modern-monaco 0.0.0-beta.0

package/dist/ssr/index.js

@@ -0,0 +1,47 @@
+// src/ssr/index.ts
+import { setDefaultWasmLoader } from "../shiki.js";
+import { getWasmInstance } from "../shiki-wasm.js";
+
+// src/ssr/ssr.ts
+import { getLanguageIdFromPath, initShiki } from "../shiki.js";
+import { render } from "../shiki.js";
+var ssrHighlighter;
+async function initRenderHighlighter(options) {
+  const highlighter = await (ssrHighlighter ?? (ssrHighlighter = initShiki(options.shiki)));
+  const { filename, language, theme } = options;
+  const promises = [];
+  if (language || filename) {
+    const languageId = language ?? getLanguageIdFromPath(filename);
+    if (languageId && !highlighter.getLoadedLanguages().includes(languageId)) {
+      console.info(
+        `[modern-monaco] Loading garmmar '${languageId}' from ${options.shiki?.downloadCDN ?? "https://esm.sh"}/tm-grammars ...`
+      );
+      promises.push(highlighter.loadGrammarFromCDN(languageId));
+    }
+  }
+  if (theme) {
+    if (!highlighter.getLoadedThemes().includes(theme)) {
+      console.info(`[modern-monaco] Loading theme '${theme}' from ${options.shiki?.downloadCDN ?? "https://esm.sh"}/tm-themes ...`);
+      promises.push(highlighter.loadThemeFromCDN(theme));
+    }
+  }
+  if (promises.length > 0) {
+    await Promise.all(promises);
+  }
+  return highlighter;
+}
+async function renderToString(options) {
+  const highlighter = await initRenderHighlighter(options);
+  return render(highlighter, options);
+}
+async function renderToWebComponent(options) {
+  const prerender = await renderToString(options);
+  return '<monaco-editor><script type="application/json" class="monaco-editor-options">' + JSON.stringify(options) + '<\/script><div class="monaco-editor-prerender" style="width:100%;height:100%;">' + prerender + "</div></monaco-editor>";
+}
+
+// src/ssr/index.ts
+setDefaultWasmLoader(getWasmInstance);
+export {
+  renderToString,
+  renderToWebComponent
+};

package/dist/ssr/workerd.js

@@ -0,0 +1,46 @@
+// src/ssr/workerd.ts
+import { setDefaultWasmLoader } from "../shiki.js";
+
+// src/ssr/ssr.ts
+import { getLanguageIdFromPath, initShiki } from "../shiki.js";
+import { render } from "../shiki.js";
+var ssrHighlighter;
+async function initRenderHighlighter(options) {
+  const highlighter = await (ssrHighlighter ?? (ssrHighlighter = initShiki(options.shiki)));
+  const { filename, language, theme } = options;
+  const promises = [];
+  if (language || filename) {
+    const languageId = language ?? getLanguageIdFromPath(filename);
+    if (languageId && !highlighter.getLoadedLanguages().includes(languageId)) {
+      console.info(
+        `[modern-monaco] Loading garmmar '${languageId}' from ${options.shiki?.downloadCDN ?? "https://esm.sh"}/tm-grammars ...`
+      );
+      promises.push(highlighter.loadGrammarFromCDN(languageId));
+    }
+  }
+  if (theme) {
+    if (!highlighter.getLoadedThemes().includes(theme)) {
+      console.info(`[modern-monaco] Loading theme '${theme}' from ${options.shiki?.downloadCDN ?? "https://esm.sh"}/tm-themes ...`);
+      promises.push(highlighter.loadThemeFromCDN(theme));
+    }
+  }
+  if (promises.length > 0) {
+    await Promise.all(promises);
+  }
+  return highlighter;
+}
+async function renderToString(options) {
+  const highlighter = await initRenderHighlighter(options);
+  return render(highlighter, options);
+}
+async function renderToWebComponent(options) {
+  const prerender = await renderToString(options);
+  return '<monaco-editor><script type="application/json" class="monaco-editor-options">' + JSON.stringify(options) + '<\/script><div class="monaco-editor-prerender" style="width:100%;height:100%;">' + prerender + "</div></monaco-editor>";
+}
+
+// src/ssr/workerd.ts
+setDefaultWasmLoader(import("../onig.wasm"));
+export {
+  renderToString,
+  renderToWebComponent
+};

package/dist/util.js

