@ai-matrx/rich-content 0.2.4 → 0.2.6

package/dist/mermaid/lazy-draw.js

@@ -0,0 +1,168 @@
+"use client";
+import { nearestScrollRoot } from "../utils/lifted/scroll-root.js";
+import { useEffect, useState, useSyncExternalStore } from "react";
+const DRAW_MARGIN = "1200px 0px";
+let renderAllPasses = 0;
+let renderAll = false;
+const listeners = /* @__PURE__ */ new Set();
+const pending = /* @__PURE__ */ new Set();
+const drawnWaiters = /* @__PURE__ */ new Set();
+const sleepers = /* @__PURE__ */ new Map();
+const drawing = /* @__PURE__ */ new Set();
+const IDLE_BATCH = 1;
+let idleScheduled = false;
+function scheduleIdleDraws() {
+  if (idleScheduled || typeof window === "undefined") return;
+  idleScheduled = true;
+  const run = () => {
+    idleScheduled = false;
+    if (drawing.size > 0) {
+      if (sleepers.size > 0) setTimeout(scheduleIdleDraws, 150);
+      return;
+    }
+    let woken = 0;
+    for (const [token, wake] of sleepers) {
+      if (woken >= IDLE_BATCH) break;
+      sleepers.delete(token);
+      drawing.add(token);
+      wake();
+      woken++;
+    }
+    if (sleepers.size > 0) setTimeout(scheduleIdleDraws, 150);
+  };
+  const ric = window.requestIdleCallback;
+  if (ric) ric(run);
+  else setTimeout(run, 200);
+}
+function emit() {
+  for (const l of listeners) l();
+}
+function subscribe(listener) {
+  listeners.add(listener);
+  return () => listeners.delete(listener);
+}
+function setRenderAll() {
+  const next = renderAllPasses > 0;
+  if (next === renderAll) return;
+  renderAll = next;
+  emit();
+}
+function beginRenderAllPass() {
+  renderAllPasses++;
+  setRenderAll();
+  let open = true;
+  return () => {
+    if (!open) return;
+    open = false;
+    renderAllPasses = Math.max(0, renderAllPasses - 1);
+    setRenderAll();
+  };
+}
+if (typeof window !== "undefined") {
+  let browserPrint = null;
+  window.addEventListener("beforeprint", () => {
+    browserPrint ??= beginRenderAllPass();
+  });
+  window.addEventListener("afterprint", () => {
+    browserPrint?.();
+    browserPrint = null;
+  });
+}
+function isRenderAllActive() {
+  return renderAll;
+}
+async function renderAllDiagrams(timeoutMs = 2e4) {
+  const release = beginRenderAllPass();
+  const result = await waitForAllDrawn(timeoutMs);
+  return { ...result, release };
+}
+async function waitForAllDrawn(timeoutMs) {
+  await new Promise((r) => setTimeout(r, 0));
+  if (pending.size === 0) return { pending: 0 };
+  return new Promise((resolve) => {
+    const done = () => {
+      if (pending.size > 0) return;
+      clearTimeout(timer);
+      drawnWaiters.delete(done);
+      resolve({ pending: 0 });
+    };
+    const timer = setTimeout(() => {
+      drawnWaiters.delete(done);
+      resolve({ pending: pending.size });
+    }, timeoutMs);
+    drawnWaiters.add(done);
+  });
+}
+async function printLivePage() {
+  const { pending: missing, release } = await renderAllDiagrams();
+  const close = () => {
+    window.removeEventListener("afterprint", close);
+    release();
+  };
+  window.addEventListener("afterprint", close);
+  if (missing > 0) {
+    const { toast } = await import("../host/toast.js");
+    toast.warning(
+      `${missing} diagram${missing === 1 ? " is" : "s are"} still drawing \u2014 they may print as placeholders. Try again in a moment.`
+    );
+  }
+  window.print();
+}
+function useRenderAllRequested() {
+  return useSyncExternalStore(subscribe, () => renderAll, () => false);
+}
+function useDrawWhenNear(ref) {
+  const all = useRenderAllRequested();
+  const [near, setNear] = useState(false);
+  const [token] = useState(() => /* @__PURE__ */ Symbol("diagram"));
+  useEffect(() => {
+    pending.add(token);
+    sleepers.set(token, () => setNear(true));
+    scheduleIdleDraws();
+    return () => {
+      pending.delete(token);
+      sleepers.delete(token);
+      drawing.delete(token);
+      for (const w of [...drawnWaiters]) w();
+    };
+  }, [token]);
+  useEffect(() => {
+    if ((near || all) && sleepers.delete(token)) drawing.add(token);
+  }, [near, all, token]);
+  useEffect(() => {
+    if (near || all) return void 0;
+    const el = ref.current;
+    if (!el || typeof IntersectionObserver === "undefined") {
+      setNear(true);
+      return void 0;
+    }
+    const io = new IntersectionObserver(
+      (entries) => {
+        if (entries.some((e) => e.isIntersecting)) setNear(true);
+      },
+      // Its own scroller, so the margin holds inside a panel or drawer too.
+      { root: nearestScrollRoot(el), rootMargin: DRAW_MARGIN }
+    );
+    io.observe(el);
+    return () => io.disconnect();
+  }, [near, all, ref]);
+  const markDrawn = () => {
+    setNear(true);
+    drawing.delete(token);
+    sleepers.delete(token);
+    if (!pending.delete(token)) return;
+    for (const w of [...drawnWaiters]) w();
+    if (sleepers.size > 0) scheduleIdleDraws();
+  };
+  return { shouldDraw: all || near, markDrawn };
+}
+export {
+  DRAW_MARGIN,
+  IDLE_BATCH,
+  beginRenderAllPass,
+  isRenderAllActive,
+  printLivePage,
+  renderAllDiagrams,
+  useDrawWhenNear,
+  useRenderAllRequested
+};

