@codingame/monaco-vscode-standalone-html-language-features 23.1.1 → 23.2.1

package/common/initialize.js

@@ -0,0 +1,11 @@
+import { start } from 'monaco-editor/esm/vs/editor/editor.worker.start.js';
+
+function initialize(callback) {
+  self.onmessage = (m) => {
+    start((ctx) => {
+      return callback(ctx, m.data);
+    });
+  };
+}
+
+export { initialize };

package/common/workers.d.ts

@@ -0,0 +1,29 @@
+import { editor } from "@codingame/monaco-vscode-api/vscode/vs/editor/editor.api.js";
+declare function createWebWorker<T extends object>(opts: IWebWorkerOptions): editor.MonacoWebWorker<T>;
+interface IWebWorkerOptions {
+    /**
+     * The AMD moduleId to load.
+     * It should export a function `create` that should return the exported proxy.
+     */
+    moduleId: string;
+    createWorker?: () => Worker;
+    /**
+     * The data to send over when calling create on the module.
+     */
+    createData?: any;
+    /**
+     * 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?: any;
+    /**
+     * Keep idle models.
+     * Defaults to false, which means that idle models will stop syncing after a while.
+     */
+    keepIdleModels?: boolean;
+}
+export { createWebWorker };
+export type { IWebWorkerOptions };

package/common/workers.js

@@ -0,0 +1,70 @@
+
+import { editor } from 'monaco-editor';
+
+function createTrustedTypesPolicy(policyName, policyOptions) {
+  const monacoEnvironment = globalThis.MonacoEnvironment;
+  if (monacoEnvironment?.createTrustedTypesPolicy) {
+    try {
+      return monacoEnvironment.createTrustedTypesPolicy(policyName, policyOptions);
+    } catch (err) {
+      console.error(err);
+      return void 0;
+    }
+  }
+  try {
+    return globalThis.trustedTypes?.createPolicy(policyName, policyOptions);
+  } catch (err) {
+    console.error(err);
+    return void 0;
+  }
+}
+let ttPolicy;
+if (typeof self === "object" && self.constructor && self.constructor.name === "DedicatedWorkerGlobalScope" && globalThis.workerttPolicy !== void 0) {
+  ttPolicy = globalThis.workerttPolicy;
+} else {
+  ttPolicy = createTrustedTypesPolicy("defaultWorkerFactory", {
+    createScriptURL: (value) => value
+  });
+}
+function getWorker(descriptor) {
+  const label = descriptor.label;
+  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(
+        ttPolicy ? ttPolicy.createScriptURL(workerUrl) : workerUrl,
+        { name: label, type: "module" }
+      );
+    }
+  }
+  if (descriptor.createWorker) {
+    return descriptor.createWorker();
+  }
+  throw new Error(
+    `You must define a function MonacoEnvironment.getWorkerUrl or MonacoEnvironment.getWorker`
+  );
+}
+function createWebWorker(opts) {
+  const worker = Promise.resolve(
+    getWorker({
+      label: opts.label ?? "monaco-editor-worker",
+      moduleId: opts.moduleId,
+      createWorker: opts.createWorker
+    })
+  ).then((w) => {
+    w.postMessage("ignore");
+    w.postMessage(opts.createData);
+    return w;
+  });
+  return editor.createWebWorker({
+    worker,
+    host: opts.host,
+    keepIdleModels: opts.keepIdleModels
+  });
+}
+
+export { createWebWorker };