modern-monaco 0.3.8 → 0.4.1

package/README.md

@@ -216,7 +216,7 @@ const monaco = await init({
 
 monaco.editor.create(document.getElementById("editor"), {
   theme: "one-light",
-})
+});
 // update the editor theme
 monaco.editor.setTheme("one-dark-pro");
 ```
@@ -382,10 +382,22 @@ export interface LSPConfig {
   };
   /** HTML language configuration. */
   html?: {
-    attributeDefaultValue?: "empty" | "singlequotes" | "doublequotes";
+    /** Defines whether the standard HTML tags are shown. Default is true. */
+    useDefaultDataProvider?: boolean;
+    /** Provides a set of custom data providers. */
+    dataProviders?: { [providerId: string]: HTMLDataV1 };
+    /** Provides a set of custom HTML tags. */
     customTags?: ITagData[];
-    hideAutoCompleteProposals?: boolean;
+    /** The default value for empty attributes. Default is "empty". */
+    attributeDefaultValue?: "empty" | "singlequotes" | "doublequotes";
+    /** Whether to hide end tag suggestions. Default is false. */
     hideEndTagSuggestions?: boolean;
+    /** Whether to hide auto complete proposals. Default is false. */
+    hideAutoCompleteProposals?: boolean;
+    /** Whether to show the import map code lens. Default is true. */
+    importMapCodeLens?: boolean;
+    /** Options for the diagnostics. */
+    diagnosticsOptions?: DiagnosticsOptions;
   };
   /** CSS language configuration. */
   css?: {
@@ -393,11 +405,15 @@ export interface LSPConfig {
     useDefaultDataProvider?: boolean;
     /** Provides a set of custom data providers. */
     dataProviders?: { [providerId: string]: CSSDataV1 };
+    /** A list of valid properties that not defined in the standard CSS properties. */
+    validProperties?: string[];
+    /** Options for the diagnostics. */
+    diagnosticsOptions?: DiagnosticsOptions;
   };
   /** JSON language configuration. */
   json?: {
-    /** By default, the validator will return syntax and semantic errors. Set to false to disable the validator. */
-    validate?: boolean;
+    /** Whether to show the import map code lens. Default is true. */
+    importMapCodeLens?: boolean;
     /** Defines whether comments are allowed or not. Default is disallowed. */
     allowComments?: boolean;
     /** A list of known schemas and/or associations of schemas to file names. */
@@ -410,17 +426,48 @@ export interface LSPConfig {
     schemaValidation?: SeverityLevel;
     /** The severity of problems that occurred when resolving and loading schemas. Default is "warning". */
     schemaRequest?: SeverityLevel;
+    /** Options for the diagnostics. */
+    diagnosticsOptions?: DiagnosticsOptions;
   };
   /** TypeScript language configuration. */
   typescript?: {
+    /** The default import maps. */
+    importMap?: ImportMap;
     /** The compiler options. */
     compilerOptions?: ts.CompilerOptions;
-    /** The global import map. */
-    importMap?: ImportMap;
+    /** Options for the diagnostics. */
+    diagnosticsOptions?: DiagnosticsOptions;
   };
 }
 ```
 
+You can also set the diagnostics options for each language by adding the `diagnosticsOptions` option to the `lsp` options:
+
+```js
+lazy({
+  lsp: {
+    css: {
+      diagnosticsOptions: {
+        // filter out unknown property errors
+        filter: (diagnostic) => diagnostic.code !== "unknownProperty",
+      },
+    },
+    json: {
+      diagnosticsOptions: {
+        // disable syntax and semantic validation
+        validate: false,
+      },
+    },
+    typescript: {
+      diagnosticsOptions: {
+        // ignore type not found errors (code 2307)
+        codesToIgnore: [2307],
+      },
+    },
+  },
+});
+```
+
 ### Import Maps
 
 modern-monaco uses [import maps](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/script/type/importmap) to resolve **bare specifier** imports in JavaScript/TypeScript. By default, modern-monaco detects the `importmap` from the root `index.html` in the workspace.

package/dist/cache.mjs

@@ -23,6 +23,11 @@ var IndexedDB = class {
     const tx = db.transaction("store", "readwrite").objectStore("store");
     await promisifyIDBRequest(tx.put(file));
   }