package/dist/mermaid/model/adapter.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Adapter contract + registry. One adapter per structurally-editable diagram
+ * type. Types without an adapter still get render + code + AI editing — the
+ * workbench's structural modes simply show a graceful "use Code or AI" state.
+ */
+import type { MermaidDiagramType } from "../diagram-type.js";
+import type { MermaidOp } from "./ops.js";
+import type { MermaidDoc, ParseOutcome } from "./types.js";
+export interface AdapterVocabulary {
+    /** What a "node" is called for humans ("Step", "Topic", "Slice", …). */
+    node: string;
+    /** Label for the primary add action ("Add step", "Add topic", …). */
+    addNode: string;
+    /** What a connection is called, when the type has them. */
+    edge?: string;
+}
+export interface MermaidAdapter<D extends MermaidDoc = MermaidDoc> {
+    diagramType: MermaidDiagramType;
+    parse(source: string): ParseOutcome;
+    /** Deterministic serialization; untouched entities re-emit `raw` verbatim. */
+    serialize(doc: D): string;
+    /** Pure; throws MermaidOpError on invalid targets. */
+    applyOp(doc: D, op: MermaidOp): D;
+    vocabulary: AdapterVocabulary;
+}
+export declare function registerAdapter<D extends MermaidDoc>(adapter: MermaidAdapter<D>): void;
+export declare function getAdapterForType(type: MermaidDiagramType): MermaidAdapter | null;
+export declare function getAdapter(source: string): MermaidAdapter | null;

package/dist/mermaid/model/adapter.js

@@ -0,0 +1,16 @@
+import { detectDiagramType } from "../diagram-type.js";
+const registry = /* @__PURE__ */ new Map();
+function registerAdapter(adapter) {
+  registry.set(adapter.diagramType, adapter);
+}
+function getAdapterForType(type) {
+  return registry.get(type) ?? null;
+}
+function getAdapter(source) {
+  return getAdapterForType(detectDiagramType(source));
+}
+export {
+  getAdapter,
+  getAdapterForType,
+  registerAdapter
+};

package/dist/mermaid/model/ops.d.ts

