modern-monaco 0.0.0-beta.0

package/dist/lsp/typescript/setup.js

@@ -0,0 +1,425 @@
+// node_modules/.pnpm/@esm.sh+import-map@0.1.1/node_modules/@esm.sh/import-map/dist/import-map.mjs
+function createBlankImportMap(baseURL) {
+  return {
+    $baseURL: new URL(baseURL ?? ".", "file:///").href,
+    imports: {},
+    scopes: {}
+  };
+}
+function importMapFrom(v, baseURL) {
+  const im = createBlankImportMap(baseURL);
+  if (isObject(v)) {
+    const { imports, scopes } = v;
+    if (isObject(imports)) {
+      validateImports(imports);
+      im.imports = imports;
+    }
+    if (isObject(scopes)) {
+      validateScopes(scopes);
+      im.scopes = scopes;
+    }
+  }
+  return im;
+}
+function parseImportMapFromJson(json, baseURL) {
+  const importMap = {
+    $baseURL: new URL(baseURL ?? ".", "file:///").href,
+    imports: {},
+    scopes: {}
+  };
+  const v = JSON.parse(json);
+  if (isObject(v)) {
+    const { imports, scopes } = v;
+    if (isObject(imports)) {
+      validateImports(imports);
+      importMap.imports = imports;
+    }
+    if (isObject(scopes)) {
+      validateScopes(scopes);
+      importMap.scopes = scopes;
+    }
+  }
+  return importMap;
+}
+function isBlankImportMap(importMap) {
+  const { imports, scopes } = importMap;
+  if (isObject(imports) && Object.keys(imports).length > 0 || isObject(scopes) && Object.keys(scopes).length > 0) {
+    return false;
+  }
+  return true;
+}
+function isSameImportMap(a, b) {
+  if (!isSameImports(a.imports, b.imports)) {
+    return false;
+  }
+  for (const k in a.scopes) {
+    if (!(k in b.scopes) || !isObject(b.scopes[k])) {
+      return false;
+    }
+    if (!isSameImports(a.scopes[k], b.scopes[k])) {
+      return false;
+    }
+  }
+  return true;
+}
+function validateImports(imports) {
+  for (const [k, v] of Object.entries(imports)) {
+    if (!v || typeof v !== "string") {
+      delete imports[k];
+    }
+  }
+}
+function validateScopes(imports) {
+  for (const [k, v] of Object.entries(imports)) {
+    if (isObject(v)) {
+      validateImports(v);
+    } else {
+      delete imports[k];
+    }
+  }
+}
+function isObject(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function isSameImports(a, b) {
+  if (Object.keys(a).length !== Object.keys(b).length) {
+    return false;
+  }
+  for (const k in a) {
+    if (a[k] !== b[k]) {
+      return false;
+    }
+  }
+  return true;
+}
+
+// src/lsp/typescript/setup.ts
+import { cache } from "../../cache.js";
+import { ErrorNotFound } from "../../workspace.js";
+import * as ls from "../language-service.js";
+var worker = null;
+async function setup2(monaco, languageId, workspace, languageSettings, formattingOptions) {
+  if (!worker) {
+    worker = createWorker(monaco, workspace, languageSettings, formattingOptions);
+  }
+  if (worker instanceof Promise) {
+    worker = await worker;
+  }
+  ls.setup(monaco);
+  ls.enableBasicFeatures(languageId, worker, [".", "/", '"', "'", "<"], workspace);
+  ls.enableAutoComplete(languageId, worker, [">", "/"]);
+  ls.enableSignatureHelp(languageId, worker, ["(", ","]);
+  ls.enableCodeAction(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 = {
+    // set allowJs to true to support embedded javascript in html
+    allowJs: true,
+    allowImportingTsExtensions: true,
+    noEmit: true,
+    isolatedModules: true,
+    module: "esnext",
+    moduleResolution: "bundler",
+    moduleDetection: "force",
+    skipLibCheck: true,
+    target: "esnext",
+    useDefineForClassFields: true,
+    ...languageSettings?.compilerOptions
+  };
+  const typesStore = new TypesSet();
+  const defaultImportMap = importMapFrom(languageSettings?.importMap);
+  const remixImportMap = (im) => {
+    if (isBlankImportMap(defaultImportMap)) {
+      return im;
+    }
+    return {
+      ...im,
+      imports: Object.assign({}, defaultImportMap.imports, im.imports),
+      scopes: Object.assign({}, defaultImportMap.scopes, im.scopes)
+    };
+  };
+  let compilerOptions = { ...defaultCompilerOptions };
+  let importMap = { ...defaultImportMap };
+  if (workspace) {
+    await Promise.all([
+      loadCompilerOptions(workspace).then((options) => {
+        compilerOptions = { ...defaultCompilerOptions, ...options };
+      }),
+      loadImportMap(workspace, remixImportMap).then((im) => {
+        importMap = im;
+      })
+    ]);
+  }
+  await typesStore.load(compilerOptions, workspace);
+  const { tabSize = 4, trimTrailingWhitespace = true, insertSpaces = true, semicolon = "insert" } = formattingOptions ?? {};
+  const createData = {
+    compilerOptions,
+    formatOptions: {
+      tabSize,
+      trimTrailingWhitespace,
+      semicolons: semicolon,
+      indentSize: tabSize,
+      convertTabsToSpaces: insertSpaces,
+      insertSpaceAfterCommaDelimiter: insertSpaces,
+      insertSpaceAfterSemicolonInForStatements: insertSpaces,
+      insertSpaceBeforeAndAfterBinaryOperators: insertSpaces,
+      insertSpaceAfterKeywordsInControlFlowStatements: insertSpaces,
+      insertSpaceAfterOpeningAndBeforeClosingNonemptyBrackets: insertSpaces
+    },
+    importMap,
+    types: typesStore.types
+  };
+  const worker2 = monaco.editor.createWebWorker({
+    moduleId: "lsp/typescript/worker",
+    label: "typescript",
+    keepIdleModels: true,
+    createData,
+    host: {
+      openModel: async (uri) => {
+        if (!workspace) {
+          throw new Error("Workspace is undefined.");
+        }
+        try {
+          await workspace._openTextDocument(uri);
+        } catch (error) {
+          if (error instanceof ErrorNotFound) {
+            return false;
+          }
+          throw error;
+        }
+        return true;
+      },
+      refreshDiagnostics: async (uri) => {
+        let model = monaco.editor.getModel(uri);
+        if (model && model.uri.path.includes(".(embedded).")) {
+          model = monaco.editor.getModel(model.uri.toString(true).split(".(embedded).")[0]);
+        }
+        if (model) {
+          Reflect.get(model, "refreshDiagnostics")?.();
+        }
+      }
+    }
+  });
+  if (fs) {
+    const updateCompilerOptions = async (options) => {
+      const proxy = await worker2.getProxy();
+      await proxy.updateCompilerOptions(options);
+      monaco.editor.getModels().forEach((model) => {
+        const langaugeId = model.getLanguageId();
+        if (langaugeId === "typescript" || langaugeId === "javascript" || langaugeId === "jsx" || langaugeId === "tsx") {
+          Reflect.get(model, "refreshDiagnostics")?.();
+        }
+      });
+    };
+    const watchTypes = () => (compilerOptions.$types ?? []).map(
+      (url) => fs.watch(url, async (kind) => {
+        if (kind === "remove") {
+          typesStore.remove(url);
+        } else {
+          const content = await fs.readTextFile(url);
+          typesStore.add(content, url);
+        }
+        updateCompilerOptions({ types: typesStore.types });
+      })
+    );
+    const watchImportMapJSON = () => {
+      const { $src } = importMap;
+      if ($src && $src.endsWith(".json")) {
+        return fs.watch($src, async (kind) => {
+          if (kind === "remove") {
+            importMap = { ...defaultImportMap };
+          } else {
+            try {
+              const content = await fs.readTextFile($src);
+              const im = parseImportMapFromJson(content);
+              im.$src = $src;
+              importMap = remixImportMap(im);
+            } catch (error) {
+              console.error("Failed to parse import map:", error);
+              importMap = { ...defaultImportMap };
+            }
+          }
+          updateCompilerOptions({ importMap });
+        });
+      }
+    };
+    let unwatchTypes = watchTypes();
+    let unwatchImportMap = watchImportMapJSON();
+    fs.watch("tsconfig.json", () => {
+      unwatchTypes.forEach((dispose) => dispose());
+      loadCompilerOptions(workspace).then((options) => {
+        const newOptions = { ...defaultCompilerOptions, ...options };
+        if (JSON.stringify(newOptions) !== JSON.stringify(compilerOptions)) {
+          compilerOptions = newOptions;
+          typesStore.load(compilerOptions, workspace).then(() => {
+            updateCompilerOptions({ compilerOptions, types: typesStore.types });
+          });
+        }
+        unwatchTypes = watchTypes();
+      });
+    });
+    fs.watch("index.html", () => {
+      unwatchImportMap?.();
+      loadImportMap(workspace, remixImportMap).then((im) => {
+        if (!isSameImportMap(importMap, im)) {
+          importMap = im;
+          updateCompilerOptions({ importMap });
+        }
+        unwatchImportMap = watchImportMapJSON();
+      });
+    });
+  }
+  monaco.editor.addCommand({
+    id: "ts:fetch_http_module",
+    run: async (_, url, containingFile) => {
+      const proxy = await worker2.getProxy();
+      await proxy.fetchHttpModule(url, containingFile);
+    }
+  });
+  return worker2;
+}
+var TypesSet = class {
+  _types = {};
+  _removedtypes = {};
+  get types() {
+    return this._types;
+  }
+  reset(types) {
+    const toRemove = Object.keys(this._types).filter(
+      (key) => !types[key]
+    );
+    for (const key of toRemove) {
+      this.remove(key);
+    }
+    for (const [filePath, content] of Object.entries(types)) {
+      this.add(content, filePath);
+    }
+  }
+  add(content, filePath) {
+    if (this._types[filePath] && this._types[filePath].content === content) {
+      return false;
+    }
+    let version = 1;
+    if (this._removedtypes[filePath]) {
+      version = this._removedtypes[filePath] + 1;
+    }
+    if (this._types[filePath]) {
+      version = this._types[filePath].version + 1;
+    }
+    this._types[filePath] = { content, version };
+    return true;
+  }
+  remove(filePath) {
+    const lib = this._types[filePath];
+    if (lib) {
+      delete this._types[filePath];
+      this._removedtypes[filePath] = lib.version;
+      return true;
+    }
+    return false;
+  }
+  /** load types defined in tsconfig.json */
+  async load(compilerOptions, workspace) {
+    const types = compilerOptions.types;
+    if (Array.isArray(types)) {
+      delete compilerOptions.types;
+      await Promise.all(types.map(async (type) => {
+        if (/^https?:\/\//.test(type)) {
+          const res = await cache.fetch(type);
+          const dtsUrl = res.headers.get("x-typescript-types");
+          if (dtsUrl) {
+            res.body?.cancel?.();
+            const res2 = await cache.fetch(dtsUrl);
+            if (res2.ok) {
+              return [dtsUrl, await res2.text()];
+            } else {
+              console.error(
+                `Failed to fetch "${dtsUrl}": ` + await res2.text()
+              );
+            }
+          } else if (res.ok) {
+            return [type, await res.text()];
+          } else {
+            console.error(
+              `Failed to fetch "${dtsUrl}": ` + await res.text()
+            );
+          }
+        } else if (typeof type === "string" && workspace) {
+          const dtsUrl = new URL(type.replace(/\.d\.ts$/, "") + ".d.ts", "file:///").href;
+          try {
+            return [dtsUrl, await workspace.fs.readTextFile(dtsUrl)];
+          } catch (error) {
+            console.error(`Failed to read "${dtsUrl}": ` + error.message);
+          }
+        }
+        return null;
+      })).then((e) => {
+        const entries = e.filter(Boolean);
+        if (workspace) {
+          compilerOptions.$types = entries.map(([url]) => url).filter((url) => url.startsWith("file://"));
+        }
+        this.reset(Object.fromEntries(entries));
+      });
+    }
+  }
+};
+async function loadCompilerOptions(workspace) {
+  const compilerOptions = {};
+  try {
+    const tsconfigJson = await workspace.fs.readTextFile("tsconfig.json");
+    const tsconfig = parseJsonc(tsconfigJson);
+    compilerOptions.$src = "file:///tsconfig.json";
+    Object.assign(compilerOptions, tsconfig.compilerOptions);
+  } catch (error) {
+    if (error instanceof ErrorNotFound) {
+    } else {
+      console.error(error);
+    }
+  }
+  return compilerOptions;
+}
+async function loadImportMap(workspace, validate) {
+  let src;
+  try {
+    let indexHtml = await workspace.fs.readTextFile("index.html");
+    let tplEl = document.createElement("template");
+    let scriptEl;
+    tplEl.innerHTML = indexHtml;
+    scriptEl = tplEl.content.querySelector('script[type="importmap"]');
+    if (scriptEl) {
+      src = scriptEl.src ? new URL(scriptEl.src, "file:///").href : "file:///index.html";
+      const importMap2 = parseImportMapFromJson(scriptEl.src ? await workspace.fs.readTextFile(scriptEl.src) : scriptEl.textContent);
+      importMap2.$src = src;
+      return validate(importMap2);
+    }
+  } catch (error) {
+    if (error instanceof ErrorNotFound) {
+    } else {
+      console.error("Failed to parse import map from index.html:", error.message);
+    }
+  }
+  const importMap = createBlankImportMap();
+  return validate(importMap);
+}
+function parseJsonc(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    const stringOrCommentRe = /("(?:\\?[^])*?")|(\/\/.*)|(\/\*[^]*?\*\/)/g;
+    const stringOrTrailingCommaRe = /("(?:\\?[^])*?")|(,\s*)(?=]|})/g;
+    const fixed = text.replace(stringOrCommentRe, "$1").replace(stringOrTrailingCommaRe, "$1");
+    return JSON.parse(fixed);
+  }
+}
+export {
+  getWorkerUrl,
+  loadImportMap,
+  setup2 as setup
+};