open-index/open-npm huggingface dataset:
npm package: @gltf-transform/lib
Description: Library of functions built on the core glTF-Transform API
Author: Don McCurdy
Latest version: 0.10.3
Deprecated: Renamed to @gltf-transform/functions in v0.11+.

# @gltf-transform/lib

[![Latest NPM release](https://img.shields.io/npm/v/@gltf-transform/lib.svg)](https://www.npmjs.com/package/@gltf-transform/lib)
[![Minzipped size](https://badgen.net/bundlephobia/minzip/@gltf-transform/lib)](https://bundlephobia.com/result?p=@gltf-transform/lib)
[![License](https://img.shields.io/npm/l/@gltf-transform/core.svg)](https://github.com/donmccurdy/glTF-Transform/blob/master/LICENSE)

Part of the glTF-Transform project.

- GitHub: https://github.com/donmccurdy/glTF-Transform
- Project Documentation: https://gltf-transform.donmccurdy.com/
- Package Documentation: https://gltf-transform.donmccurdy.com/library.html

## Installation

Install:

```
npm install --save @gltf-transform/lib
```

Import:

```js
// ES6
import { dedup } from '@gltf-transform/lib';

// CommonJS
const { dedup } = require('@gltf-transform/lib');

// Use.
await document.transform(dedup({textures: true, accessors: false}));
```
npm package: @glu/cli
Description: Graph Link Utility
Author: Alex Yuly
Latest version: 0.0.0-alpha.0

# glu

Graph Link Utility

## Install glu CLI (command line utility)

`npm i -g @glu/cli`

## Run example applications

- `glu examples/HelloWorld.yml --start`
- `glu examples/PrintSomething.yml --print 'Welcome to glu!'`
npm package: @glua-addon-types/flex
Description: types for FLEX
Author: SupinePandora43
Latest version: 1.1.0

# flex
`package.json`:
```json
{
	"devDependencies": {
		"@glua-addon-types/flex": "^1.1.0"
	}
}
```
`tsconfig.json`:
```
{
	"compilerOptions": {
		"target": "ESNext",
		"lib": [ "ESNext" ],
		"types": [
			"@glua-addon-types/FLEX/index"
		]
	}
}
```
npm package: @glua-addon-types/glua-types
Description: Typings generation for garrysmod
Latest version: 0.1.2

<div align="center">

[![NPM version](https://img.shields.io/npm/v/@glua-ts/types.svg?style=flat)](https://www.npmjs.com/package/@glua-ts/types)
[![NPM downloads](https://img.shields.io/npm/dm/@glua-ts/types.svg?style=flat)](https://www.npmjs.com/package/@glua-ts/types) [![Known Vulnerabilities](https://snyk.io/test/github/glua-ts/types/badge.svg)](https://snyk.io/test/github/glua-ts/types)


</div>

<div align="center">

[![Conventional Commits](https://img.shields.io/badge/Conventional%20Commits-1.0.0-yellow.svg)](https://conventionalcommits.org) [![js-standard-style](https://img.shields.io/badge/Code%20Style-Standard-brightgreen.svg?style=flat)](http://standardjs.com/) [![Security Responsible
Disclosure](https://img.shields.io/badge/Security-Responsible%20Disclosure-yellow.svg)](https://github.com/nodejs/security-wg/blob/master/processes/responsible_disclosure_template.md)

</div>


# @glua-ts/types

Tool to generate typescript definitions for garrysmod.

For use with [Typescript To Lua](https://github.com/Perryvw/TypescriptToLua)

The first run will take a while because all pages need to get fetched from the gmod wiki. Executions after that shouldnt take longer than a couple of seconds.

Caches wiki pages into `./data` and generates declarations in `./typings`

If you want to refresh your cache just delete the `./data` folder and rerun.

to install *just* the typings run

```
npm install --save-dev @glua-ts/types
```
npm package: @glua-addon-types/rule34js
Description: typings for rule34js lua addon
Author: SupinePandora43
Latest version: 1.0.0

# @glua-addon-types/rule34js

Definitions for https://steamcommunity.com/sharedfiles/filedetails/?id=2162211415

it defines global function, and module `autorun/rule34js.lua`
`package.json`:```json
{
	"devDependencies": {
		"@glua-addon-types/rule34js": "1.0.0"
	}
}
```
`tsconfig.json`:```json
{
    "compilerOptions":{
        "types": [
			"@glua-addon-types/rule34js/index"
		]
    }
}
```
npm package: @glua-ts/types
Description: Typings generation for garrysmod
Author: Nurdism
Latest version: 0.1.0

<div align="center">

[![NPM version](https://img.shields.io/npm/v/@glua-ts/types.svg?style=flat)](https://www.npmjs.com/package/@glua-ts/types)
[![NPM downloads](https://img.shields.io/npm/dm/@glua-ts/types.svg?style=flat)](https://www.npmjs.com/package/@glua-ts/types) [![Known Vulnerabilities](https://snyk.io/test/github/glua-ts/types/badge.svg)](https://snyk.io/test/github/glua-ts/types)


</div>

<div align="center">

[![Conventional Commits](https://img.shields.io/badge/Conventional%20Commits-1.0.0-yellow.svg)](https://conventionalcommits.org) [![js-standard-style](https://img.shields.io/badge/Code%20Style-Standard-brightgreen.svg?style=flat)](http://standardjs.com/) [![Security Responsible
Disclosure](https://img.shields.io/badge/Security-Responsible%20Disclosure-yellow.svg)](https://github.com/nodejs/security-wg/blob/master/processes/responsible_disclosure_template.md)

</div>


# @glua-ts/types

Tool to generate typescript definitions for garrysmod.

For use with [Typescript To Lua](https://github.com/Perryvw/TypescriptToLua)

The first run will take a while because all pages need to get fetched from the gmod wiki. Executions after that shouldnt take longer than a couple of seconds.

Caches wiki pages into `./data` and generates declarations in `./typings`

If you want to refresh your cache just delete the `./data` folder and rerun.

to install *just* the typings run

```
npm install --save-dev @glua-ts/types
```
npm package: @gluck/preact-custom-element
Description: Wrap your component up as a custom element
Latest version: 3.1.3

# preact-custom-element

Generate/register a custom element from a preact component. As of 3.0.0, this library implements the Custom Elements v1 spec.
Previous versions (< 3.0.0) implemented the v0 proposal, which was only implemented in Chrome and is abandoned.

## Usage

Import `CustomElement` and call with your component a tag name __\*__, and a list of attribute names you want to observe:

```javascript
import register from 'preact-custom-element';

const Greeting = ({ name = 'World' }) => (
  <p>Hello, {name}!</p>
);

register(Greeting, 'x-greeting', ['name']);
```

> _**\* Note:** as per the [Custom Elements specification](http://w3c.github.io/webcomponents/spec/custom/#prod-potentialcustomelementname), the tag name must contain a hyphen._

Use the new tag name in HTML, attribute keys and values will be passed in as props:

```html
<x-greeting name="Billy Jo"></x-greeting>
```

Output:

```html
<p>Hello, Billy Jo!</p>
```

### Prop Names and Automatic Prop Names

The Custom Elements V1 specification requires explictly stating the names of any attributes you want to observe. From your Preact component perspective, `props` could be an object with any keys at runtime, so it's not always clear which props should be accepted as attributes.

If you omit the third parameter to `register()`, the list of attributes to observe can be specified using a static `observedAttributes` property on your Component. This also works for the Custom Element's name, which can be specified using a `tagName` static property:

```js
import register from 'preact-custom-element';

// <x-greeting name="Bo"></x-greeting>
class Greeting extends Component {
  // Register as <x-greeting>:
  static tagName = 'x-greeting';

  // Track these attributes:
  static observedAttributes = ['name'];

  render({ name }) {
    return <p>Hello, {name}!</p>;
  }
}
register(Greeting);
```

If no `observedAttributes` are specified, they will be inferred from the keys of `propTypes` if present on the Component:

```js
// Other option: use PropTypes:
function FullName(props) {
  return <span>{props.first} {props.last}</span>
}
FullName.propTypes = {
  first: Object,   // you can use PropTypes, or this
  last: Object     // trick to define untyped props.
};
register(FullName, 'full-name');
```


## Related

[preact-shadow-dom](https://github.com/bspaulding/preact-shadow-dom)
npm package: @gluck/vue-color
Description: Color of Vue Components
Author: xiaokai
Latest version: 2.7.0-1

# vue-color 

[![npm](https://img.shields.io/npm/v/vue-color.svg)](https://www.npmjs.com/package/vue-color)

Color Pickers for Sketch, Photoshop, Chrome & more with Vue.js(vue2.0).  

## [Live demo](http://xiaokaike.github.io/vue-color/)

![intro](./intro.png)

## Installation

### NPM
```bash
$ npm install vue-color
```

### CommonJS
```js
var Photoshop = require('vue-color/src/Photoshop.vue');

new Vue({
  components: {
    'Photoshop': Photoshop
  }
})
```

### ES6
```js
import { Photoshop } from 'vue-color'

new Vue({
  components: {
    'photoshop-picker': Photoshop
  }
})
```

### Browser globals
The `dist` folder contains `vue-color.js` and `vue-color.min.js` with all components exported in the <code>window.VueColor</code> object. These bundles are also available on NPM packages.

```html
<script src="path/to/vue.js"></script>
<script src="path/to/vue-color.min.js"></script>
<script>
  var Photoshop = VueColor.Photoshop
</script>
```

## Local setup

```
npm install
npm run dev
```

## Usage

```js

var colors = {
  hex: '#194d33',
  hsl: { h: 150, s: 0.5, l: 0.2, a: 1 },
  hsv: { h: 150, s: 0.66, v: 0.30, a: 1 },
  rgba: { r: 25, g: 77, b: 51, a: 1 },
  a: 1
}
// or
var colors = '#194d33'
// or 
var colors = { h: 150, s: 0.66, v: 0.30 }
// or 
var colors = { r: 255, g: 0, b: 0 }
// etc...

new Vue({
  el: '#app',
  components: {
    'material-picker': material,
    'compact-picker': compact,
    'swatches-picker': swatches,
    'slider-picker': slider,
    'sketch-picker': sketch,
    'chrome-picker': chrome,
    'photoshop-picker': photoshop
  },
  data () {
    return {
      colors
    }
  }
})

```

`colors` accepts either a string of a hex color '#333' or a object of rgb or hsl values `{ r: 51, g: 51, b: 51 }` or `{ h: 0, s: 0, l: .10 }`, whatever [tinycolor2](https://www.npmjs.com/package/tinycolor2) accepts as an input.

```html
<!-- suppose you have the data 'colors' in your component -->
<material-picker v-model="colors" />
<compact-picker v-model="colors" />
<swatches-picker v-model="colors" />
<slider-picker v-model="colors" />
<sketch-picker v-model="colors" />
<chrome-picker v-model="colors" />
<photoshop-picker v-model="colors" />
```

OR

```html
<chrome-picker :value="colors" @input="updateValue"></chrome-picker>
```

In some cases you can give the component a predefined set of colors with the property `presetColors` (for `Sketch` only) or `palette` (for `Compact` and `Grayscale`), by simply passing it an array with the color values as strings in any css compatible format.

```html
<sketch-picker 
  @input="updateValue"
  :value="colors"
  :presetColors="[ 
    '#f00', '#00ff00', '#00ff0055', 'rgb(201, 76, 76)', 'rgba(0,0,255,1)', 'hsl(89, 43%, 51%)', 'hsla(89, 43%, 51%, 0.6)'
  ]"
></sketch-picker>

<compact-picker 
  @input="updateValue"
  :value="colors"
  :palette="[ 
    '#f00', '#00ff00', '#00ff0055', 'rgb(201, 76, 76)', 'rgba(0,0,255,1)', 'hsl(89, 43%, 51%)', 'hsla(89, 43%, 51%, 0.6)'
  ]"
></compact-picker>
```

## License

vue-color is licensed under [The MIT License](LICENSE).
npm package: @glue42/bbg-market-data
Description: A high-level API that wraps existing Glue42 Bloomberg Bridge Market Data interop methods. The API is based on the jBloomberg open source wrapper.
Author: Glue42
Latest version: 0.9.0

## Overview

A high-level API that wraps existing Glue42 Bloomberg Bridge Market Data interop methods. The API is based on the jBloomberg open source wrapper.

## Initialization

The BBGMarketData API depends on the Glue42 [Interop](https://docs.glue42.com/glue42-concepts/data-sharing-between-apps/interop/overview/index.html) API. It also accepts a config object to control logging behavior, optionally provide a custom logger implementation and session settings to overwrite default session options and session identity options. 

```typescript
import BBGMarketData, {
  BBGMarketDataAPI,
  SessionOptions,
  FieldSearchRequestArguments,
  FieldSearchRequest,
  ResponseData,
  FieldSearchData
} from "@glue42/bbg-market-data";
import Glue from "@glue42/desktop";

const glue = await Glue();

const sessionOptions: SessionOptions = {
  connectTimeout: 15000
}
const bbgMarketData: BBGMarketDataAPI = BBGMarketData(glue.interop, {
  debug: true, // Enable only if you need logging.
  sessionSettings: {
    options: sessionOptions
  }
});

// Start using the library.
```

Example (creating a FieldSearchRequest request):

```typescript
const requestArgs: FieldSearchRequestArguments = {
  searchSpec: "last price",
  returnFieldDocumentation: true
};

const request: FieldSearchRequest = bbgMarketData.createFieldSearchRequest(
  requestArgs
);

request.onData(function handleResponse(
  response: ResponseData<FieldSearchData>
): void {
  if (response.isLast) {
    // Handle final response
  } else {
    // Handle partial response
  }
});

request.onError(function handleError(error): void {
  // Request failed. Process the error.
});

// Send the actual request to Bloomberg.
request
  .open()
  .then((response: FieldSearchData[] | undefined) => {
    //Request completed. Process aggregated response.
  })
  .catch((error) => {
    // Request failed. Process the error.
  });
```
npm package: @glue42/cli-core
Description: Glue42 Core development environment CLI
Latest version: 1.3.1

# Glue42 Core CLI

The Glue42 CLI is a command line tool designed to simplify your development process with **Glue42 Core**. The Glue42 CLI allows you to quickly start a new **Glue42 Core** project or integrate **Glue42 Core** into an existing project. You can also use the built-in dev server to serve your applications and **Glue42 Core** assets. Finally, the Glue42 CLI allows you to easily create a **Glue42 Core** bundle ready for deployment.

For detailed information on the installation, configuration and usage, see the [Glue42 CLI](https://docs.glue42.com/core/core-concepts/cli/index.html) documentation.
npm package: @glue42/desktop
Description: Glue42 desktop library
Author: Glue42
Latest version: 5.26.0

# Intro

@glue42/desktop is a JavaScript library that allows glue-enabled applications to interact with each other and to access [Glue42 Desktop](https://glue42.com/) functionalities.

@glue42/desktop includes the following modules:
* data sharing between applications:
    * **interop** - offer/consume functionality to/from other applications (JavaScript and native) by registering Interop methods and stream
    * **contexts** - share named data objects between applications
    * **activities** - an activity is a collection of windows organized in a layout and sharing a private context
    * **channels** - globally accessed named contexts that allow users to dynamically group applications, instructing them to work over the same shared data object
    * **pub/sub** - basic pub/sub API that allow apps to publish/subscribe for messages on a specific topic
* **application management** - manage and monitor Glue42 applications
* **layouts** - layouts allows you to save the arrangement of any set of applications running in Glue42 Desktop and later restore it
* **windows management** - lets you create and manipulate windows
* **hotkeys** - allows applications to register key combinations and receive notifications when a key combination is pressed by the user irrespective of whether the application is on focus or not
* **metrics** - a way of assessing the life cycle of a certain process (application performance, business process, employee productivity etc.) by acquiring, recording and monitoring over time specific data about the key performance indicators of the said process.

For more information check [Glue42 documentation](https://docs.glue42.com).

# Usage

```javascript
import Glue from "@glue42/desktop";

// configuration will be inferred from your application configuration
Glue({})
    .then((glue) => {
        // use glue library
    })
    .catch((error) => {
        // handle errors
    });
```
npm package: @glue42/electron
Description: Glue42 Electron library
Author: Glue42
Latest version: 0.1.6

This package allows you to [Glue42](glue42.com) enable your [Electron](https://www.electronjs.org/) application.

# Basic Usage

1. Install the package

```sh
npm i @glue42/electron
```

2. Initialize the package in the **main** process of your Electron app, **after** Electron's app ready event.

```javascript
import * as glue42Electron from '@glue42/electron';

...

const config = {
    appDefinition: {
        name: 'desktop-electron-app',
        title: 'Desktop Electron App'
    }
}
const glue = await glue42Electron.initialize(config);
```

3. When your Electron window is ready, register it with Glue42

```javascript
const gdMainWindow = glue.registerStartupWindow(this.mainWindow, {allowChannels: true, channelId: "Red"});
```

When you do this and you run yor app, the package will:

* discover any running Glue42 instance, and connect to it
* inject glue42 API into any window of your app
* your main Window will become sticky and now you can stick it to any Glue42 windows


# Advanced

## Inject FDC3
By default the lib will inject Glue42 API into any window - if you want to change this and inject FDC3 you need to set *inject* option to "fdc3" when initializing the lib

```javascript
const glue = await glue42Electron.initialize({ inject: "fdc3" });
```

## Starting option - when the application is started from Glue42 Application Manager

```javascript
const options = glue.startupOptions;
const context = options.context
const windowOptions = options.windowOptions;
```

You can also disable any injection by setting the option to *none*.

## Application Factories

You can register your app as factory for certain window types, e.g. if you have a Chat Window in your app, you might want to allow other apps to create this window with a given context.
To do so you can register an appFactory

```javascript
 glue.registerAppFactory(
    {
      name: "child-app-electron",
      title: "Glue42 Electron Child Application"
    }, function(appDefinition, context, glue42electron) {
      // if you want some window options to override - you can use this
      // this.title = "my special title"
      // the first parameter is the app definition
      // the second one is the context - when restoring, starting with context
      // the third one is the service object which should be inject in the renderer, when preload: false
      // should return the newly created BrowserWindow
      const bw = new BrowserWindow();
      return bw;
    })
```
## Registering a Child Window

```javascript
const bw = new BrowserWindow();
 const glueWindow = glue.registerChildWindow(bw, {
        name: "child-app-electron-2",
        title: "Glue42 Electron Child Application"
      }, {
          mode: "tab",
          left: 100,
          top: 100,
          width: 400,
          height: 400
        }
      })
```
npm package: @glue42/fdc3
Description: Glue42 implementation of the FDC3 standard
Author: Glue42
Latest version: 3.2.3

# Glue42 FDC3

Glue42 FDC3 is a JavaScript implementation of the [FDC3](https://fdc3.finos.org/docs/1.1/fdc3-intro) standard for [Glue42 Core](https://core-docs.glue42.com/getting-started/what-is-glue42-core/index.html) and [Glue42 Enterprise](https://docs.glue42.com/getting-started/what-is-glue42/general-overview/index.html).

## What is FDC3?

The mission of FDC3 is to develop specific protocols and classifications to advance the ability of desktop applications in financial workflows to interoperate in a plug-and-play fashion without prior bilateral agreements.

## Useful Links

You can find the FDC3 specification [here](https://fdc3.finos.org/).

You can find more information on the Glue42 FDC3 library [here](https://core-docs.glue42.com/getting-started/fdc3-compliance/index.html).
npm package: @glue42/groups-ui-react
Description: React version of the groups ui library
Author: Glue42
Latest version: 1.4.3

## Overview

The `@glue42/groups-ui-react` library enables you to create your own Web Group App for [**Glue42 Enterprise**](https://glue42.com/enterprise/). It provides all necessary functionalities as a single React component - `<Group />`. The library allows complete customization of the Glue42 Window group elements and the elements of the different types of Glue42 Windows (flat, tab and HTML) participating in the group. The provided default components can be replaced or extended with your custom ones.

## Install

To use the library in your project, execute the following command:

```cmd
npm install @glue42/groups-ui-react
```

## Usage

The following example demonstrates a basic usage of the `<Group />` component:

```javascript
import React from 'react'
import Group from "@glue42/groups-ui-react";
import "@glue42/groups-ui-react/dist/styles/styles.css";

const App = () => {
  return <Group />
};

export default App;
```
npm package: @glue42/intents-resolver-api
Description: Glue42 Intents Resolver
Author: Glue42
Latest version: 1.2.2

# Glue42 Intents Resolver

The **Glue42 Intents Resolver** library offers a way to create custom Intents Resolver. This application is used to provide the user with a list of all available applications and running instances which can handle a raised intent.<br>
**Intents Resolver** is enabled by default. You can use our template [**Glue42 Intents Resolver UI**](https://github.com/Glue42/core/tree/master/templates/intents-resolver) application. Copy the project, build it and serve it. Then, reference its application definition in your **Glue42 Web Platform** configuration. Now each application whish raises an intent will use **Intents Resolver**.
npm package: @glue42/product-theme
Description: Glue42 Product theme
Author: Glue42
Latest version: 0.0.11

# Glue42 UI kit
## Overview
The Glue42 UI kit is designed to fit the new Launch Experience for the Glue42 Platform. Keeps UI components for workspaces, web groups, and all system applications of the product.

## Usage

```cmd
npm install @glue42/product-theme
```
## Themes
- Add `dark` or `light` class to the `<html>` tag.

### HTML 

```html
<!DOCTYPE HTML>
    <html lang="en" class="dark">
        <head>
            <link rel="stylesheet" href="../glue42-product-theme.css">
            <link rel="stylesheet" href="./custom-style.css">
        </head>
    <!-- your app -->
</html>
```
npm package: @glue42/search-api
Description: Glue42 Search API
Author: Glue42
Latest version: 1.3.2

# Glue42 Search API

/* eslint-disable @typescript-eslint/no-explicit-any */

// package name: @glue42/search-api -> adds the Search API

// @glue42/web-platform -> can use the package to register as a provider or use as a client
// @glue42/web -> can use the package to register as a provider or use as a client
// @glue42/core-plus -> by default register as a provider for applications, workspaces, layouts and optionally actions
// GD3 -> by default register as a provider for applications, workspaces, layouts and optionally actions

// Foundation: Interop and Shared Context
// lib registers: lazily two methods
// lib uses: shared context to providers state management
// method used when registered as provider to accept queries

// category = display name for type
npm package: @glue42/web
Description: Glue42 Core client application package
Author: Glue42
Latest version: 2.24.1

# Glue42 Web

The [**Glue42 Web**](https://core-docs.glue42.com/reference/core/latest/glue42%20web/index.html) library is used in a [**Glue42 Core**](https://core-docs.glue42.com/getting-started/what-is-glue42-core/index.html) project to connect the [Glue42 Client](https://core-docs.glue42.com/developers/core-concepts/glue42-client/overview/index.html) applications to the [Glue42 Environment](https://core-docs.glue42.com/developers/core-concepts/environment/overview/index.html). It offer sets of APIs through which the connected applications can share data and control window behavior.

For more information on the Glue42 Web library and **Glue42 Core**, see:

- [Glue42 Web API](https://core-docs.glue42.com/reference/core/latest/glue42%20web/index.html) - reference documentation for the GLue42 Web APIs;
- [Glue42 Client](https://core-docs.glue42.com/developers/core-concepts/glue42-client/overview/index.html) - information on what a Glue42 Client is and how to create and set up one;
- [Quick Start](https://core-docs.glue42.com/getting-started/quick-start/index.html) - a quick walk-through on how to create your first **Glue42 Core** project using the Glue42 Web library;
npm package: @glue42/web-platform
Description: Glue42 Core main application package
Author: Glue42
Latest version: 1.27.2

## Glue42 Web Platform

A Web Platform application (or "Main application") in the context of **Glue42 Core** is a web application that uses the [`@glue42/web-platform`](https://www.npmjs.com/package/@glue42/web-platform) package. This app is responsible for configuring the entire Glue42 environment and acts as a central hub for all [Web Client](https://core-docs.glue42.com/core-concept/web-client/overview/index.html) apps in your **Glue42 Core** project. All Glue42 operations are routed through this Main application, meaning that this is the place where you can get centralized logging, information about all operations and details about the general state of your project. The configuration for all Glue42 libraries (e.g., Application Management, Layouts, Workspaces, Plugins, Notifications) is handled here.

The Main application also provides tracking and control over non-Glue42 applications opened through it. The level of control is limited, but all basic operations are available - open, close, receiving events, listing, adding and manipulating via [Workspaces](https://core-docs.glue42.com/capabilities/windows/workspaces/overview/index.html).

If the Main application is closed, all [Web Client](https://core-docs.glue42.com/core-concept/web-client/overview/index.html) applications will lose their connection to Glue42 and therefore - all Glue42 capabilities. Opening the Main app again *won't reestablish the connection*, because this will effectively be an entirely new window with a new session and new context. However, if the Main application is *refreshed*, the existing [Web Client](https://core-docs.glue42.com/core-concept/web-client/overview/index.html) apps will detect that and *will reconnect* as soon as the Main app is back online.
npm package: @glue42/web-worker
Description: Glue42 Core service worker module
Author: Glue42
Latest version: 1.3.0

# Glue42 Core Service Worker Module

## Overview

@glue42/web-worker is a library, which is designed to be imported into a service worker file. The library enables the advanced notifications functionality of Glue42 Core, which requires a Service Worker.

## Getting Started

The package can be added to a service worker file in two ways. One is by using the `importScripts()` method attached to the `self` global object in the Service Worker scope. The library will then define and attach to the `self` object a number of stateless functions.

The other way is to import the package just like any other JS package in your existing service worker project. Then you can build it and the output should be a single .js file, ready to be registered as a service worker.

## Usage

The library gives access to three functions:
- self.GlueWebWorker or default export - this function initializes the package and registers the necessary event listeners to correctly capture and process notification clicks
- self.openCorePlatform or {openCorePlatform} - this function accepts a url and will open and wait for the platform app to be fully operational
- self.raiseGlueNotification or {raiseGlueNotification} - this function accepts a Glue42 Core notification settings object and will raise the notification.
npm package: @glue42/worker-web
Description: Glue42 Core shared worker
Author: Glue42
Latest version: 1.0.6

# Shared Worker

The Shared Worker is a script which is used to create a [Shared Web Worker](https://developer.mozilla.org/en-US/docs/Web/API/SharedWorker). This is the central point to which all [Glue42 Clients](https://docs.glue42.com/core/core-concepts/glue42-client/overview/index.html) connect when initializing the [Glue42 Web](https://docs.glue42.com/reference/core/latest/glue42%20web/index.html) library. It is responsible for configuring, initializing and linking Glue42 Clients to the [Glue42 Gateway](https://docs.glue42.com/core/core-concepts/environment/overview/index.html#glue42_gateway).

The Shared Worker uses the `glue.config.json` configuration file to get user-defined settings for the Glue42 Gateway.

**Important!** The Shared Worker will expect to find a configuration file at `./glue.config.json`. Due to the current limitations of the Shared Web Worker interface, passing a different config file location is not an option. Therefore, if this file is not found at that location, the worker will proceed with the default settings for the Glue42 Gateway.
npm package: @glue42/workspaces-api
Description: Glue42 Core workspaces API
Author: Glue42
Latest version: 1.24.1

# Glue42 Workspaces API

The **Workspaces** library offers advanced window management functionalities. Using Workspaces, users are able to arrange multiple applications within the same visual window (called **Frame**). This arrangement can be performed programmatically or by dragging and dropping applications within the Frame. Users can also save Workspace layouts and restore them within the same Frame or even in different Frames.

The Glue42 Workspaces enable the users to compose a custom arrangement of applications by treating each application as an individual building block that can be added, removed, moved or resized within a Workspace. The Frame can hold multiple Workspaces (as tabs) and can also be maximized, minimized or resized. 

*For detailed information on the Workspaces API, see the [**Workspaces**](https://core-docs.glue42.com/capabilities/windows/workspaces/overview/index.html) documentation.*
npm package: @glue42/workspaces-app
Description: Glue42's PWA implementation of Workspaces
Author: Glue42
Latest version: 1.2.6

# Workspaces-app

## Description
The `workspaces-app` is a vanilla web application which wraps `@glue42/golden-layout` and implements the `workspaces-api` protocol while providing the user with a PWA Workspaces experience.

## Usage
Please go to [Glue42 Core's website](https://docs.glue42.com/core/what-is-glue42-core/index.html) for more information.
npm package: @glue42/workspaces-ui-core
Description: Glue42's vanilla JS implementation of the workspaces ui component
Author: Glue42
Latest version: 1.21.1

# @glue42/workspaces-ui-core

## Description
`@glue42/workspaces-ui-core`is a js library which wraps `@glue42/golden-layout` and implements the `@glue42/workspaces-api` protocol while providing an API used in `@glue42/workspaces-ui-react`.

## Usage
Please go to [Glue42 Core's website](https://core-docs.glue42.com/getting-started/what-is-glue42-core/index.html) for more information.
npm package: @glue42/workspaces-ui-react
Description: React version of the workspaces ui component.
Latest version: 2.8.1

# @glue42/workspaces-ui-react

> React version of workspaces


## Install

```bash
npm install --save @glue42/workspaces-ui-react @glue42/react-hooks
```

## Usage

```tsx
import React, { Component } from 'react'
import Workspaces from '@glue42/workspaces-ui-react'
import "@glue42/workspaces-ui-react/dist/styles/popups.css";
import "@glue42/workspaces-ui-react/dist/styles/goldenlayout-base.css";
import "@glue42/workspaces-ui-react/dist/styles/glue42-theme.css";

class Example extends Component {
  render() {
    return <Workspaces />
  }
}
```

## License

MIT © [](https://github.com/)
npm package: @gluebi/vue-resilient-error-boundary
Description: Vue 3 error boundary that freezes DOM on error instead of unmounting content
Latest version: 1.0.0

# @gluebi/vue-resilient-error-boundary

Vue 3 error boundary that **freezes DOM on error** instead of unmounting content.

When a child component throws, this component:

1. Snapshots the current DOM (taken on mount and refreshed on error)
2. Replaces the live component tree with frozen HTML via `v-html`
3. Blocks interaction with a `pointer-events: none` overlay and `cursor: not-allowed`
4. Emits an `@error` event for the consumer to handle logging

No existing Vue/Nuxt library does this — every error boundary unmounts content and shows a fallback. This component preserves what the user was seeing.

## Install

```bash
pnpm add @gluebi/vue-resilient-error-boundary
```

## Usage (Vue 3)

```vue
<script setup>
import { ResilientErrorBoundary } from '@gluebi/vue-resilient-error-boundary'
import '@gluebi/vue-resilient-error-boundary/style.css'
</script>

<template>
  <ResilientErrorBoundary context="product-tile-42" @error="handleError">
    <ProductTile :product="product" />
  </ResilientErrorBoundary>
</template>
```

## Usage (Nuxt 3)

```ts
// nuxt.config.ts
export default defineNuxtConfig({
  modules: ['@gluebi/vue-resilient-error-boundary/nuxt'],
})
```

The Nuxt module auto-imports the component and CSS. No manual imports needed:

```vue
<template>
  <ResilientErrorBoundary context="product-tile-42" @error="handleError">
    <ProductTile :product="product" />
  </ResilientErrorBoundary>
</template>
```

## Enriched logging with provide/inject

For parent-level error handlers with enriched context (e.g., container data for Datadog):

```ts
import { RESILIENT_ERROR_HANDLER_KEY } from '@gluebi/vue-resilient-error-boundary'

// In a parent/wrapper component:
provide(RESILIENT_ERROR_HANDLER_KEY, (error: Error, context: string) => {
  logger.error('tile-error', { error, context, containerData })
})
```

The handler receives the normalized `Error` object and the `context` string from the boundary.

## Props

| Prop | Type | Default | Description |
|------|------|---------|-------------|
| `context` | `string` | `'unknown'` | Identifier passed to `@error` and the injected handler |

## Events

| Event | Payload | Description |
|-------|---------|-------------|
| `error` | `Error` | Emitted when a child component throws |

## How it works

- Uses `display: contents` on wrapper elements — invisible to CSS grid/flexbox
- Snapshots `innerHTML` on mount and refreshes in `onErrorCaptured` (before state change)
- Uses Vue's `onErrorCaptured` directly (not wrapping `NuxtErrorBoundary`)
- Returns `false` from `onErrorCaptured` to stop error propagation
- Frozen content has `pointer-events: none` with a `::after` overlay using `pointer-events: auto` and `cursor: not-allowed`

## Requirements

- Vue 3.5+
- Nuxt 3+ (optional, for module usage)