@@ -0,0 +1,282 @@
+/**
+ * Edit operations per diagram type — the ONLY way structural modes (visual /
+ * outline) mutate a document. Adapters implement applyOp as a pure function:
+ * (doc, op) → new doc. Ops throw MermaidOpError on an invalid target; the
+ * editor surfaces that as a friendly toast, never a crash.
+ */
+import type { FlowDirection, FlowEdgeStyle, FlowShape, MindmapShape, SequenceArrow } from "./types.js";
+export declare class MermaidOpError extends Error {
+    constructor(message: string);
+}
+export type FlowchartOp = {
+    type: "addNode";
+    label: string;
+    shape?: FlowShape;
+    connectFrom?: string;
+} | {
+    type: "renameNode";
+    id: string;
+    label: string;
+} | {
+    type: "deleteNode";
+    id: string;
+} | {
+    type: "setNodeShape";
+    id: string;
+    shape: FlowShape;
+} | {
+    type: "setNodePalette";
+    id: string;
+    paletteKey: string | null;
+} | {
+    type: "connectNodes";
+    from: string;
+    to: string;
+    label?: string;
+} | {
+    type: "deleteEdge";
+    id: string;
+} | {
+    type: "setEdgeLabel";
+    id: string;
+    label: string;
+} | {
+    type: "setEdgeStyle";
+    id: string;
+    style: FlowEdgeStyle;
+} | {
+    type: "reverseEdge";
+    id: string;
+} | {
+    type: "setDirection";
+    direction: FlowDirection;
+} | {
+    type: "renameSubgraph";
+    id: string;
+    title: string;
+};
+export type MindmapOp = {
+    type: "addChild";
+    parentId: string;
+    label: string;
+} | {
+    type: "renameNode";
+    id: string;
+    label: string;
+} | {
+    type: "deleteNode";
+    id: string;
+} | {
+    type: "setShape";
+    id: string;
+    shape: MindmapShape;
+} | {
+    type: "indent";
+    id: string;
+} | {
+    type: "outdent";
+    id: string;
+} | {
+    type: "moveBefore";
+    id: string;
+    siblingId: string;
+};
+export type SequenceOp = {
+    type: "addParticipant";
+    label: string;
+    isActor?: boolean;
+} | {
+    type: "renameParticipant";
+    id: string;
+    label: string;
+} | {
+    type: "deleteParticipant";
+    id: string;
+} | {
+    type: "addMessage";
+    from: string;
+    to: string;
+    text: string;
+    arrow?: SequenceArrow;
+} | {
+    type: "editMessage";
+    id: string;
+    from?: string;
+    to?: string;
+    text?: string;
+    arrow?: SequenceArrow;
+} | {
+    type: "deleteMessage";
+    id: string;
+} | {
+    type: "moveMessage";
+    id: string;
+    direction: "up" | "down";
+} | {
+    type: "setAutonumber";
+    enabled: boolean;
+};
+export type PieOp = {
+    type: "setTitle";
+    title: string;
+} | {
+    type: "setShowData";
+    enabled: boolean;
+} | {
+    type: "addSlice";
+    label: string;
+    value: number;
+} | {
+    type: "editSlice";
+    id: string;
+    label?: string;
+    value?: number;
+} | {
+    type: "deleteSlice";
+    id: string;
+};
+export type TimelineOp = {
+    type: "setTitle";
+    title: string;
+} | {
+    type: "addSection";
+    title: string;
+} | {
+    type: "renameSection";
+    id: string;
+    title: string;
+} | {
+    type: "deleteSection";
+    id: string;
+} | {
+    type: "addRow";
+    sectionId: string;
+    period: string;
+    event?: string;
+} | {
+    type: "editRow";
+    id: string;
+    period?: string;
+} | {
+    type: "addEvent";
+    rowId: string;
+    text: string;
+} | {
+    type: "editEvent";
+    rowId: string;
+    eventIndex: number;
+    text: string;
+} | {
+    type: "deleteEvent";
+    rowId: string;
+    eventIndex: number;
+} | {
+    type: "deleteRow";
+    id: string;
+};
+export type JourneyOp = {
+    type: "setTitle";
+    title: string;
+} | {
+    type: "addSection";
+    title: string;
+} | {
+    type: "renameSection";
+    id: string;
+    title: string;
+} | {
+    type: "deleteSection";
+    id: string;
+} | {
+    type: "addTask";
+    sectionId: string;
+    name: string;
+    score?: number;
+    actors?: string[];
+} | {
+    type: "editTask";
+    id: string;
+    name?: string;
+    score?: number;
+    actors?: string[];
+} | {
+    type: "deleteTask";
+    id: string;
+};
+export type QuadrantOp = {
+    type: "setTitle";
+    title: string;
+} | {
+    type: "setXAxis";
+    text: string;
+} | {
+    type: "setYAxis";
+    text: string;
+} | {
+    type: "setQuadrantLabel";
+    index: number;
+    text: string;
+} | {
+    type: "addPoint";
+    label: string;
+    x?: number;
+    y?: number;
+} | {
+    type: "editPoint";
+    id: string;
+    label?: string;
+    x?: number;
+    y?: number;
+} | {
+    type: "deletePoint";
+    id: string;
+};
+export type StateOp = {
+    type: "addState";
+    name: string;
+} | {
+    type: "setStateDescription";
+    id: string;
+    description: string;
+} | {
+    type: "deleteState";
+    id: string;
+} | {
+    type: "addTransition";
+    from: string;
+    to: string;
+    label?: string;
+} | {
+    type: "setTransitionLabel";
+    id: string;
+    label: string;
+} | {
+    type: "reverseTransition";
+    id: string;
+} | {
+    type: "deleteTransition";
+    id: string;
+};
+export type ErOp = {
+    type: "addRelationship";
+    left: string;
+    right: string;
+    label?: string;
+} | {
+    type: "setRelationshipLabel";
+    id: string;
+    label: string;
+} | {
+    type: "setRelationshipCardinality";
+    id: string;
+    leftCard?: string;
+    rightCard?: string;
+    identifying?: boolean;
+} | {
+    type: "reverseRelationship";
+    id: string;
+} | {
+    type: "deleteRelationship";
+    id: string;
+};
+export type MermaidOp = FlowchartOp | MindmapOp | SequenceOp | PieOp | TimelineOp | JourneyOp | QuadrantOp | StateOp | ErOp;

