# monaco-worker-manager

> Easily deal with monaco workers

Latest version **2.0.1** (published 2022-06-03) · MIT license · 0 weekly downloads

## Install

```sh
npm install monaco-worker-manager
pnpm add monaco-worker-manager
yarn add monaco-worker-manager
bun add monaco-worker-manager
```

## Health

**Score 35/100 (D)** — status: abandoned.

Positive: has types; esm support; no vulnerabilities.

Warnings: low downloads.

Negative: abandoned.

## Facts

| | |
|---|---|
| Version | 2.0.1 |
| Published | 2022-06-03 |
| First published | 2022-04-03 |
| Weekly downloads | 0 |
| License | MIT |
| TypeScript types | bundled |
| Module format | ESM |
| Dependencies | 0 |
| Unpacked size | 10.5 KB |
| Known vulnerabilities | 0 |
| Install scripts | no |
| GitHub stars | 5 |
| Author | Remco Haszing |
| Maintainers | remcohaszing |
| Keywords | monaco, monaco-editor, worker, webworker |

## Links

- npm: https://www.npmjs.com/package/monaco-worker-manager
- Repository: https://github.com/remcohaszing/monaco-worker-manager
- Homepage: https://github.com/remcohaszing/monaco-worker-manager#readme
- Issues: https://github.com/remcohaszing/monaco-worker-manager/issues
- npm.io page: https://npm.io/package/monaco-worker-manager

## Alternatives

- [cron](https://npm.io/package/cron.md) — 4.9M weekly downloads
- [@vercel/queue](https://npm.io/package/@vercel/queue.md) — 731.6K weekly downloads
- [create-sonicjs](https://npm.io/package/create-sonicjs.md) — 1.6K weekly downloads
- [@exellix/jobs-api](https://npm.io/package/@exellix/jobs-api.md) — 941 weekly downloads
- [@forwardimpact/libskill](https://npm.io/package/@forwardimpact/libskill.md) — 575 weekly downloads

## Recent versions

- 2.0.1 (latest) — 2022-06-03
- 2.0.0 — 2022-04-07
- 1.0.1 — 2022-04-03
- 1.0.0 — 2022-04-03

## README

# Monaco Worker Manager

[![ci workflow](https://github.com/remcohaszing/monaco-worker-manager/actions/workflows/ci.yaml/badge.svg)](https://github.com/remcohaszing/monaco-worker-manager/actions/workflows/ci.yaml)
[![npm version](https://img.shields.io/npm/v/monaco-worker-manager)](https://www.npmjs.com/package/monaco-worker-manager)
[![prettier code style](https://img.shields.io/badge/code_style-prettier-ff69b4.svg)](https://prettier.io)

A Monaco worker manager handles workers in a type safe manner.

## Installation

This project has a peer dependency on `monaco-editor`. It’s recommded to add it explicitly.

```sh
npm install monaco-editor monaco-editor-manager
```

## Usage

Create a module that contains a Monaco web worker, let’s call it `my.worker.ts`.

```typescript
import { initialize } from 'monaco-worker-manager/worker';
import { doValidate } from 'my-language-service';

export interface MyWorker {
  doValidate: (uri: string) => Violation[];
}

initialize<MyWorker>((ctx, options) => {
  function getModel(uri: string): worker.IMirrorModel | undefined {
    for (const model of ctx.getMirrorModels()) {
      if (String(model.uri) === uri) {
        return model;
      }
    }
  }

  return {
    doValidate(uri) {
      const model = getModel(uri);

      if (!model) {
        return [];
      }

      return doValidate(model, options);
    },
  };
});
```

Now create a monaco environment and create a worker manager in the main thread:

```typescript
import { editor, Uri } from 'monaco-editor';
import { createWorkerManager } from 'monaco-worker-manager';

import { MyWorker } from './my.worker';

const myLabel = 'myLabel';
const myModuleId = 'my.worker';

window.MonacoEnvironment = {
  getWorker(moduleId, label) {
    switch (label) {
      case 'editorWorkerService':
        return new Worker(new URL('monaco-editor/esm/vs/editor/editor.worker', import.meta.url));
      case myLabel:
        return new Worker(new URL('my.worker', import.meta.url));
      default:
        throw new Error(`Unknown label ${label}`);
    }
  },
};

const workerManager = createWorkerManager<MyWorker>({
  label: myLabel,
  moduleId: myModuleId,
});

const model = editor.createModel('Hello Monaco!', 'plaintext', Uri.parse('file:///hello.txt'));

async function main(): Promise<void> {
  const worker = await workerManager.getWorker(model.uri);
  const diagnostics = await worker.doValidate(String(model.uri));
  console.log(diagnostics);
}

main();
```

## API

This project exposes 2 modules: one to use in the main thread, another to create your own worker.

### `monaco-worker-manager#createWorkerManager(options)`

Create a worker manager.

A worker manager is an object which deals with Monaco based web workers, such as cleanups and idle
timeouts.

#### Options

- `options.createData`: The data to send over when creating the worker. (Optional)
- `options.interval` How often to check if a worker is idle in milliseconds. (Optional, default:
  `30_000`)
- `options.label`: A label to be used to identify the web worker.
- `options.moduleId`: The module id to be used to identify the web worker.
- `options.stopWhenIdleFor`: The worker is stopped after this time has passed in milliseconds. Set
  to Infinity to never stop the worker. (Optional, default: `120_000`)

#### Return value

A disposable object with the following keys:

- `getWorker(...resources: Uri[])`: An unbound method for getting the web worker.
- `updateCreateData(newCreateData)`: An unbound method which updates the create data and reloads the
  worker.

### `monaco-worker-manager/worker#initialize(fn)`

Create a web worker in a type safe manner.

The function will be called with the following arguments:

1. The Monaco worker context.
2. The create data defined by the worker manager.

## License

[MIT](https://github.com/remcohaszing/monaco-worker-manager/blob/main/LICENSE.md)

---
_Source: https://npm.io/package/monaco-worker-manager · Machine-readable twin of the npm.io package page. Health data is recomputed on every publish._