modern-monaco 0.1.9 → 0.2.1

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);

package/dist/{shiki.js → shiki.mjs}

@@ -7739,8 +7739,8 @@ var version = "1.24.10";
 var version2 = "1.10.9";
 
 // src/shiki.ts
-import { cache } from "./cache.js";
-import { isPlainObject } from "./util.js";
+import { cache } from "./cache.mjs";
+import { isPlainObject } from "./util.mjs";
 
 // src/render.ts
 var DEFAULT_WINDOWS_FONT_FAMILY = "Consolas, 'Courier New', monospace";
@@ -8071,6 +8071,9 @@ async function initShiki({
   if (languages?.length) {
     const set = /* @__PURE__ */ new Set();
     languages.forEach((l) => {
+      if (["plaintext", "text"].includes(l)) {
+        return;
+      }
       if (typeof l === "string" || l instanceof URL) {
         if (!set.has(l.toString())) {
           const g = grammars.find((g2) => g2.name === l);

package/dist/ssr/{index.js → index.mjs}

@@ -1,10 +1,10 @@
 // src/ssr/index.ts
-import { setDefaultWasmLoader } from "../shiki.js";
-import { getWasmInstance } from "../shiki-wasm.js";
+import { setDefaultWasmLoader } from "../shiki.mjs";
+import { getWasmInstance } from "../shiki-wasm.mjs";
 
 // src/ssr/ssr.ts
-import { getLanguageIdFromPath, initShiki } from "../shiki.js";
-import { render } from "../shiki.js";
+import { getLanguageIdFromPath, initShiki } from "../shiki.mjs";
+import { render } from "../shiki.mjs";
 var ssrHighlighter;
 async function renderToString(input, options) {
   const { language, theme, shiki } = options ?? {};

package/dist/ssr/{workerd.js → workerd.mjs}

@@ -1,9 +1,9 @@
 // src/ssr/workerd.ts
-import { setDefaultWasmLoader } from "../shiki.js";
+import { setDefaultWasmLoader } from "../shiki.mjs";
 
 // src/ssr/ssr.ts
-import { getLanguageIdFromPath, initShiki } from "../shiki.js";
-import { render } from "../shiki.js";
+import { getLanguageIdFromPath, initShiki } from "../shiki.mjs";
+import { render } from "../shiki.mjs";
 var ssrHighlighter;
 async function renderToString(input, options) {
   const { language, theme, shiki } = options ?? {};

package/dist/{workspace.js → workspace.mjs}

@@ -11,7 +11,7 @@ import {
   promisifyIDBRequest,
   supportLocalStorage,
   toURL
-} from "./util.js";
+} from "./util.mjs";
 var Workspace = class {
   _monaco;
   _history;
@@ -66,18 +66,18 @@ var Workspace = class {
   }
   async openTextDocument(uri, content) {
     const monaco = await this._monaco.promise;
-    return this._openTextDocument(uri, monaco.editor.getEditors()[0]);
+    return this._openTextDocument(uri, monaco.editor.getEditors()[0], void 0, content);
   }
   // @internal
-  async _openTextDocument(uri, editor, selectionOrPosition) {
+  async _openTextDocument(uri, editor, selectionOrPosition, readonlyContent) {
     const monaco = await this._monaco.promise;
     const fs = this._fs;
     const href = toURL(uri).href;
-    const content = await fs.readTextFile(href);
+    const content = readonlyContent ?? await fs.readTextFile(href);
     const viewState = await this.viewState.get(href);
     const modelUri = monaco.Uri.parse(href);
     const model = monaco.editor.getModel(modelUri) ?? monaco.editor.createModel(content, void 0, modelUri);
-    if (!Reflect.has(model, "__OB__")) {
+    if (!Reflect.has(model, "__OB__") && typeof readonlyContent !== "string") {
       const persist = createPersistTask(() => fs.writeFile(href, model.getValue(), { isModelContentChange: true }));
       const disposable = model.onDidChangeContent(persist);
       const unwatch = fs.watch(href, (kind, _, __, context) => {
@@ -99,7 +99,13 @@ var Workspace = class {
     }
     if (editor) {
       editor.setModel(model);
-      editor.updateOptions({ readOnly: false });
+      editor.updateOptions({ readOnly: typeof readonlyContent === "string" });
+      if (typeof readonlyContent === "string") {
+        const disposable = editor.onDidChangeModel(() => {
+          model.dispose();
+          disposable.dispose();
+        });
+      }
       if (selectionOrPosition) {
         if ("startLineNumber" in selectionOrPosition) {
           editor.setSelection(selectionOrPosition);
@@ -149,14 +155,12 @@ var FS = class {
     const transaction = (await this._db.open()).transaction(["fs-meta", "fs-blob"], readwrite ? "readwrite" : "readonly");
     return [transaction.objectStore("fs-meta"), transaction.objectStore("fs-blob")];
   }
-  /**
-   * read the fs entries
-   * @internal
-   */
-  async entries() {
+  async *walk() {
     const metaStore = await this._getIdbObjectStore("fs-meta");
     const entries = await promisifyIDBRequest(metaStore.getAll());
-    return entries.map(({ url, type }) => [url, type]);
+    for (const entry of entries) {
+      yield [new URL(entry.url).pathname, entry.type];
+    }
   }
   async stat(name) {
     const url = filenameToURL(name).href;

package/package.json

@@ -1,47 +1,50 @@
 {
   "name": "modern-monaco",
   "description": "A modern version of Monaco Editor",
-  "version": "0.1.9",
+  "version": "0.2.1",
   "type": "module",
-  "main": "./dist/index.js",
-  "module": "./dist/index.js",
+  "main": "./dist/index.mjs",
+  "module": "./dist/index.mjs",
   "types": "./types/index.d.ts",
   "exports": {
     ".": {
-      "import": "./dist/index.js",
+      "import": "./dist/index.mjs",
       "types": "./types/index.d.ts"
     },
     "./core": {
-      "import": "./dist/core.js",
+      "import": "./dist/core.mjs",
       "types": "./types/core.d.ts"
     },
     "./workspace": {
-      "import": "./dist/workspace.js",
+      "import": "./dist/workspace.mjs",
       "types": "./types/workspace.d.ts"
     },
     "./ssr": {
-      "workerd": "./dist/ssr/workerd.js",
-      "import": "./dist/ssr/index.js",
+      "workerd": "./dist/ssr/workerd.mjs",
+      "import": "./dist/ssr/index.mjs",
       "types": "./types/ssr.d.ts"
     },
     "./editor-core": {
-      "import": "./dist/editor-core.js",
+      "import": "./dist/editor-core.mjs",
       "types": "./types/monaco.d.ts"
     },
     "./editor-worker": {
-      "import": "./dist/editor-worker.js"
+      "import": "./dist/editor-worker.mjs"
+    },
+    "./editor-worker-main": {
+      "import": "./dist/editor-worker-main.mjs"
     },
     "./cache": {
-      "import": "./dist/cache.js"
+      "import": "./dist/cache.mjs"
     },
     "./shiki": {
-      "import": "./dist/shiki.js"
+      "import": "./dist/shiki.mjs"
     },
     "./util": {
-      "import": "./dist/util.js"
+      "import": "./dist/util.mjs"
     },
     "./lsp/*": {
-      "import": "./dist/lsp/*.js"
+      "import": "./dist/lsp/*.mjs"
     }
   },
   "esm.sh": {
@@ -67,7 +70,7 @@
     "@esm.sh/import-map": "0.1.1",
     "@shikijs/core": "3.12.2",
     "@shikijs/engine-oniguruma": "3.12.2",
-    "monaco-editor-core": "0.52.2",
+    "monaco-editor-core": "0.53.0",
     "tm-grammars": "1.24.10",
     "tm-themes": "1.10.9",
     "typescript": "5.9.2",

package/types/index.d.ts

@@ -1,7 +1,7 @@
 import type * as monacoNS from "./monaco.d.ts";
 import type { LSPConfig } from "./lsp.d.ts";
 import type { TextmateGrammarName, TextmateThemeName } from "./textmate.d.ts";
-import type { ErrorNotFound, FileSystem, Workspace } from "./workspace.d.ts";
+import { ErrorNotFound, FileSystem, Workspace } from "./workspace";
 
 type Awaitable<T> = T | Promise<T>;
 type MaybeGetter<T> = Awaitable<MaybeModule<T>> | (() => Awaitable<MaybeModule<T>>);

package/types/lsp.d.ts

@@ -66,7 +66,7 @@ export interface ITagData extends IData {
   void?: boolean;
 }
 
-export interface LSP {
+export interface LSPModule {
   setup: (
     monaco: typeof monacoNS,
     languageId: string,
@@ -74,13 +74,12 @@ export interface LSP {
     formattingOptions?: Record<string, unknown>,
     workspace?: Workspace,
   ) => Promise<void>;
-  getWorkerUrl: () => URL;
 }
 
 export interface LSPProvider {
   aliases?: string[];
   syntaxes?: any[];
-  import: () => Promise<LSP>;
+  import: () => Promise<LSPModule>;
 }
 
 export interface LSPConfig extends LSPLanguageConfig {
@@ -105,8 +104,6 @@ declare global {
       compilerOptions?: ts.CompilerOptions;
       /** The global import maps. */
       importMap?: ImportMap;
-      /** The version of the typescript imported from esm.sh CDN. Default: ">= 5.5.0" */
-      tsVersion?: string;
     };
   }
 }