package/dist/mermaid/model/ops.js

@@ -0,0 +1,9 @@
+class MermaidOpError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "MermaidOpError";
+  }
+}
+export {
+  MermaidOpError
+};

package/dist/mermaid/model/round-trip.d.ts

@@ -0,0 +1,22 @@
+/**
+ * The round-trip fidelity gate — the hard guarantee behind structural editing.
+ *
+ * Structural modes (visual/outline) are enabled ONLY when the adapter has
+ * PROVEN lossless round-trip on this exact document: serialize(parse(s)) must
+ * equal s up to declared-safe normalization (trailing whitespace, blank-line
+ * collapse). Anything else downgrades to code-only BEFORE the user can edit —
+ * silent content destruction is structurally impossible, not just unlikely.
+ */
+import type { MermaidAdapter } from "./adapter.js";
+import type { ParseOutcome } from "./types.js";
+/** Declared-safe normalization: per-line trailing whitespace + blank runs. */
+export declare function normalizeForComparison(source: string): string;
+export interface GatedParseResult {
+    outcome: ParseOutcome;
+    /** Present when the gate fired — what serialize produced vs the original. */
+    roundTripDiff?: {
+        expected: string;
+        actual: string;
+    };
+}
+export declare function parseWithFidelityGate(adapter: MermaidAdapter, source: string): GatedParseResult;

package/dist/mermaid/model/round-trip.js

@@ -0,0 +1,45 @@
+function normalizeForComparison(source) {
+  return source.replace(/\r\n?/g, "\n").split("\n").map((line) => line.replace(/\s+$/, "")).join("\n").replace(/\n{3,}/g, "\n\n").replace(/^\n+|\n+$/g, "");
+}
+function parseWithFidelityGate(adapter, source) {
+  const outcome = adapter.parse(source);
+  if (outcome.status !== "ok") return { outcome };
+  let serialized;
+  try {
+    serialized = adapter.serialize(outcome.doc);
+  } catch (err) {
+    const detail = err instanceof Error ? err.message : String(err);
+    console.warn(
+      `[MermaidFidelityGate] ${adapter.diagramType} serialize threw during gate \u2014 downgrading to code-only`,
+      err
+    );
+    return {
+      outcome: {
+        status: "code-only",
+        reason: `the ${adapter.diagramType} structural editor hit an internal error (${detail}) \u2014 please report it`,
+        diagnostics: [{ line: 1, message: `serialize failed: ${detail}`, severity: "error" }]
+      }
+    };
+  }
+  const expected = normalizeForComparison(source);
+  const actual = normalizeForComparison(serialized);
+  if (expected !== actual) {
+    console.warn(
+      `[MermaidFidelityGate] ${adapter.diagramType} round-trip mismatch \u2014 structural editing disabled for this document`,
+      { expected, actual }
+    );
+    return {
+      outcome: {
+        status: "code-only",
+        reason: "this diagram uses syntax that structural editing can't preserve yet",
+        diagnostics: []
+      },
+      roundTripDiff: { expected, actual }
+    };
+  }
+  return { outcome };
+}
+export {
+  normalizeForComparison,
+  parseWithFidelityGate
+};