modern-monaco 0.0.0-beta.0

package/dist/workspace.js

@@ -0,0 +1,611 @@
+// src/workspace.ts
+import {
+  createPersistStateStorage,
+  createPersistTask,
+  decode,
+  encode,
+  filenameToURL,
+  openIDB,
+  openIDBCursor,
+  promiseWithResolvers,
+  promisifyIDBRequest,
+  supportLocalStorage,
+  toURL
+} from "./util.js";
+var Workspace = class {
+  _monaco;
+  _history;
+  _fs;
+  _viewState;
+  _entryFile;
+  constructor(options = {}) {
+    const { name = "default", browserHistory, initialFiles, entryFile } = options;
+    const db = new WorkspaceDatabase(
+      name,
+      {
+        name: "fs/meta",
+        keyPath: "url",
+        onCreate: async (store) => {
+          if (initialFiles) {
+            const promises = [];
+            const now = Date.now();
+            const reg = { type: 1, version: 1, ctime: now, mtime: now, size: 0 };
+            const dir = { type: 2, version: 1, ctime: now, mtime: now, size: 0 };
+            for (const [name2, data] of Object.entries(initialFiles)) {
+              const { pathname, href: url } = filenameToURL(name2);
+              let parent = pathname.slice(0, pathname.lastIndexOf("/"));
+              while (parent) {
+                promises.push(
+                  promisifyIDBRequest(
+                    store.put({ url: toURL(parent).href, ...dir })
+                  )
+                );
+                parent = parent.slice(0, parent.lastIndexOf("/"));
+              }
+              promises.push(
+                promisifyIDBRequest(
+                  store.put({ url, ...reg, size: encode(data).byteLength })
+                )
+              );
+            }
+            await Promise.all(promises);
+          }
+        }
+      },
+      {
+        name: "fs/blobs",
+        keyPath: "url",
+        onCreate: async (store) => {
+          if (initialFiles) {
+            const promises = [];
+            for (const [name2, data] of Object.entries(initialFiles)) {
+              promises.push(
+                promisifyIDBRequest(
+                  store.put({ url: filenameToURL(name2).href, content: encode(data) })
+                )
+              );
+            }
+            await Promise.all(promises);
+          }
+        }
+      },
+      {
+        name: "viewState",
+        keyPath: "url"
+      }
+    );
+    this._monaco = promiseWithResolvers();
+    this._fs = new FS(db);
+    this._viewState = new WorkspaceStateStorage(db, "viewState");
+    this._entryFile = entryFile;
+    if (browserHistory) {
+      if (!globalThis.history) {
+        throw new Error("Browser history is not supported.");
+      }
+      this._history = new BrowserHistory(browserHistory === true ? "/" : browserHistory.basePath);
+    } else {
+      this._history = new LocalStorageHistory(name);
+    }
+  }
+  init(monaco) {
+    this._monaco.resolve(monaco);
+  }
+  get entryFile() {
+    return this._entryFile;
+  }
+  get fs() {
+    return this._fs;
+  }
+  get history() {
+    return this._history;
+  }
+  get viewState() {
+    return this._viewState;
+  }
+  async openTextDocument(uri, content) {
+    const monaco = await this._monaco.promise;
+    return this._openTextDocument(uri, monaco.editor.getEditors()[0]);
+  }
+  // @internal
+  async _openTextDocument(uri, editor, selectionOrPosition) {
+    const monaco = await this._monaco.promise;
+    const fs = this._fs;
+    const href = toURL(uri).href;
+    const content = 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__")) {
+      const persist = createPersistTask(() => fs.writeFile(href, model.getValue(), { isModelContentChange: true }));
+      const disposable = model.onDidChangeContent(persist);
+      const unwatch = fs.watch(href, (kind, _, __, context) => {
+        if (kind === "modify" && (!context || !context.isModelContentChange)) {
+          fs.readTextFile(href).then((content2) => {
+            if (model.getValue() !== content2) {
+              model.setValue(content2);
+              model.pushStackElement();
+            }
+          });
+        }
+      });
+      model.onWillDispose(() => {
+        Reflect.deleteProperty(model, "__OB__");
+        disposable.dispose();
+        unwatch();
+      });
+      Reflect.set(model, "__OB__", true);
+    }
+    if (editor) {
+      editor.setModel(model);
+      editor.updateOptions({ readOnly: false });
+      if (selectionOrPosition) {
+        if ("startLineNumber" in selectionOrPosition) {
+          editor.setSelection(selectionOrPosition);
+        } else {
+          editor.setPosition(selectionOrPosition);
+        }
+        const pos = editor.getPosition();
+        if (pos) {
+          const svp = editor.getScrolledVisiblePosition(new monaco.Position(pos.lineNumber - 7, pos.column));
+          if (svp) {
+            editor.setScrollTop(svp.top);
+          }
+        }
+      } else if (viewState) {
+        editor.restoreViewState(viewState);
+      }
+      if (this._history.state.current !== href) {
+        this._history.push(href);
+      }
+    }
+    return model;
+  }
+  async showInputBox(options, token) {
+    const monaco = await this._monaco.promise;
+    return monaco.showInputBox(options, token);
+  }
+  async showQuickPick(items, options, token) {
+    const monaco = await this._monaco.promise;
+    return monaco.showQuickPick(items, options, token);
+  }
+};
+var FS = class {
+  constructor(_db) {
+    this._db = _db;
+  }
+  _watchers = /* @__PURE__ */ new Set();
+  async _getIdbObjectStore(storeName, readwrite = false) {
+    const db = await this._db.open();
+    return db.transaction(storeName, readwrite ? "readwrite" : "readonly").objectStore(storeName);
+  }
+  async _getIdbObjectStores(readwrite = false) {
+    const transaction = (await this._db.open()).transaction(["fs/meta", "fs/blobs"], readwrite ? "readwrite" : "readonly");
+    return [transaction.objectStore("fs/meta"), transaction.objectStore("fs/blobs")];
+  }
+  /**
+   * read the fs entries
+   * @internal
+   */
+  async entries() {
+    const metaStore = await this._getIdbObjectStore("fs/meta");
+    const entries = await promisifyIDBRequest(metaStore.getAll());
+    return entries.map(({ url, type }) => [url, type]);
+  }
+  async stat(name) {
+    const url = filenameToURL(name).href;
+    if (url === "file:///") {
+      return { type: 2, version: 1, ctime: 0, mtime: 0, size: 0 };
+    }
+    const metaStore = await this._getIdbObjectStore("fs/meta");
+    const stat = await promisifyIDBRequest(metaStore.get(url));
+    if (!stat) {
+      throw new ErrorNotFound(url);
+    }
+    return stat;
+  }
+  async createDirectory(name) {
+    const now = Date.now();
+    const { pathname, href: url } = filenameToURL(name);
+    const metaStore = await this._getIdbObjectStore("fs/meta", true);
+    const promises = [];
+    const newDirs = [];
+    let parent = pathname.slice(0, pathname.lastIndexOf("/"));
+    while (parent) {
+      const stat2 = { type: 2, version: 1, ctime: now, mtime: now, size: 0 };
+      promises.push(
+        promisifyIDBRequest(metaStore.add({ url: filenameToURL(parent).href, ...stat2 })).catch((error) => {
+          if (error.name !== "ConstraintError") {
+            throw error;
+          }
+        })
+      );
+      newDirs.push(parent);
+      parent = parent.slice(0, parent.lastIndexOf("/"));
+    }
+    const stat = { type: 2, version: 1, ctime: now, mtime: now, size: 0 };
+    promises.push(
+      promisifyIDBRequest(metaStore.add({ url, ...stat })).catch((error) => {
+        if (error.name !== "ConstraintError") {
+          throw error;
+        }
+      })
+    );
+    newDirs.push(pathname);
+    await Promise.all(promises);
+    for (const dir of newDirs) {
+      this._notify("create", dir, 2);
+    }
+  }
+  async readDirectory(name) {
+    const { pathname } = filenameToURL(name);
+    const stat = await this.stat(name);
+    if (stat.type !== 2) {
+      throw new Error(`read ${pathname}: not a directory`);
+    }
+    const metaStore = await this._getIdbObjectStore("fs/meta");
+    const entries = [];
+    const dir = "file://" + pathname + (pathname.endsWith("/") ? "" : "/");
+    await openIDBCursor(metaStore, IDBKeyRange.lowerBound(dir, true), (cursor) => {
+      const stat2 = cursor.value;
+      if (stat2.url.startsWith(dir)) {
+        const name2 = stat2.url.slice(dir.length);
+        if (name2 !== "" && name2.indexOf("/") === -1) {
+          entries.push([name2, stat2.type]);
+        }
+        return true;
+      }
+      return false;
+    });
+    return entries;
+  }
+  async readFile(name) {
+    const url = filenameToURL(name).href;
+    const blobStore = await this._getIdbObjectStore("fs/blobs");
+    const file = await promisifyIDBRequest(blobStore.get(url));
+    if (!file) {
+      throw new ErrorNotFound(url);
+    }
+    return file.content;
+  }
+  async readTextFile(filename) {
+    return this.readFile(filename).then(decode);
+  }
+  async writeFile(name, content, context) {
+    const { pathname, href: url } = filenameToURL(name);
+    const dir = pathname.slice(0, pathname.lastIndexOf("/"));
+    if (dir) {
+      try {
+        if ((await this.stat(dir)).type !== 2) {
+          throw new Error(`write ${pathname}: not a directory`);
+        }
+      } catch (error) {
+        if (error instanceof ErrorNotFound) {
+          throw new Error(`write ${pathname}: no such file or directory`);
+        }
+        throw error;
+      }
+    }
+    let oldStat = null;
+    try {
+      oldStat = await this.stat(url);
+    } catch (error) {
+      if (!(error instanceof ErrorNotFound)) {
+        throw error;
+      }
+    }
+    if (oldStat?.type === 2) {
+      throw new Error(`write ${pathname}: is a directory`);
+    }
+    content = typeof content === "string" ? encode(content) : content;
+    const now = Date.now();
+    const newStat = {
+      type: 1,
+      version: (oldStat?.version ?? 0) + 1,
+      ctime: oldStat?.ctime ?? now,
+      mtime: now,
+      size: content.byteLength
+    };
+    const [metaStore, blobStore] = await this._getIdbObjectStores(true);
+    await Promise.all([
+      promisifyIDBRequest(metaStore.put({ url, ...newStat })),
+      promisifyIDBRequest(blobStore.put({ url, content }))
+    ]);
+    this._notify(oldStat ? "modify" : "create", pathname, 1, context);
+  }
+  async delete(name, options) {
+    const { pathname, href: url } = filenameToURL(name);
+    const stat = await this.stat(url);
+    if (stat.type === 1) {
+      const [metaStore, blobStore] = await this._getIdbObjectStores(true);
+      await Promise.all([
+        promisifyIDBRequest(metaStore.delete(url)),
+        promisifyIDBRequest(blobStore.delete(url))
+      ]);
+      this._notify("remove", pathname, 1);
+    } else if (stat.type === 2) {
+      if (options?.recursive) {
+        const promises = [];
+        const [metaStore, blobStore] = await this._getIdbObjectStores(true);
+        const deleted = [];
+        promises.push(openIDBCursor(metaStore, IDBKeyRange.lowerBound(url), (cursor) => {
+          const stat2 = cursor.value;
+          if (stat2.url.startsWith(url)) {
+            if (stat2.type === 1) {
+              promises.push(promisifyIDBRequest(blobStore.delete(stat2.url)));
+            }
+            promises.push(promisifyIDBRequest(cursor.delete()));
+            deleted.push([stat2.url, stat2.type]);
+            return true;
+          }
+          return false;
+        }));
+        await Promise.all(promises);
+        for (const [url2, type] of deleted) {
+          this._notify("remove", new URL(url2).pathname, type);
+        }
+      } else {
+        const entries = await this.readDirectory(url);
+        if (entries.length > 0) {
+          throw new Error(`delete ${url}: directory not empty`);
+        }
+        const metaStore = await this._getIdbObjectStore("fs/meta", true);
+        await promisifyIDBRequest(metaStore.delete(url));
+        this._notify("remove", pathname, 2);
+      }
+    } else {
+      const metaStore = await this._getIdbObjectStore("fs/meta", true);
+      await promisifyIDBRequest(metaStore.delete(url));
+      this._notify("remove", pathname, stat.type);
+    }
+  }
+  async copy(source, target, options) {
+    throw new Error("Method not implemented.");
+  }
+  async rename(oldName, newName, options) {
+    const { href: oldUrl, pathname: oldPath } = filenameToURL(oldName);
+    const { href: newUrl, pathname: newPath } = filenameToURL(newName);
+    const oldStat = await this.stat(oldUrl);
+    try {
+      const stat = await this.stat(newUrl);
+      if (!options?.overwrite) {
+        throw new Error(`rename ${oldUrl} to ${newUrl}: file exists`);
+      }
+      await this.delete(newUrl, stat.type === 2 ? { recursive: true } : void 0);
+    } catch (error) {
+      if (!(error instanceof ErrorNotFound)) {
+        throw error;
+      }
+    }
+    const newPathDirname = newPath.slice(0, newPath.lastIndexOf("/"));
+    if (newPathDirname) {
+      try {
+        if ((await this.stat(newPathDirname)).type !== 2) {
+          throw new Error(`rename ${oldUrl} to ${newUrl}: Not a directory`);
+        }
+      } catch (error) {
+        if (error instanceof ErrorNotFound) {
+          throw new Error(`rename ${oldUrl} to ${newUrl}: No such file or directory`);
+        }
+        throw error;
+      }
+    }
+    const [metaStore, blobStore] = await this._getIdbObjectStores(true);
+    const promises = [
+      promisifyIDBRequest(metaStore.delete(oldUrl)),
+      promisifyIDBRequest(metaStore.put({ ...oldStat, url: newUrl }))
+    ];
+    const renameBlob = (oldUrl2, newUrl2) => openIDBCursor(blobStore, IDBKeyRange.only(oldUrl2), (cursor) => {
+      promises.push(promisifyIDBRequest(blobStore.put({ url: newUrl2, content: cursor.value.content })));
+      promises.push(promisifyIDBRequest(cursor.delete()));
+    });
+    const moved = [[oldPath, newPath, oldStat.type]];
+    if (oldStat.type === 1) {
+      promises.push(renameBlob(oldUrl, newUrl));
+    } else if (oldStat.type === 2) {
+      let dirUrl = oldUrl;
+      if (!dirUrl.endsWith("/")) {
+        dirUrl += "/";
+      }
+      const renamingChildren = openIDBCursor(
+        metaStore,
+        IDBKeyRange.lowerBound(dirUrl, true),
+        (cursor) => {
+          const stat = cursor.value;
+          if (stat.url.startsWith(dirUrl)) {
+            const url = newUrl + stat.url.slice(dirUrl.length - 1);
+            if (stat.type === 1) {
+              promises.push(renameBlob(stat.url, url));
+            }
+            promises.push(promisifyIDBRequest(metaStore.put({ ...stat, url })));
+            promises.push(promisifyIDBRequest(cursor.delete()));
+            moved.push([new URL(stat.url).pathname, new URL(url).pathname, stat.type]);
+            return true;
+          }
+          return false;
+        }
+      );
+      promises.push(renamingChildren);
+    }
+    await Promise.all(promises);
+    for (const [oldPath2, newPath2, type] of moved) {
+      this._notify("remove", oldPath2, type);
+      this._notify("create", newPath2, type);
+    }
+  }
+  watch(filename, handleOrOptions, handle) {
+    const options = typeof handleOrOptions === "function" ? void 0 : handleOrOptions;
+    handle = typeof handleOrOptions === "function" ? handleOrOptions : handle;
+    if (typeof handle !== "function") {
+      throw new TypeError("handle must be a function");
+    }
+    const watcher = { pathname: filenameToURL(filename).pathname, recursive: options?.recursive ?? false, handle };
+    this._watchers.add(watcher);
+    return () => {
+      this._watchers.delete(watcher);
+    };
+  }
+  async _notify(kind, pathname, type, context) {
+    for (const watcher of this._watchers) {
+      if (watcher.pathname === pathname || watcher.recursive && (watcher.pathname === "/" || pathname.startsWith(watcher.pathname + "/"))) {
+        watcher.handle(kind, pathname, type, context);
+      }
+    }
+  }
+};
+var ErrorNotFound = class extends Error {
+  constructor(name) {
+    super("No such file or directory: " + name);
+  }
+};
+var WorkspaceDatabase = class {
+  _db;
+  constructor(workspaceName, ...stores) {
+    const open = () => openIDB("monaco:workspace:" + workspaceName, 1, ...stores).then((db) => {
+      db.onclose = () => {
+        this._db = open();
+      };
+      return this._db = db;
+    });
+    this._db = open();
+  }
+  async open() {
+    return await this._db;
+  }
+};
+var WorkspaceStateStorage = class {
+  constructor(_db, _stateName) {
+    this._db = _db;
+    this._stateName = _stateName;
+  }
+  async get(uri) {
+    const url = toURL(uri).href;
+    const store = (await this._db.open()).transaction(this._stateName, "readonly").objectStore(this._stateName);
+    return promisifyIDBRequest(store.get(url)).then((result) => result?.state);
+  }
+  async save(uri, state) {
+    const url = toURL(uri).href;
+    const store = (await this._db.open()).transaction(this._stateName, "readwrite").objectStore(this._stateName);
+    await promisifyIDBRequest(store.put({ url, state }));
+  }
+};
+var LocalStorageHistory = class {
+  _state;
+  _maxHistory;
+  _handlers = /* @__PURE__ */ new Set();
+  constructor(scope, maxHistory = 100) {
+    const defaultState = { "current": -1, "history": [] };
+    this._state = supportLocalStorage() ? createPersistStateStorage(`monaco:workspace:${scope}:history`, defaultState) : defaultState;
+    this._maxHistory = maxHistory;
+  }
+  _onPopState() {
+    for (const handler of this._handlers) {
+      handler(this.state);
+    }
+  }
+  get state() {
+    return { current: this._state.history[this._state.current] ?? "" };
+  }
+  back() {
+    this._state.current--;
+    if (this._state.current < 0) {
+      this._state.current = 0;
+    }
+    this._onPopState();
+  }
+  forward() {
+    this._state.current++;
+    if (this._state.current >= this._state.history.length) {
+      this._state.current = this._state.history.length - 1;
+    }
+    this._onPopState();
+  }
+  push(name) {
+    const url = filenameToURL(name);
+    const history2 = this._state.history.slice(0, this._state.current + 1);
+    history2.push(url.href);
+    if (history2.length > this._maxHistory) {
+      history2.shift();
+    }
+    this._state.history = history2;
+    this._state.current = history2.length - 1;
+    this._onPopState();
+  }
+  replace(name) {
+    const url = filenameToURL(name);
+    const history2 = [...this._state.history];
+    if (this._state.current === -1) {
+      this._state.current = 0;
+    }
+    history2[this._state.current] = url.href;
+    this._state.history = history2;
+    this._onPopState();
+  }
+  onChange(handler) {
+    this._handlers.add(handler);
+    return () => {
+      this._handlers.delete(handler);
+    };
+  }
+};
+var BrowserHistory = class {
+  _basePath = "";
+  _current = "";
+  _handlers = /* @__PURE__ */ new Set();
+  constructor(basePath = "") {
+    this._basePath = "/" + basePath.split("/").filter(Boolean).join("/");
+    this._current = this._trimBasePath(location.pathname);
+    window.addEventListener("popstate", () => {
+      this._current = this._trimBasePath(location.pathname);
+      this._onPopState();
+    });
+  }
+  _trimBasePath(pathname) {
+    if (pathname != "/" && pathname.startsWith(this._basePath)) {
+      return new URL(pathname.slice(this._basePath.length), "file:///").href;
+    }
+    return "";
+  }
+  _joinBasePath(url) {
+    const basePath = this._basePath === "/" ? "" : this._basePath;
+    if (url.protocol === "file:") {
+      return basePath + url.pathname;
+    }
+    return basePath + "/" + url.href;
+  }
+  _onPopState() {
+    for (const handler of this._handlers) {
+      handler(this.state);
+    }
+  }
+  get state() {
+    return { current: this._current };
+  }
+  back() {
+    history.back();
+  }
+  forward() {
+    history.forward();
+  }
+  push(name) {
+    const url = filenameToURL(name);
+    history.pushState(null, "", this._joinBasePath(url));
+    this._current = url.href;
+    this._onPopState();
+  }
+  replace(name) {
+    const url = filenameToURL(name);
+    history.replaceState(null, "", this._joinBasePath(url));
+    this._current = url.href;
+    this._onPopState();
+  }
+  onChange(handler) {
+    this._handlers.add(handler);
+    return () => {
+      this._handlers.delete(handler);
+    };
+  }
+};
+export {
+  ErrorNotFound,
+  Workspace
+};