+  async delete(url) {
+    const db = await this.#db;
+    const tx = db.transaction("store", "readwrite").objectStore("store");
+    await promisifyIDBRequest(tx.delete(url));
+  }
 };
 var MemoryCache = class {
   #cache = /* @__PURE__ */ new Map();
@@ -32,6 +37,9 @@ var MemoryCache = class {
   async put(file) {
     this.#cache.set(file.url, file);
   }
+  async delete(url) {
+    this.#cache.delete(url);
+  }
 };
 var Cache = class {
   _db;
@@ -43,41 +51,60 @@ var Cache = class {
     }
   }
   async fetch(url) {
-    url = normalizeURL(url);
     const storedRes = await this.query(url);
     if (storedRes) {
       return storedRes;
     }
     const res = await fetch(url);
-    if (res.ok) {
-      const file = {
-        url: url.href,
-        content: null,
-        ctime: Date.now()
-      };
-      if (res.redirected) {
-        file.headers = [["location", res.url]];
-        this._db.put(file);
+    if (!res.ok || !res.headers.has("cache-control")) {
+      return res;
+    }
+    const cacheControl = res.headers.get("cache-control");
+    const maxAgeStr = cacheControl.match(/max-age=(\d+)/)?.[1];
+    if (!maxAgeStr) {
+      return res;
+    }
+    const maxAge = parseInt(maxAgeStr);
+    if (isNaN(maxAge) || maxAge <= 0) {
+      return res;
+    }
+    const createdAt = Date.now();
+    const expiresAt = createdAt + maxAge * 1e3;
+    const file = {
+      url: res.url,
+      content: null,
+      createdAt,
+      expiresAt,
+      headers: []
+    };
+    if (res.redirected) {
+      await this._db.put({
+        ...file,
+        url: url instanceof URL ? url.href : url,
+        // raw url
+        headers: [["location", res.url]]
+      });
+    }
+    for (const header of ["content-type", "x-typescript-types"]) {
+      if (res.headers.has(header)) {
+        file.headers.push([header, res.headers.get(header)]);
       }
-      const content = await res.arrayBuffer();
-      const headers = [...res.headers.entries()].filter(
-        ([k]) => ["cache-control", "content-type", "content-length", "x-typescript-types"].includes(k)
-      );
-      file.url = res.url;
-      file.headers = headers;
-      file.content = content;
-      this._db.put(file);
-      const resp = new Response(content, { headers });
-      defineProperty(resp, "url", res.url);
-      defineProperty(resp, "redirected", res.redirected);
-      return resp;
     }
-    return res;
+    file.content = await res.arrayBuffer();
+    await this._db.put(file);
+    const resp = new Response(file.content, { headers: file.headers });
+    defineProperty(resp, "url", res.url);
+    defineProperty(resp, "redirected", res.redirected);
+    return resp;
   }
   async query(key) {
     const url = normalizeURL(key).href;
     const file = await this._db.get(url);
-    if (file && file.headers) {
+    if (file) {
+      if (file.expiresAt < Date.now()) {
+        await this._db.delete(url);
+        return null;
+      }
       const headers = new Headers(file.headers);
       if (headers.has("location")) {
         const redirectedUrl = headers.get("location");

package/dist/core.mjs

@@ -1,46 +1,5 @@
-// node_modules/@esm.sh/import-map/dist/import-map.mjs
-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 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);
-}
-
 // package.json
-var version = "0.3.8";
+var version = "0.4.1";
 
 // src/core.ts
 import { getExtnameFromLanguageId, getLanguageIdFromPath, grammars, initShiki, setDefaultWasmLoader, themes } from "./shiki.mjs";
@@ -270,13 +229,13 @@ function lazy(options) {
               editor.onDidScrollChange(debunce(storeViewState, 500));
               workspace.history.onChange((state) => {
                 if (editor.getModel()?.uri.toString() !== state.current) {
-                  workspace._openTextDocument(state.current, editor);
+                  workspace._openTextDocument(monaco, editor, state.current);
                 }
               });
             }
             if (filename && workspace) {
               try {
-                const model = await workspace._openTextDocument(filename, editor);
+                const model = await workspace._openTextDocument(monaco, editor, filename);
                 if (code && code !== model.getValue()) {
                   model.setValue(code);
                 }
@@ -288,7 +247,7 @@ function lazy(options) {
                       await workspace.fs.createDirectory(dirname);
                     }
                     await workspace.fs.writeFile(filename, code);
-                    workspace._openTextDocument(filename, editor);
+                    workspace._openTextDocument(monaco, editor, filename);
                   } else {
                     editor.setModel(monaco.editor.createModel(""));
                   }
@@ -334,7 +293,7 @@ async function loadMonaco(highlighter, workspace, lsp) {
   let importmapEl = null;
   if (importmapEl = document.querySelector("script[type='importmap']")) {
     try {
-      const { imports = {} } = parseImportMapFromJson(importmapEl.textContent);
+      const { imports = {} } = JSON.parse(importmapEl.textContent);
       if (imports["modern-monaco/editor-core"]) {
         editorCoreModuleUrl = imports["modern-monaco/editor-core"];
       }
@@ -385,7 +344,7 @@ async function loadMonaco(highlighter, workspace, lsp) {
     openCodeEditor: async (editor, resource, selectionOrPosition) => {
       if (workspace && resource.scheme === "file") {
         try {
-          await workspace._openTextDocument(resource.toString(), editor, selectionOrPosition);
+          await workspace._openTextDocument(monaco, editor, resource.toString(), selectionOrPosition);
           return true;
         } catch (err) {
           if (err instanceof NotFoundError) {