modern-monaco 0.1.8 → 0.2.0

package/dist/lsp/typescript/{setup.js → setup.mjs}

@@ -94,11 +94,11 @@ function isSameImports(a, b) {
 }
 
 // src/lsp/typescript/setup.ts
-import { cache } from "../../cache.js";
-import { ErrorNotFound } from "../../workspace.js";
-import * as ls from "../language-service.js";
+import { cache } from "../../cache.mjs";
+import { ErrorNotFound } from "../../workspace.mjs";
+import * as ls from "../language-service.mjs";
 var worker = null;
-async function setup(monaco, languageId, workspace, languageSettings, formattingOptions) {
+async function setup(monaco, languageId, languageSettings, formattingOptions, workspace) {
   if (!worker) {
     worker = createWorker(monaco, workspace, languageSettings, formattingOptions);
   }
@@ -110,12 +110,6 @@ async function setup(monaco, languageId, workspace, languageSettings, formatting
   ls.registerSignatureHelp(languageId, worker, ["(", ","]);
   ls.registerCodeAction(languageId, worker);
 }
-function getWorkerUrl() {
-  const i = () => import("./worker.js");
-  const m = getWorkerUrl.toString().match(/import\(['"](.+?)['"]\)/);
-  if (!m) throw new Error("worker url not found", { cause: i });
-  return new URL(m[1], import.meta.url);
-}
 async function createWorker(monaco, workspace, languageSettings, formattingOptions) {
   const fs = workspace?.fs;
   const defaultCompilerOptions = {
@@ -173,13 +167,12 @@ async function createWorker(monaco, workspace, languageSettings, formattingOptio
       insertSpaceAfterOpeningAndBeforeClosingNonemptyBrackets: insertSpaces
     },
     importMap,
-    types: typesStore.types
+    types: typesStore.types,
+    workspace: !!workspace
   };
   const worker2 = monaco.editor.createWebWorker({
-    moduleId: "lsp/typescript/worker",
-    label: "typescript",
+    worker: getWorker(createData),
     keepIdleModels: true,
-    createData,
     host: {
       openModel: async (uri) => {
         if (!workspace) {
@@ -284,6 +277,21 @@ async function createWorker(monaco, workspace, languageSettings, formattingOptio
   });
   return worker2;
 }
+function createWebWorker() {
+  const workerUrl = new URL("./worker.mjs", import.meta.url);
+  if (workerUrl.origin !== location.origin) {
+    return new Worker(
+      URL.createObjectURL(new Blob([`import "${workerUrl.href}"`], { type: "application/javascript" })),
+      { type: "module" }
+    );
+  }
+  return new Worker(new URL("./worker.mjs", import.meta.url), { type: "module" });
+}
+function getWorker(createData) {
+  const worker2 = createWebWorker();
+  worker2.postMessage(createData);
+  return worker2;
+}
 var TypesSet = class {
   _types = {};
   _removedtypes = {};
@@ -418,7 +426,6 @@ function parseJsonc(text) {
   }
 }
 export {
-  getWorkerUrl,
   loadImportMap,
   setup
 };

package/dist/lsp/typescript/{worker.js → worker.mjs}

@@ -1466,14 +1466,15 @@ function getWellformedEdit(textEdit) {
 
 // src/lsp/worker-base.ts
 var WorkerBase = class {
-  constructor(_ctx, _createLanguageDocument) {
+  constructor(_ctx, _createData, _createLanguageDocument) {
     this._ctx = _ctx;
+    this._createData = _createData;
     this._createLanguageDocument = _createLanguageDocument;
   }
-  _documentCache = /* @__PURE__ */ new Map();
-  _fsEntries;
+  #documentCache = /* @__PURE__ */ new Map();
+  #fs;
   get hasFileSystemProvider() {
-    return !!this._fsEntries;
+    return !!this._createData.workspace;
   }
   get host() {
     return this._ctx.host;
@@ -1506,17 +1507,17 @@ var WorkerBase = class {
     if (!model) {
       return null;
     }
-    const cached = this._documentCache.get(uri);
+    const cached = this.#documentCache.get(uri);
     if (cached && cached[0] === model.version) {
       return cached[1];
     }
     const document2 = TextDocument2.create(uri, "-", model.version, model.getValue());
-    this._documentCache.set(uri, [model.version, document2, void 0]);
+    this.#documentCache.set(uri, [model.version, document2, void 0]);
     return document2;
   }
   getLanguageDocument(document2) {
     const { uri, version } = document2;
-    const cached = this._documentCache.get(uri);
+    const cached = this.#documentCache.get(uri);
     if (cached && cached[0] === version && cached[2]) {
       return cached[2];
     }
@@ -1524,14 +1525,13 @@ var WorkerBase = class {
       throw new Error("createLanguageDocument is not provided");
     }
     const languageDocument = this._createLanguageDocument(document2);
-    this._documentCache.set(uri, [version, document2, languageDocument]);
+    this.#documentCache.set(uri, [version, document2, languageDocument]);
     return languageDocument;
   }
   readDir(uri, extensions) {
     const entries = [];
-    const fsTree = this._fsEntries;
-    if (fsTree) {
-      for (const [path, type] of fsTree) {
+    if (this.#fs) {
+      for (const [path, type] of this.#fs) {
         if (path.startsWith(uri)) {
           const name = path.slice(uri.length);
           if (!name.includes("/")) {
@@ -1567,30 +1567,25 @@ var WorkerBase = class {
   resolveReference(ref, baseUrl) {
     const url = new URL(ref, baseUrl);
     const href = url.href;
-    if (url.protocol === "file:" && this._fsEntries) {
-      if (!this._fsEntries.has(href)) {
-        return void 0;
-      }
+    if (url.protocol === "file:" && url.pathname !== "/" && this.#fs && !this.#fs.has(href.endsWith("/") ? href.slice(0, -1) : href)) {
+      return void 0;
     }
     return href;
   }
   // #region methods used by the host
   async removeDocumentCache(uri) {
-    this._documentCache.delete(uri);
-  }
-  async syncFSEntries(entries) {
-    this._fsEntries = new Map(entries);
+    this.#documentCache.delete(uri);
   }
   async fsNotify(kind, path, type) {
     const url = "file://" + path;
-    const entries = this._fsEntries ?? (this._fsEntries = /* @__PURE__ */ new Map());
+    const entries = this.#fs ?? (this.#fs = /* @__PURE__ */ new Map());
     if (kind === "create") {
       if (type) {
         entries.set(url, type);
       }
     } else if (kind === "remove") {
       if (entries.get(url) === 1 /* File */) {
-        this._documentCache.delete(url);
+        this.#documentCache.delete(url);
       }
       entries.delete(url);
     }
@@ -1599,17 +1594,17 @@ var WorkerBase = class {
 };
 
 // src/lsp/typescript/worker.ts
-import libs from "./libs.js";
-import { cache } from "../../cache.js";
-import { initializeWorker } from "../../editor-worker.js";
+import libs from "./libs.mjs";
+import { cache } from "../../cache.mjs";
+import { initializeWorker } from "../../editor-worker.mjs";
 var TypeScriptWorker = class extends WorkerBase {
   #compilerOptions;
+  #languageService;
   #formatOptions;
   #importMap;
   #importMapVersion;
   #isBlankImportMap;
   #types;
-  #languageService = ts.createLanguageService(this);
   #urlMappings = /* @__PURE__ */ new Map();
   #typesMappings = /* @__PURE__ */ new Map();
   #httpLibs = /* @__PURE__ */ new Map();
@@ -1622,8 +1617,9 @@ var TypeScriptWorker = class extends WorkerBase {
   #fetchPromises = /* @__PURE__ */ new Map();
   #httpDocumentCache = /* @__PURE__ */ new Map();
   constructor(ctx, createData) {
-    super(ctx);
+    super(ctx, createData);
     this.#compilerOptions = ts.convertCompilerOptionsFromJson(createData.compilerOptions, ".").options;
+    this.#languageService = ts.createLanguageService(this);
     this.#importMap = createData.importMap;
     this.#importMapVersion = 0;
     this.#isBlankImportMap = isBlankImportMap(createData.importMap);