markstream-solid 0.0.0-stage → 2.0.23

package/dist/server/workers/katexCdnWorker.js

@@ -0,0 +1,190 @@
+function stringifyForWorker(value) {
+  return JSON.stringify(value);
+}
+function buildKaTeXCDNWorkerSource(options) {
+  const mode = options.mode ?? "classic";
+  const renderOptions = {
+    throwOnError: true,
+    displayMode: true,
+    output: "html",
+    strict: "ignore",
+    ...options.renderOptions || {}
+  };
+  const renderOptionsLiteral = stringifyForWorker(renderOptions);
+  const katexUrlLiteral = stringifyForWorker(options.katexUrl);
+  const mhchemUrlLiteral = options.mhchemUrl ? stringifyForWorker(options.mhchemUrl) : '""';
+  if (mode === "module") {
+    return `
+let DEBUG = false
+let katex = null
+let katexLoadError = null
+let loadPromise = null
+
+function normalizeKaTeX(mod) {
+  const resolved = mod && mod.default ? mod.default : mod
+  if (resolved && typeof resolved.renderToString === 'function')
+    return resolved
+  return null
+}
+
+async function loadKaTeX() {
+  if (katex || katexLoadError)
+    return
+  if (!loadPromise) {
+    loadPromise = (async () => {
+      try {
+        const mod = await import(${katexUrlLiteral})
+        katex = normalizeKaTeX(mod) || null
+        const mhchemUrl = ${mhchemUrlLiteral}
+        if (mhchemUrl) {
+          try {
+            await import(mhchemUrl)
+          }
+          catch (e) {
+            if (DEBUG)
+              console.warn('[markstream-solid:katex-cdn-worker] failed to load mhchem', e)
+          }
+        }
+      }
+      catch (e) {
+        katexLoadError = e
+      }
+    })()
+  }
+  await loadPromise
+}
+
+globalThis.addEventListener('message', async (ev) => {
+  const data = ev.data || {}
+  if (data.type === 'init') {
+    DEBUG = !!data.debug
+    return
+  }
+
+  const id = data.id ?? ''
+  const content = data.content ?? ''
+  const displayMode = data.displayMode ?? true
+
+  await loadKaTeX()
+
+  if (!katex) {
+    const reason = katexLoadError ? String(katexLoadError?.message || katexLoadError) : 'KaTeX is not available in worker'
+    globalThis.postMessage({ id, error: reason, content, displayMode })
+    return
+  }
+
+  try {
+    const opts = ${renderOptionsLiteral}
+    const html = katex.renderToString(content, { ...opts, displayMode: !!displayMode })
+    globalThis.postMessage({ id, html, content, displayMode })
+  }
+  catch (err) {
+    globalThis.postMessage({ id, error: String(err?.message || err), content, displayMode })
+  }
+})
+`.trimStart();
+  }
+  return `
+let DEBUG = false
+let katex = null
+let katexLoadError = null
+
+function normalizeKaTeX(val) {
+  const resolved = val && val.default ? val.default : val
+  if (resolved && typeof resolved.renderToString === 'function')
+    return resolved
+  return null
+}
+
+function loadKaTeXClassic() {
+  if (katex || katexLoadError)
+    return
+  try {
+    importScripts(${katexUrlLiteral})
+    const mhchemUrl = ${mhchemUrlLiteral}
+    if (mhchemUrl) {
+      try {
+        importScripts(mhchemUrl)
+      }
+      catch (e) {
+        if (DEBUG)
+          console.warn('[markstream-solid:katex-cdn-worker] failed to load mhchem', e)
+      }
+    }
+    katex = normalizeKaTeX(globalThis.katex)
+  }
+  catch (e) {
+    katexLoadError = e
+  }
+}
+
+loadKaTeXClassic()
+
+globalThis.addEventListener('message', (ev) => {
+  const data = ev.data || {}
+  if (data.type === 'init') {
+    DEBUG = !!data.debug
+    return
+  }
+
+  const id = data.id ?? ''
+  const content = data.content ?? ''
+  const displayMode = data.displayMode ?? true
+
+  if (!katex && !katexLoadError)
+    loadKaTeXClassic()
+
+  if (!katex) {
+    const reason = katexLoadError ? String(katexLoadError?.message || katexLoadError) : 'KaTeX is not available in worker'
+    globalThis.postMessage({ id, error: reason, content, displayMode })
+    return
+  }
+
+  try {
+    const opts = ${renderOptionsLiteral}
+    const html = katex.renderToString(content, { ...opts, displayMode: !!displayMode })
+    globalThis.postMessage({ id, html, content, displayMode })
+  }
+  catch (err) {
+    globalThis.postMessage({ id, error: String(err?.message || err), content, displayMode })
+  }
+})
+`.trimStart();
+}
+function createKaTeXWorkerFromCDN(options) {
+  const source = buildKaTeXCDNWorkerSource(options);
+  if (typeof Worker === "undefined" || typeof URL === "undefined" || typeof Blob === "undefined") {
+    return {
+      worker: null,
+      dispose: () => {
+      },
+      source
+    };
+  }
+  const blob = new Blob([source], { type: "text/javascript" });
+  const url = URL.createObjectURL(blob);
+  let revoked = false;
+  const dispose = () => {
+    if (revoked)
+      return;
+    revoked = true;
+    try {
+      URL.revokeObjectURL(url);
+    } catch {
+    }
+  };
+  const mode = options.mode ?? "classic";
+  const workerOptions = mode === "module" ? { ...options.workerOptions ?? {}, type: "module" } : options.workerOptions;
+  const worker = new Worker(url, workerOptions);
+  if (options.debug) {
+    try {
+      worker.postMessage({ type: "init", debug: true });
+    } catch {
+    }
+  }
+  return { worker, dispose, source };
+}
+export {
+  buildKaTeXCDNWorkerSource,
+  createKaTeXWorkerFromCDN
+};

