markstream-solid 0.0.0-stage → 2.0.23

package/dist/server/workers/mermaidCdnWorker.js

@@ -0,0 +1,238 @@
+import { applyMermaidThemeDirective } from "markstream-core";
+function stringifyForWorker(value) {
+  return JSON.stringify(value);
+}
+function buildMermaidCDNWorkerSource(options) {
+  const mode = options.mode ?? "module";
+  const mermaidUrlLiteral = stringifyForWorker(options.mermaidUrl);
+  const initLiteral = stringifyForWorker({
+    startOnLoad: false,
+    securityLevel: "strict",
+    flowchart: { htmlLabels: false },
+    ...options.initializeOptions || {}
+  });
+  const sharedLogic = `
+let DEBUG = false
+let mermaid = null
+let mermaidLoadError = null
+
+const applyMermaidThemeDirective = ${applyMermaidThemeDirective.toString()}
+
+function normalizeMermaidModule(mod) {
+  if (!mod)
+    return mod
+  const candidate = mod && mod.default ? mod.default : mod
+  if (candidate && (typeof candidate.render === 'function' || typeof candidate.parse === 'function' || typeof candidate.initialize === 'function'))
+    return candidate
+  if (candidate && candidate.mermaidAPI && (typeof candidate.mermaidAPI.render === 'function' || typeof candidate.mermaidAPI.parse === 'function')) {
+    const api = candidate.mermaidAPI
+    return {
+      ...candidate,
+      render: api.render ? api.render.bind(api) : undefined,
+      parse: api.parse ? api.parse.bind(api) : undefined,
+      initialize: (opts) => {
+        if (typeof candidate.initialize === 'function')
+          return candidate.initialize(opts)
+        return api.initialize ? api.initialize(opts) : undefined
+      },
+    }
+  }
+  if (mod && mod.mermaid && typeof mod.mermaid.parse === 'function')
+    return mod.mermaid
+  return candidate
+}
+
+function applyThemeTo(code, theme) {
+  const themeValue = theme === 'dark' ? 'dark' : 'default'
+  const themeConfig = \`%%{init: {"theme": "\${themeValue}"}}%%\\n\`
+  return applyMermaidThemeDirective(code || '', themeConfig)
+}
+
+function findHeaderIndex(lines) {
+  const headerRe = /^(?:graph|flowchart|flowchart\\s+tb|flowchart\\s+lr|sequenceDiagram|gantt|classDiagram|stateDiagram(?:-v2)?|erDiagram|journey|pie|quadrantChart|timeline|xychart(?:-beta)?)\\b/
+  let inFrontmatter = lines[0]?.trimEnd() === '---'
+  for (let i = 0; i < lines.length; i++) {
+    const line = (lines[i] || '').trim()
+    if (inFrontmatter) {
+      if (i > 0 && lines[i].trimEnd() === '---')
+        inFrontmatter = false
+      continue
+    }
+    if (!line || line.startsWith('%%'))
+      continue
+    if (headerRe.test(line))
+      return i
+  }
+  return -1
+}
+
+async function canParse(code, theme) {
+  const themed = applyThemeTo(code, theme)
+  if (mermaid && typeof mermaid.parse === 'function') {
+    await mermaid.parse(themed)
+    return true
+  }
+  throw new Error('mermaid.parse not available in worker')
+}
+
+async function findLastRenderablePrefix(baseCode, theme) {
+  const lines = String(baseCode || '').split(/\\r\\n?|\\n/)
+  const headerIndex = findHeaderIndex(lines)
+  if (headerIndex === -1)
+    return null
+  const head = lines.slice(0, headerIndex + 1)
+  await canParse(head.join('\\n'), theme)
+
+  let low = headerIndex + 1
+  let high = lines.length
+  let lastGood = headerIndex + 1
+  let tries = 0
+  const MAX_TRIES = 12
+
+  while (low <= high && tries < MAX_TRIES) {
+    const mid = Math.floor((low + high) / 2)
+    const candidate = [...head, ...lines.slice(headerIndex + 1, mid)].join('\\n')
+    tries += 1
+    try {
+      await canParse(candidate, theme)
+      lastGood = mid
+      low = mid + 1
+    }
+    catch {
+      high = mid - 1
+    }
+  }
+
+  return [...head, ...lines.slice(headerIndex + 1, lastGood)].join('\\n')
+}
+
+function initMermaidOnce() {
+  if (!mermaid)
+    return
+  try {
+    if (typeof mermaid.initialize === 'function')
+      mermaid.initialize(${initLiteral})
+  }
+  catch (e) {
+    if (DEBUG)
+      console.warn('[markstream-solid:mermaid-cdn-worker] initialize failed', e)
+  }
+}
+
+globalThis.addEventListener('message', async (ev) => {
+  const msg = ev.data || {}
+  if (msg.type === 'init') {
+    DEBUG = !!msg.debug
+    return
+  }
+
+  const id = msg.id
+  const action = msg.action
+  const payload = msg.payload || {}
+
+  if (!mermaid) {
+    const error = mermaidLoadError ? String(mermaidLoadError?.message || mermaidLoadError) : 'Mermaid is not available in worker'
+    globalThis.postMessage({ id, ok: false, error })
+    return
+  }
+
+  try {
+    if (action === 'canParse') {
+      const ok = await canParse(payload.code, payload.theme)
+      globalThis.postMessage({ id, ok: true, result: ok })
+      return
+    }
+    if (action === 'findPrefix') {
+      const result = await findLastRenderablePrefix(payload.code, payload.theme)
+      globalThis.postMessage({ id, ok: true, result })
+      return
+    }
+    globalThis.postMessage({ id, ok: false, error: 'Unknown action' })
+  }
+  catch (e) {
+    globalThis.postMessage({ id, ok: false, error: String(e?.message || e) })
+  }
+})
+`.trimStart();
+  if (mode === "module") {
+    return `
+${sharedLogic}
+
+let loadPromise = null
+async function loadMermaid() {
+  if (mermaid || mermaidLoadError)
+    return
+  if (!loadPromise) {
+    loadPromise = (async () => {
+      try {
+        const mod = await import(${mermaidUrlLiteral})
+        mermaid = normalizeMermaidModule(mod) || null
+        initMermaidOnce()
+      }
+      catch (e) {
+        mermaidLoadError = e
+      }
+    })()
+  }
+  await loadPromise
+}
+
+await loadMermaid()
+`.trimStart();
+  }
+  return `
+${sharedLogic}
+
+function loadMermaidClassic() {
+  if (mermaid || mermaidLoadError)
+    return
+  try {
+    importScripts(${mermaidUrlLiteral})
+    mermaid = normalizeMermaidModule(globalThis.mermaid) || null
+    initMermaidOnce()
+  }
+  catch (e) {
+    mermaidLoadError = e
+  }
+}
+
+loadMermaidClassic()
+`.trimStart();
+}
+function createMermaidWorkerFromCDN(options) {
+  const source = buildMermaidCDNWorkerSource(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 ?? "module";
+  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 {
+  buildMermaidCDNWorkerSource,
+  createMermaidWorkerFromCDN
+};

package/dist/server/workers/mermaidWorkerClient.js

@@ -0,0 +1,333 @@
+const defaultMermaidLoader = () => import("mermaid");
+const GLOBAL_MERMAID_KEY = "__MARKSTREAM_SOLID_MERMAID__";
+let cachedMermaid = null;
+let importAttempted = false;
+let lastInitKey = null;
+let pendingImport = null;
+let mermaidLoader = defaultMermaidLoader;
+function computeInitKey(config) {
+  const securityLevel = String(config?.securityLevel ?? "strict");
+  const htmlLabels = config?.flowchart?.htmlLabels;
+  return `${securityLevel}|htmlLabels:${htmlLabels === false ? "0" : "1"}`;
+}
+function normalizeMermaidModule(mod) {
+  if (!mod)
+    return mod;
+  const candidate = mod?.default ?? mod;
+  if (candidate && (typeof candidate.render === "function" || typeof candidate.parse === "function" || typeof candidate.initialize === "function"))
+    return candidate;
+  if (candidate?.mermaidAPI && (typeof candidate.mermaidAPI.render === "function" || typeof candidate.mermaidAPI.parse === "function")) {
+    const api = candidate.mermaidAPI;
+    return {
+      ...candidate,
+      render: api.render.bind(api),
+      parse: api.parse ? api.parse.bind(api) : void 0,
+      initialize: (opts) => {
+        if (typeof candidate.initialize === "function")
+          return candidate.initialize(opts);
+        return api.initialize ? api.initialize(opts) : void 0;
+      }
+    };
+  }
+  if (mod?.mermaid && typeof mod.mermaid.render === "function")
+    return mod.mermaid;
+  return candidate;
+}
+function patchInitialize(target) {
+  if (!target)
+    return;
+  try {
+    const originalInitialize = target?.initialize;
+    target.initialize = (opts) => {
+      const merged = { suppressErrorRendering: true, ...opts || {} };
+      if (typeof originalInitialize === "function")
+        return originalInitialize.call(target, merged);
+      if (target?.mermaidAPI && typeof target.mermaidAPI.initialize === "function")
+        return target.mermaidAPI.initialize(merged);
+      return void 0;
+    };
+  } catch {
+  }
+}
+function ensureInitialized(instance, config) {
+  if (!instance || !config)
+    return;
+  const key = computeInitKey(config);
+  if (lastInitKey === key)
+    return;
+  try {
+    if (typeof instance.initialize === "function")
+      instance.initialize(config);
+    else if (instance.mermaidAPI?.initialize)
+      instance.mermaidAPI.initialize(config);
+    lastInitKey = key;
+  } catch {
+  }
+}
+function getGlobalMermaid() {
+  try {
+    const globalStore = globalThis;
+    return normalizeMermaidModule(globalStore?.[GLOBAL_MERMAID_KEY] ?? globalStore?.mermaid);
+  } catch {
+    return null;
+  }
+}
+function setGlobalMermaid(instance) {
+  try {
+    ;
+    globalThis[GLOBAL_MERMAID_KEY] = instance;
+  } catch {
+  }
+}
+function resetCachedMermaid() {
+  cachedMermaid = null;
+  importAttempted = false;
+  lastInitKey = null;
+  pendingImport = null;
+  try {
+    delete globalThis[GLOBAL_MERMAID_KEY];
+  } catch {
+  }
+}
+function setMermaidLoader(loader) {
+  mermaidLoader = loader;
+  resetCachedMermaid();
+}
+function enableMermaid(loader) {
+  setMermaidLoader(loader ?? defaultMermaidLoader);
+}
+function disableMermaid() {
+  setMermaidLoader(null);
+}
+function isMermaidEnabled() {
+  return typeof mermaidLoader === "function";
+}
+async function getMermaid(initConfig) {
+  if (cachedMermaid) {
+    ensureInitialized(cachedMermaid, initConfig);
+    return cachedMermaid;
+  }
+  const globalMermaid = getGlobalMermaid();
+  if (globalMermaid) {
+    patchInitialize(globalMermaid);
+    cachedMermaid = globalMermaid;
+    setGlobalMermaid(cachedMermaid);
+    ensureInitialized(cachedMermaid, initConfig);
+    return cachedMermaid;
+  }
+  if (pendingImport) {
+    const instance = await pendingImport;
+    if (instance)
+      ensureInitialized(instance, initConfig);
+    return instance;
+  }
+  if (importAttempted)
+    return null;
+  const loader = mermaidLoader;
+  if (!loader) {
+    importAttempted = true;
+    return null;
+  }
+  pendingImport = (async () => {
+    try {
+      const mod = await loader();
+      const instance = normalizeMermaidModule(mod);
+      if (!instance) {
+        importAttempted = true;
+        return null;
+      }
+      patchInitialize(instance);
+      cachedMermaid = instance;
+      setGlobalMermaid(cachedMermaid);
+      return cachedMermaid;
+    } catch {
+      importAttempted = true;
+      return null;
+    }
+  })();
+  try {
+    const instance = await pendingImport;
+    if (instance)
+      ensureInitialized(instance, initConfig);
+    return instance;
+  } finally {
+    pendingImport = null;
+  }
+}
+let worker = null;
+let workerInitError = null;
+const rpcMap = /* @__PURE__ */ new Map();
+let maxConcurrency = 5;
+let debugClient = false;
+function setMermaidWorkerClientDebug(enabled) {
+  debugClient = !!enabled;
+}
+function setMermaidWorkerMaxConcurrency(value) {
+  if (Number.isFinite(value) && value > 0)
+    maxConcurrency = Math.floor(value);
+}
+function getMermaidWorkerLoad() {
+  return { inFlight: rpcMap.size, max: maxConcurrency };
+}
+const MERMAID_WORKER_BUSY_CODE = "WORKER_BUSY";
+const MERMAID_DISABLED_CODE = "MERMAID_DISABLED";
+function setMermaidWorker(nextWorker) {
+  worker = nextWorker;
+  workerInitError = null;
+  const current = nextWorker;
+  worker.onmessage = (event) => {
+    if (worker !== current)
+      return;
+    const { id, ok, result, error } = event.data || {};
+    const active = rpcMap.get(id);
+    if (!active)
+      return;
+    if (ok === false || error)
+      active.reject(new Error(error || "Unknown error"));
+    else
+      active.resolve(result);
+  };
+  worker.onerror = (event) => {
+    if (worker !== current)
+      return;
+    if (rpcMap.size === 0) {
+      console.debug?.("[markstream-solid:mermaidWorkerClient] Worker error (idle):", event?.message || event);
+      return;
+    }
+    try {
+      if (debugClient)
+        console.error("[markstream-solid:mermaidWorkerClient] Worker error:", event?.message || event);
+      else
+        console.debug?.("[markstream-solid:mermaidWorkerClient] Worker error:", event?.message || event);
+    } catch {
+    }
+    for (const [, active] of rpcMap.entries())
+      active.reject(new Error(`Worker error: ${event.message}`));
+    rpcMap.clear();
+  };
+  worker.onmessageerror = (event) => {
+    if (worker !== current)
+      return;
+    if (rpcMap.size === 0) {
+      console.debug?.("[markstream-solid:mermaidWorkerClient] Worker messageerror (idle):", event);
+      return;
+    }
+    for (const [, active] of rpcMap.entries())
+      active.reject(new Error("Worker messageerror"));
+    rpcMap.clear();
+  };
+}
+function clearMermaidWorker() {
+  if (worker) {
+    try {
+      for (const [, active] of rpcMap.entries())
+        active.reject(new Error("Worker cleared"));
+      rpcMap.clear();
+      worker.terminate?.();
+    } catch {
+    }
+  }
+  worker = null;
+  workerInitError = null;
+}
+function ensureWorker() {
+  if (worker)
+    return worker;
+  workerInitError = new Error("[markstream-solid:mermaidWorkerClient] No worker instance set. Please inject a Worker via setMermaidWorker().");
+  workerInitError.name = "WorkerInitError";
+  workerInitError.code = "WORKER_INIT_ERROR";
+  return null;
+}
+function callWorker(action, payload, timeout = 1400) {
+  if (!isMermaidEnabled()) {
+    const error = new Error("Mermaid rendering disabled");
+    error.name = "MermaidDisabled";
+    error.code = MERMAID_DISABLED_CODE;
+    return Promise.reject(error);
+  }
+  if (workerInitError)
+    return Promise.reject(workerInitError);
+  const activeWorker = ensureWorker();
+  if (!activeWorker)
+    return Promise.reject(workerInitError);
+  if (rpcMap.size >= maxConcurrency) {
+    const error = new Error("Worker busy");
+    error.name = "WorkerBusy";
+    error.code = MERMAID_WORKER_BUSY_CODE;
+    error.inFlight = rpcMap.size;
+    error.max = maxConcurrency;
+    return Promise.reject(error);
+  }
+  return new Promise((resolve, reject) => {
+    const id = Math.random().toString(36).slice(2);
+    let settled = false;
+    let timeoutId = null;
+    const cleanup = () => {
+      if (settled)
+        return;
+      settled = true;
+      if (timeoutId != null)
+        clearTimeout(timeoutId);
+      rpcMap.delete(id);
+    };
+    rpcMap.set(id, {
+      resolve: (value) => {
+        cleanup();
+        resolve(value);
+      },
+      reject: (error) => {
+        cleanup();
+        reject(error);
+      }
+    });
+    try {
+      activeWorker.postMessage({ id, action, payload });
+    } catch (error) {
+      rpcMap.delete(id);
+      reject(error);
+      return;
+    }
+    timeoutId = setTimeout(() => {
+      const error = new Error("Worker call timed out");
+      error.name = "WorkerTimeout";
+      error.code = "WORKER_TIMEOUT";
+      const pending = rpcMap.get(id);
+      pending?.reject(error);
+    }, timeout);
+  });
+}
+async function canParseOffthread(code, theme, timeout = 1400) {
+  return await callWorker("canParse", { code, theme }, timeout);
+}
+async function findPrefixOffthread(code, theme, timeout = 1400) {
+  return await callWorker("findPrefix", { code, theme }, timeout);
+}
+function terminateWorker() {
+  if (worker) {
+    try {
+      for (const [, active] of rpcMap.entries())
+        active.reject(new Error("Worker terminated"));
+      rpcMap.clear();
+      worker.terminate();
+    } finally {
+      worker = null;
+    }
+  }
+}
+export {
+  MERMAID_DISABLED_CODE,
+  MERMAID_WORKER_BUSY_CODE,
+  canParseOffthread,
+  clearMermaidWorker,
+  disableMermaid as d,
+  enableMermaid as e,
+  findPrefixOffthread,
+  getMermaid as g,
+  getMermaidWorkerLoad,
+  isMermaidEnabled as i,
+  setMermaidLoader as s,
+  setMermaidWorker,
+  setMermaidWorkerClientDebug,
+  setMermaidWorkerMaxConcurrency,
+  terminateWorker
+};

package/dist/streamDiffsWorker.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Host-injected `WorkerPoolManager` for stream-diffs / @pierre/diffs
+ * highlighting.
+ *
+ * markstream-solid deliberately does NOT bundle or spawn the highlight worker
+ * itself — worker assets are bundler-specific (`?worker` in Vite, etc.) and
+ * would be fragile inside a multi-bundler library. Instead, the host app
+ * creates the pool with its own bundler and injects it here; every enhanced
+ * code block then forwards it as the `workerManager` runtime option so Shiki
+ * tokenization runs off the main thread.
+ *
+ * When no pool is injected, highlighting stays on the main thread exactly as
+ * before. A broken/terminated pool is non-fatal: `@pierre/diffs` falls back to
+ * its main-thread highlighter when the pool reports itself unavailable.
+ */
+export interface StreamDiffsWorkerPoolLike {
+    /**
+     * True while the pool is usable. `@pierre/diffs` checks this to decide
+     * between worker-based and main-thread highlighting.
+     */
+    isWorkingPool?: () => boolean;
+    /** Resolves once workers are spawned and initialized. */
+    initialize?: (languages?: string[]) => Promise<void>;
+    /**
+     * Updates worker-side render options (theme). Called by markstream-solid on
+     * theme changes so worker-generated tokens match the active theme.
+     */
+    setRenderOptions?: (options: {
+        theme?: string | {
+            dark: string;
+            light: string;
+        };
+    }) => Promise<void> | void;
+    terminate?: () => void;
+}
+/**
+ * Inject (or clear) the shared worker pool. Pass `null`/`undefined` to disable
+ * worker-based highlighting and fall back to the main thread.
+ *
+ * @example
+ * ```ts
+ * import DiffsWorker from '@pierre/diffs/worker/worker.js?worker'
+ * import { getOrCreateWorkerPoolSingleton } from '@pierre/diffs/worker'
+ * import { setStreamDiffsWorkerPool } from 'markstream-solid'
+ *
+ * const pool = getOrCreateWorkerPoolSingleton({
+ *   poolOptions: {
+ *     poolSize: 4,
+ *     workerFactory: () => new DiffsWorker(),
+ *   },
+ *   highlighterOptions: {
+ *     theme: { dark: 'pierre-dark', light: 'pierre-light' },
+ *   },
+ * })
+ * setStreamDiffsWorkerPool(pool)
+ * ```
+ */
+export declare function setStreamDiffsWorkerPool(pool: StreamDiffsWorkerPoolLike | null | undefined): void;
+export declare function getStreamDiffsWorkerPool(): StreamDiffsWorkerPoolLike | null;
+/** Clear the injected pool without terminating it (host keeps ownership). */
+export declare function clearStreamDiffsWorkerPool(): void;
+/** Terminate the injected pool (if it exposes `terminate`) and clear it. */
+export declare function terminateStreamDiffsWorkerPool(): void;
+/**
+ * Forward the active theme to the worker pool so worker-produced tokens match
+ * the requested theme. No-op when no pool is injected. Failures are non-fatal:
+ * tokens still render, and colors catch up on the next sync.
+ */
+export declare function syncStreamDiffsWorkerTheme(theme: string | {
+    dark: string;
+    light: string;
+}): Promise<void>;

package/dist/tailwind.d.ts

@@ -0,0 +1,2 @@
+export * from './index'
+export { default } from './index'

package/dist/tailwind.js

@@ -0,0 +1,3 @@
+import './index.css'
+export * from './client/index.js'
+export { default } from './client/index.js'

package/dist/tooltip/singletonTooltip.d.ts

@@ -0,0 +1,7 @@
+export type TooltipPlacement = 'top' | 'bottom' | 'left' | 'right';
+export declare function showTooltipForAnchor(anchor: HTMLElement | null, content: string, placement?: TooltipPlacement, immediate?: boolean, _origin?: {
+    x: number;
+    y: number;
+} | undefined, isDark?: boolean | null): void;
+export declare function hideTooltip(immediate?: boolean): void;
+export declare function isTooltipVisible(): boolean;