@@ -0,0 +1,192 @@
+// src/util.ts
+var enc = new TextEncoder();
+var dec = new TextDecoder();
+function encode(data) {
+  return typeof data === "string" ? enc.encode(data) : data;
+}
+function decode(data) {
+  return data instanceof Uint8Array ? dec.decode(data) : data;
+}
+function defineProperty(obj, prop, value) {
+  Object.defineProperty(obj, prop, { value });
+}
+function toURL(uri) {
+  return uri instanceof URL ? uri : new URL(uri, "file:///");
+}
+function filenameToURL(filename) {
+  if (filename.startsWith("file://")) {
+    filename = filename.slice(7);
+  }
+  const url = new URL(filename.replace(/[\/\\]+/g, "/"), "file:///");
+  if (url.pathname.endsWith("/")) {
+    url.pathname = url.pathname.slice(0, -1);
+  }
+  url.search = "";
+  return url;
+}
+function isPlainObject(v) {
+  return typeof v === "object" && v !== null && v.constructor === Object;
+}
+function debunce(fn, delay = 500) {
+  let timer = null;
+  return () => {
+    if (timer !== null) {
+      clearTimeout(timer);
+    }
+    timer = setTimeout(() => {
+      timer = null;
+      fn();
+    }, delay);
+  };
+}
+function createPersistTask(persist, delay = 500) {
+  let timer = null;
+  const askToExit = (e) => {
+    e.preventDefault();
+    return false;
+  };
+  return () => {
+    if (timer !== null) {
+      return;
+    }
+    addEventListener("beforeunload", askToExit);
+    timer = setTimeout(async () => {
+      timer = null;
+      await persist();
+      removeEventListener("beforeunload", askToExit);
+    }, delay);
+  };
+}
+function createSyncPersistTask(persist, delay = 500) {
+  let timer = null;
+  return () => {
+    if (timer !== null) {
+      return;
+    }
+    addEventListener("beforeunload", persist);
+    timer = setTimeout(() => {
+      timer = null;
+      removeEventListener("beforeunload", persist);
+      persist();
+    }, delay);
+  };
+}
+function createPersistStateStorage(storeKey, defaultValue) {
+  let state;
+  const init = defaultValue ?? {};
+  const storeValue = localStorage.getItem(storeKey);
+  if (storeValue) {
+    try {
+      for (const [key, value] of Object.entries(JSON.parse(storeValue))) {
+        init[key] = Object.freeze(value);
+      }
+    } catch (e) {
+      console.error(e);
+    }
+  }
+  const persist = createSyncPersistTask(() => localStorage.setItem(storeKey, JSON.stringify(state)), 1e3);
+  return state = createProxy(init, persist);
+}
+function createProxy(obj, onChange) {
+  let filled = false;
+  const proxy = new Proxy(/* @__PURE__ */ Object.create(null), {
+    get(target, key) {
+      return Reflect.get(target, key);
+    },
+    set(target, key, value) {
+      if (isPlainObject(value) && !Object.isFrozen(value)) {
+        value = createProxy(value, onChange);
+      }
+      const ok = Reflect.set(target, key, value);
+      if (ok && filled) {
+        onChange();
+      }
+      return ok;
+    }
+  });
+  for (const [key, value] of Object.entries(obj)) {
+    proxy[key] = value;
+  }
+  filled = true;
+  return proxy;
+}
+function supportLocalStorage() {
+  if (globalThis.localStorage) {
+    try {
+      localStorage.setItem("..", "");
+      localStorage.removeItem("..");
+      return true;
+    } catch {
+    }
+  }
+  return false;
+}
+function promisifyIDBRequest(req) {
+  return new Promise((resolve, reject) => {
+    req.onsuccess = () => resolve(req.result);
+    req.onerror = () => reject(req.error);
+  });
+}
+async function openIDB(name, version = 1, ...stores) {
+  const req = indexedDB.open(name, version);
+  const promises = [];
+  req.onupgradeneeded = () => {
+    const db2 = req.result;
+    for (const { name: name2, keyPath, onCreate } of stores) {
+      if (!db2.objectStoreNames.contains(name2)) {
+        const store = db2.createObjectStore(name2, { keyPath });
+        if (onCreate) {
+          promises.push(onCreate(store));
+        }
+      }
+    }
+  };
+  const db = await promisifyIDBRequest(req);
+  await Promise.all(promises);
+  return db;
+}
+function openIDBCursor(store, range, callback, direction) {
+  return new Promise((resolve, reject) => {
+    const ocr = store.openCursor(range, direction);
+    ocr.onsuccess = () => {
+      const cursor = ocr.result;
+      if (cursor) {
+        if (callback(cursor) !== false) {
+          cursor.continue();
+          return;
+        }
+      }
+      resolve();
+    };
+    ocr.onerror = () => {
+      reject(ocr.error);
+    };
+  });
+}
+function promiseWithResolvers() {
+  let resolve;
+  let reject;
+  const promise = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return { promise, resolve, reject };
+}
+export {
+  createPersistStateStorage,
+  createPersistTask,
+  createProxy,
+  createSyncPersistTask,
+  debunce,
+  decode,
+  defineProperty,
+  encode,
+  filenameToURL,
+  isPlainObject,
+  openIDB,
+  openIDBCursor,
+  promiseWithResolvers,
+  promisifyIDBRequest,
+  supportLocalStorage,
+  toURL
+};