package/package.json

@@ -0,0 +1,67 @@
+{
+  "name": "modern-monaco",
+  "description": "A modern version of Monaco Editor",
+  "version": "0.0.0-beta.0",
+  "type": "module",
+  "module": "dist/index.js",
+  "types": "types/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./types/index.d.ts"
+    },
+    "./editor-core": {
+      "import": "./dist/editor-core.js",
+      "types": "./types/monaco.d.ts"
+    },
+    "./editor-worker": {
+      "import": "./dist/editor-worker.js"
+    },
+    "./ssr": {
+      "workerd": "./dist/ssr/workerd.js",
+      "import": "./dist/ssr/index.js",
+      "types": "./types/ssr.d.ts"
+    },
+    "./lsp/*": {
+      "import": "./dist/lsp/*.js"
+    }
+  },
+  "scripts": {
+    "prepublishOnly": "deno run -A --no-lock scripts/build.ts",
+    "prepare": "deno run -A --no-lock scripts/patch.ts",
+    "update-language-configurations": "deno run -A --no-lock scripts/update-language-configurations.ts",
+    "dev": "deno run -A --no-lock scripts/dev.ts",
+    "fmt": "dprint fmt"
+  },
+  "files": [
+    "dist/",
+    "types/"
+  ],
+  "browser": {
+    "process": false,
+    "buffer": false
+  },
+  "sideEffects": false,
+  "devDependencies": {
+    "@esm.sh/import-map": "0.1.1",
+    "@shikijs/core": "3.2.1",
+    "@shikijs/engine-oniguruma": "3.2.1",
+    "monaco-editor-core": "0.52.2",
+    "tm-grammars": "1.23.5",
+    "tm-themes": "1.10.1",
+    "typescript": "5.8.2",
+    "vscode-css-languageservice": "6.3.2",
+    "vscode-html-languageservice": "5.3.1",
+    "vscode-json-languageservice": "5.4.3",
+    "vscode-languageserver-textdocument": "1.0.12",
+    "vscode-languageserver-types": "3.17.5"
+  },
+  "peerDependencies": {
+    "typescript": ">= 5.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/esm-dev/modern-monaco.git"
+  },
+  "license": "MIT"
+}

package/types/cache.d.ts

@@ -0,0 +1,7 @@
+export interface ICache {
+  fetch(url: string | URL): Promise<Response>;
+  query(key: string | URL): Promise<Response | null>;
+}
+
+export const cache: ICache;
+export default cache;