@codingame/monaco-vscode-editor-api 16.0.1 → 16.0.2

package/esm/vs/editor/editor.api.d.ts

@@ -1,7 +1,36 @@
 import { createModelReference, writeFile } from "@codingame/monaco-vscode-api/monaco";
+import type { IInternalWebWorkerOptions, MonacoWebWorker } from "../../../vscode/src/vs/editor/standalone/browser/standaloneWebWorker.js";
 export * from "../../../vscode/src/vs/editor/editor.api.js";
 declare module "../../../vscode/src/vs/editor/editor.api.js" {
     namespace editor {
         export { createModelReference, writeFile };
     }
 }
+/**
+ * Make the `createWebWorker` method backward compatible, until the monaco standalone workers are updated
+ */
+export interface IWebWorkerOptions {
+    /**
+     * The AMD moduleId to load.
+     * It should export a function `create` that should return the exported proxy.
+     */
+    moduleId: string;
+    /**
+     * The data to send over when calling create on the module.
+     */
+    createData?: unknown;
+    /**
+     * A label to be used to identify the web worker for debugging purposes.
+     */
+    label?: string;
+    /**
+     * An object that can be used by the web worker to make calls back to the main thread.
+     */
+    host?: unknown;
+    /**
+     * Keep idle models.
+     * Defaults to false, which means that idle models will stop syncing after a while.
+     */
+    keepIdleModels?: boolean;
+}
+export declare function createWebWorker<T extends object>(options: IWebWorkerOptions | IInternalWebWorkerOptions): MonacoWebWorker<T>;

package/esm/vs/editor/editor.api.js

@@ -3,6 +3,8 @@ import { languages, editor } from '../../../vscode/src/vs/editor/editor.api.js';
 export { CancellationTokenSource, Emitter, KeyCode, KeyMod, MarkerSeverity, MarkerTag, Position, Range, Selection, SelectionDirection, Token, Uri } from '../../../vscode/src/vs/editor/editor.api.js';
 import { createConfiguredEditor, createConfiguredDiffEditor, createModelReference, writeFile } from '@codingame/monaco-vscode-api/monaco';
 import { withReadyServices } from '@codingame/monaco-vscode-api/services';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { createWebWorker as createWebWorker$1 } from '../../../vscode/src/vs/editor/standalone/browser/standaloneEditor.js';
 
 const originalOnLanguage = languages.onLanguage;
 languages.onLanguage = (languageId, callback) => withReadyServices(() => originalOnLanguage(languageId, callback));
@@ -12,5 +14,46 @@ editor.create = createConfiguredEditor;
 editor.createDiffEditor = createConfiguredDiffEditor;
 editor.createModelReference = createModelReference;
 editor.writeFile = writeFile;
+let id = 0;
+function getWorker(descriptor) {
+    const label = descriptor.label || 'anonymous' + ++id;
+    const monacoEnvironment = globalThis.MonacoEnvironment;
+    if (monacoEnvironment) {
+        if (typeof monacoEnvironment.getWorker === 'function') {
+            return monacoEnvironment.getWorker('workerMain.js', label);
+        }
+        if (typeof monacoEnvironment.getWorkerUrl === 'function') {
+            const workerUrl = monacoEnvironment.getWorkerUrl('workerMain.js', label);
+            return new Worker(workerUrl, { name: label, type: 'module' });
+        }
+    }
+    throw new Error(`You must define a function MonacoEnvironment.getWorkerUrl or MonacoEnvironment.getWorker`);
+}
+function isIWebWorkerOptions(options) {
+    return 'moduleId' in options;
+}
+const originalCreateWebWorker = editor.createWebWorker;
+function createWebWorker(options) {
+    if (isIWebWorkerOptions(options)) {
+        const worker = getWorker({
+            esmModuleLocation: URI.parse(options.moduleId),
+            label: options.label
+        });
+        const webworker = createWebWorker$1({
+            worker,
+            host: options.host,
+            keepIdleModels: options.keepIdleModels
+        });
+        void (async () => {
+            const proxy = await webworker.getProxy();
+            proxy.$initialize(options.createData);
+        })();
+        return webworker;
+    }
+    else {
+        return originalCreateWebWorker(options);
+    }
+}
+editor.createWebWorker = createWebWorker;
 
-export { editor, languages };
+export { createWebWorker, editor, languages };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-editor-api",
-  "version": "16.0.1",
+  "version": "16.0.2",
   "private": false,
   "description": "VSCode public API plugged on the monaco editor - monaco-editor compatible api",
   "keywords": [],
@@ -15,8 +15,8 @@
   },
   "type": "module",
   "dependencies": {
-    "@codingame/monaco-vscode-5452e2b7-9081-5f95-839b-4ab3544ce28f-common": "16.0.1",
-    "@codingame/monaco-vscode-api": "16.0.1"
+    "@codingame/monaco-vscode-5452e2b7-9081-5f95-839b-4ab3544ce28f-common": "16.0.2",
+    "@codingame/monaco-vscode-api": "16.0.2"
   },
   "exports": {
     ".": "./esm/vs/editor/editor.api.js",

package/vscode/src/vs/editor/standalone/browser/standaloneWebWorker.js

@@ -14,6 +14,9 @@ class MonacoWebWorkerImpl extends EditorWorkerClient {
                     if (typeof prop !== 'string') {
                         throw ( new Error(`Not supported`));
                     }
+                    if (prop === 'then') {
+                        return undefined;
+                    }
                     return (...args) => {
                         return proxy.$fmr(prop, args);
                     };