modern-monaco 0.0.0-beta.0

package/dist/lsp/json/setup.js

@@ -0,0 +1,258 @@
+// 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 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 parseImportMapFromHtml(html, baseURL) {
+  const tplEl = document.createElement("template");
+  tplEl.innerHTML = html;
+  const scriptEl = tplEl.content.querySelector("script[type='importmap']");
+  if (scriptEl) {
+    return parseImportMapFromJson(scriptEl.textContent, baseURL);
+  }
+  return createBlankImportMap(baseURL);
+}
+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);
+}
+
+// src/lsp/json/schemas.ts
+var schemas = [
+  {
+    uri: "https://github.com/denoland/vscode_deno/blob/main/schemas/import_map.schema.json",
+    fileMatch: [
+      "import_map.json",
+      "import-map.json",
+      "importmap.json",
+      "importMap.json",
+      "*.importmap"
+    ],
+    schema: {
+      $schema: "http://json-schema.org/draft-07/schema#",
+      title: "An Import Map",
+      description: "An import map which is used to remap imports when modules are loaded.",
+      type: "object",
+      properties: {
+        imports: {
+          description: "A map of specifiers to their remapped specifiers.",
+          type: "object",
+          properties: {
+            "@jsxRuntime": {
+              description: "The key is the specifier for JSX import source, with a value that represents the target specifier.",
+              type: "string",
+              default: "https://esm.sh/react@18.3.1"
+            }
+          },
+          additionalProperties: {
+            description: "The key is the specifier or partial specifier to match, with a value that represents the target specifier.",
+            type: "string"
+          }
+        },
+        scopes: {
+          description: "Define a scope which remaps a specifier in only a specified scope",
+          type: "object",
+          additionalProperties: {
+            description: "A definition of a scoped remapping.",
+            type: "object",
+            additionalProperties: {
+              description: "The key is the specifier or partial specifier to match within the referring scope, with a value that represents the target specifier.",
+              type: "string"
+            }
+          }
+        }
+      }
+    }
+  },
+  {
+    uri: "https://json.schemastore.org/tsconfig",
+    fileMatch: [
+      "tsconfig.json"
+    ]
+  }
+];
+
+// src/lsp/json/setup.ts
+import * as ls from "../language-service.js";
+async function setup2(monaco, languageId, workspace, languageSettings, formattingOptions) {
+  const { editor, languages } = monaco;
+  const createData = {
+    settings: {
+      validate: true,
+      allowComments: false,
+      schemas: Array.isArray(languageSettings?.schemas) ? schemas.concat(languageSettings.schemas) : schemas,
+      comments: "error",
+      trailingCommas: "error",
+      schemaRequest: "warning",
+      schemaValidation: "warning"
+    },
+    format: {
+      tabSize: 4,
+      insertSpaces: false,
+      trimTrailingWhitespace: true,
+      insertFinalNewline: true,
+      trimFinalNewlines: true,
+      ...formattingOptions
+    }
+  };
+  const worker = editor.createWebWorker({
+    moduleId: "lsp/json/worker",
+    label: languageId,
+    createData,
+    host: ls.createHost(workspace)
+  });
+  const resetSchema = async (uri) => {
+    (await worker.getProxy()).resetSchema(uri.toString());
+  };
+  editor.onWillDisposeModel((model) => {
+    if (model.getLanguageId() === languageId) {
+      resetSchema(model.uri);
+    }
+  });
+  editor.onDidChangeModelLanguage((event) => {
+    if (event.model.getLanguageId() === languageId) {
+      resetSchema(event.model.uri);
+    }
+  });
+  ls.setup(monaco);
+  ls.enableBasicFeatures(languageId, worker, [" ", ":", '"'], workspace);
+  ls.enableColorPresentation(languageId, worker);
+  ls.enableDocumentLinks(languageId, worker);
+  languages.registerCodeLensProvider(languageId, {
+    provideCodeLenses: function(model, _token) {
+      const isImportMap = model.uri.scheme == "file" && ["importmap.json", "import_map.json", "import-map.json", "importMap.json"].some((name) => model.uri.path === "/" + name);
+      if (isImportMap) {
+        const m2 = model.findNextMatch(`"imports":\\s*\\{`, { column: 1, lineNumber: 1 }, true, false, null, false);
+        return {
+          lenses: [
+            {
+              range: m2?.range ?? new monaco.Range(1, 1, 1, 1),
+              command: {
+                id: "search-npm-package",
+                title: "$(sparkle-filled) Search packages on NPM",
+                tooltip: "Search packages on NPM",
+                arguments: [model]
+              }
+            }
+          ],
+          dispose: () => {
+          }
+        };
+      }
+    }
+  });
+  editor.registerCommand("search-npm-package", async (_accessor, model) => {
+    const keyword = await monaco.showInputBox({
+      placeHolder: "Enter package name, e.g. lodash",
+      validateInput: (value) => {
+        return /^[\w\-\.@]+$/.test(value) ? null : "Invalid package name, only word characters are allowed";
+      }
+    });
+    if (!keyword) {
+      return;
+    }
+    const pkg = await monaco.showQuickPick(searchPackagesFromNpm(keyword, 32), {
+      placeHolder: "Select a package",
+      matchOnDetail: true
+    });
+    if (!pkg) {
+      return;
+    }
+    const editor2 = monaco.editor.getEditors().filter((e) => e.hasWidgetFocus())[0];
+    const modelPath = model.uri.path;
+    const { imports, scopes } = modelPath.endsWith(".json") ? parseImportMapFromJson(model.getValue()) : parseImportMapFromHtml(model.getValue());
+    const specifier = "https://esm.sh/" + pkg.name + "@" + pkg.version;
+    if (imports[pkg.name] === specifier) {
+      return;
+    }
+    imports[pkg.name] = specifier;
+    const json = JSON.stringify({ imports, scopes: Object.keys(scopes).length > 0 ? scopes : void 0 }, null, 2);
+    if (modelPath.endsWith(".json")) {
+      const viewState = editor2?.saveViewState();
+      model.setValue(model.normalizeIndentation(json));
+      editor2?.restoreViewState(viewState);
+    } else if (modelPath.endsWith(".html")) {
+      const html = model.getValue();
+      const newHtml = html.replace(
+        /<script[^>]*? type="importmap"[^>]*?>[^]*?<\/script>/,
+        ['<script type="importmap">', ...json.split("\n").map((l) => "  " + l), "<\/script>"].join("\n  ")
+      );
+      const viewState = editor2?.saveViewState();
+      model.setValue(model.normalizeIndentation(newHtml));
+      editor2?.restoreViewState(viewState);
+    }
+  });
+}
+async function searchPackagesFromNpm(keyword, size = 20) {
+  const res = await fetch(`https://registry.npmjs.com/-/v1/search?text=${keyword}&size=${size}`);
+  if (!res.ok) {
+    throw new Error(`Failed to search npm packages: ${res.statusText}`);
+  }
+  const { objects } = await res.json();
+  if (!Array.isArray(objects)) {
+    return [];
+  }
+  const items = new Array(objects.length);
+  let len = 0;
+  for (const { package: pkg } of objects) {
+    if (!pkg.name.startsWith("@types/")) {
+      items[len] = {
+        label: (keyword === pkg.name ? "$(star-empty) " : "") + pkg.name,
+        description: pkg.version,
+        detail: pkg.description,
+        name: pkg.name,
+        version: pkg.version
+      };
+      len++;
+    }
+  }
+  return items.slice(0, len);
+}
+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);
+}
+export {
+  getWorkerUrl,
+  setup2 as setup
+};