package/dist/server/workers/katexWorkerClient.js

@@ -0,0 +1,373 @@
+let katex = null;
+let importAttempted = false;
+let pendingImport = null;
+let katexLoader = defaultKatexLoader;
+function normalizeKatexModule(mod) {
+  const resolved = mod?.default ?? mod;
+  if (resolved && typeof resolved.renderToString === "function")
+    return resolved;
+  return null;
+}
+function getGlobalKatex() {
+  try {
+    const globalStore = globalThis;
+    return normalizeKatexModule(globalStore?.katex);
+  } catch {
+    return null;
+  }
+}
+function defaultKatexLoader() {
+  return (async () => {
+    const globalKatex = getGlobalKatex();
+    if (globalKatex)
+      return globalKatex;
+    const mod = await import("katex");
+    try {
+      await import("katex/contrib/mhchem");
+    } catch {
+    }
+    return normalizeKatexModule(mod);
+  })();
+}
+function resetCache() {
+  katex = null;
+  importAttempted = false;
+  pendingImport = null;
+}
+function setKatexLoader(loader) {
+  katexLoader = loader;
+  resetCache();
+}
+function enableKatex(loader) {
+  setKatexLoader(loader ?? defaultKatexLoader);
+}
+function disableKatex() {
+  setKatexLoader(null);
+}
+function isKatexEnabled() {
+  return typeof katexLoader === "function";
+}
+async function getKatex() {
+  const globalKatex = getGlobalKatex();
+  if (globalKatex) {
+    katex = globalKatex;
+    return katex;
+  }
+  if (katex)
+    return katex;
+  if (pendingImport)
+    return await pendingImport;
+  if (importAttempted)
+    return null;
+  const loader = katexLoader;
+  if (!loader) {
+    importAttempted = true;
+    return null;
+  }
+  pendingImport = (async () => {
+    try {
+      const result = await loader();
+      const normalized = normalizeKatexModule(result) ?? result;
+      if (normalized) {
+        katex = normalized;
+        return katex;
+      }
+    } catch {
+    }
+    importAttempted = true;
+    return null;
+  })();
+  try {
+    return await pendingImport;
+  } finally {
+    pendingImport = null;
+  }
+}
+function normalizeKaTeXRenderInput(content) {
+  if (!content)
+    return "";
+  return content.replace(/·/g, "⋅").replace(/℃/g, "°C");
+}
+const WORKER_BUSY_CODE = "WORKER_BUSY";
+let worker = null;
+let workerInitError = null;
+let debugKatexWorker = false;
+const pending = /* @__PURE__ */ new Map();
+const cache = /* @__PURE__ */ new Map();
+const cacheMax = 200;
+const drainWaiters = /* @__PURE__ */ new Set();
+let maxConcurrency = 5;
+function notifyDrainIfBelowCap() {
+  if (pending.size >= maxConcurrency || drainWaiters.size === 0)
+    return;
+  const currentWaiters = Array.from(drainWaiters);
+  drainWaiters.clear();
+  for (const waiter of currentWaiters) {
+    try {
+      waiter();
+    } catch {
+    }
+  }
+}
+function rememberCache(content, displayMode, html) {
+  cache.set(`${displayMode ? "d" : "i"}:${content}`, html);
+  if (cache.size > cacheMax) {
+    const firstKey = cache.keys().next().value;
+    if (firstKey)
+      cache.delete(firstKey);
+  }
+}
+function setKaTeXWorker(nextWorker) {
+  worker = nextWorker;
+  workerInitError = null;
+  worker.onmessage = (event) => {
+    const { id, html, error, content, displayMode } = event.data || {};
+    const active = pending.get(id);
+    if (!active)
+      return;
+    pending.delete(id);
+    clearTimeout(active.timeoutId);
+    notifyDrainIfBelowCap();
+    if (error) {
+      active.reject(new Error(error));
+      return;
+    }
+    if (content)
+      rememberCache(String(content), Boolean(displayMode), String(html || ""));
+    active.resolve(String(html || ""));
+  };
+  worker.onerror = (event) => {
+    for (const [, active] of pending.entries()) {
+      clearTimeout(active.timeoutId);
+      active.reject(new Error(`Worker error: ${event.message}`));
+    }
+    pending.clear();
+    notifyDrainIfBelowCap();
+  };
+  if (debugKatexWorker)
+    worker.postMessage({ type: "init", debug: true });
+}
+function clearKaTeXWorker() {
+  if (worker)
+    worker.terminate?.();
+  worker = null;
+  workerInitError = null;
+}
+function ensureWorker() {
+  if (worker)
+    return worker;
+  workerInitError = new Error("[markstream-solid:katexWorkerClient] No worker instance set. Please inject a Worker via setKaTeXWorker().");
+  workerInitError.name = "WorkerInitError";
+  workerInitError.code = "WORKER_INIT_ERROR";
+  return null;
+}
+function setKaTeXWorkerDebug(enabled) {
+  debugKatexWorker = !!enabled;
+  if (worker)
+    worker.postMessage({ type: "init", debug: debugKatexWorker });
+}
+async function renderKaTeXInWorker(content, displayMode = true, timeout = 2e3, signal) {
+  const normalizedContent = normalizeKaTeXRenderInput(content);
+  if (!isKatexEnabled()) {
+    const error = new Error("KaTeX rendering disabled");
+    error.name = "KaTeXDisabled";
+    error.code = "KATEX_DISABLED";
+    return Promise.reject(error);
+  }
+  if (workerInitError)
+    return Promise.reject(workerInitError);
+  const cacheKey = `${displayMode ? "d" : "i"}:${normalizedContent}`;
+  const cached = cache.get(cacheKey);
+  if (cached)
+    return cached;
+  const activeWorker = ensureWorker();
+  if (!activeWorker)
+    return Promise.reject(workerInitError);
+  if (pending.size >= maxConcurrency) {
+    const error = new Error("Worker busy");
+    error.name = "WorkerBusy";
+    error.code = WORKER_BUSY_CODE;
+    error.busy = true;
+    error.inFlight = pending.size;
+    error.max = maxConcurrency;
+    return Promise.reject(error);
+  }
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) {
+      const error = new Error("Aborted");
+      error.name = "AbortError";
+      reject(error);
+      return;
+    }
+    const id = Math.random().toString(36).slice(2);
+    const timeoutId = globalThis.setTimeout(() => {
+      pending.delete(id);
+      notifyDrainIfBelowCap();
+      const error = new Error("Worker render timed out");
+      error.name = "WorkerTimeout";
+      error.code = "WORKER_TIMEOUT";
+      reject(error);
+    }, timeout);
+    const onAbort = () => {
+      globalThis.clearTimeout(timeoutId);
+      if (pending.delete(id))
+        notifyDrainIfBelowCap();
+      const error = new Error("Aborted");
+      error.name = "AbortError";
+      reject(error);
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
+    pending.set(id, {
+      timeoutId,
+      resolve: (html) => {
+        signal?.removeEventListener("abort", onAbort);
+        resolve(html);
+      },
+      reject: (error) => {
+        signal?.removeEventListener("abort", onAbort);
+        reject(error);
+      }
+    });
+    activeWorker.postMessage({
+      id,
+      type: "render",
+      content: normalizedContent,
+      displayMode
+    });
+  });
+}
+function setKaTeXCache(content, displayMode = true, html) {
+  rememberCache(normalizeKaTeXRenderInput(content), displayMode, html);
+}
+function getKaTeXWorkerLoad() {
+  return {
+    inFlight: pending.size,
+    max: maxConcurrency
+  };
+}
+function setKaTeXWorkerMaxConcurrency(value) {
+  if (Number.isFinite(value) && value > 0)
+    maxConcurrency = Math.floor(value);
+}
+function isKaTeXWorkerBusy() {
+  return pending.size >= maxConcurrency;
+}
+function waitForKaTeXWorkerSlot(timeout = 2e3, signal) {
+  if (pending.size < maxConcurrency)
+    return Promise.resolve();
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    let timer = null;
+    const onDrain = () => {
+      if (settled)
+        return;
+      settled = true;
+      if (timer)
+        clearTimeout(timer);
+      drainWaiters.delete(onDrain);
+      resolve();
+    };
+    drainWaiters.add(onDrain);
+    timer = setTimeout(() => {
+      if (settled)
+        return;
+      settled = true;
+      drainWaiters.delete(onDrain);
+      const error = new Error("Wait for worker slot timed out");
+      error.name = "WorkerBusyTimeout";
+      error.code = "WORKER_BUSY_TIMEOUT";
+      reject(error);
+    }, timeout);
+    queueMicrotask(() => notifyDrainIfBelowCap());
+    if (signal) {
+      const onAbort = () => {
+        if (settled)
+          return;
+        settled = true;
+        if (timer)
+          clearTimeout(timer);
+        drainWaiters.delete(onDrain);
+        const error = new Error("Aborted");
+        error.name = "AbortError";
+        reject(error);
+      };
+      if (signal.aborted)
+        onAbort();
+      else
+        signal.addEventListener("abort", onAbort, { once: true });
+    }
+  });
+}
+const defaultBackpressure = {
+  timeout: 2e3,
+  waitTimeout: 1500,
+  backoffMs: 30,
+  maxRetries: 1
+};
+const maxBackpressureRetries = 8;
+function setKaTeXBackpressureDefaults(options) {
+  if (options.timeout != null)
+    defaultBackpressure.timeout = Math.max(0, Math.floor(options.timeout));
+  if (options.waitTimeout != null)
+    defaultBackpressure.waitTimeout = Math.max(0, Math.floor(options.waitTimeout));
+  if (options.backoffMs != null)
+    defaultBackpressure.backoffMs = Math.max(0, Math.floor(options.backoffMs));
+  if (options.maxRetries != null)
+    defaultBackpressure.maxRetries = Math.max(0, Math.floor(options.maxRetries));
+}
+function getKaTeXBackpressureDefaults() {
+  return { ...defaultBackpressure };
+}
+async function renderKaTeXWithBackpressure(content, displayMode = true, options = {}) {
+  if (!isKatexEnabled()) {
+    const error = new Error("KaTeX rendering disabled");
+    error.name = "KaTeXDisabled";
+    error.code = "KATEX_DISABLED";
+    throw error;
+  }
+  const timeout = options.timeout ?? defaultBackpressure.timeout;
+  const waitTimeout = options.waitTimeout ?? defaultBackpressure.waitTimeout;
+  const backoffMs = options.backoffMs ?? defaultBackpressure.backoffMs;
+  const rawMaxRetries = options.maxRetries ?? defaultBackpressure.maxRetries;
+  const maxRetries = Number.isFinite(rawMaxRetries) ? Math.max(0, Math.min(Math.floor(rawMaxRetries), maxBackpressureRetries)) : defaultBackpressure.maxRetries;
+  let attempt = 0;
+  for (; ; ) {
+    if (options.signal?.aborted) {
+      const error = new Error("Aborted");
+      error.name = "AbortError";
+      throw error;
+    }
+    try {
+      return await renderKaTeXInWorker(content, displayMode, timeout, options.signal);
+    } catch (error) {
+      if (error?.code !== WORKER_BUSY_CODE || attempt >= maxRetries)
+        throw error;
+      attempt += 1;
+      await waitForKaTeXWorkerSlot(waitTimeout, options.signal).catch(() => {
+      });
+      if (backoffMs > 0)
+        await new Promise((resolve) => globalThis.setTimeout(resolve, backoffMs * attempt));
+    }
+  }
+}
+export {
+  WORKER_BUSY_CODE,
+  clearKaTeXWorker,
+  disableKatex as d,
+  enableKatex as e,
+  getKatex as g,
+  getKaTeXBackpressureDefaults,
+  getKaTeXWorkerLoad,
+  isKatexEnabled as i,
+  isKaTeXWorkerBusy,
+  normalizeKaTeXRenderInput as n,
+  renderKaTeXInWorker,
+  renderKaTeXWithBackpressure,
+  setKatexLoader as s,
+  setKaTeXBackpressureDefaults,
+  setKaTeXCache,
+  setKaTeXWorker,
+  setKaTeXWorkerDebug,
+  setKaTeXWorkerMaxConcurrency,
+  waitForKaTeXWorkerSlot
+};