@ai-matrx/rich-content 0.2.4 → 0.2.6

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

@@ -0,0 +1,271 @@
+/**
+ * MermaidDocModel — typed structured documents parsed from mermaid DSL.
+ *
+ * The DSL string is ALWAYS the single source of truth; docs are derived,
+ * edited via operations, and serialized back. Every entity banks its original
+ * source line in `raw`; untouched entities re-emit `raw` verbatim so an edit
+ * to one node produces a minimal diff and never reformats the user's file.
+ *
+ * Anything an adapter recognizes but cannot structurally edit (classDef,
+ * linkStyle, click, style, accTitle, init directives, comments) is banked as
+ * a PassthroughSegment with a positional anchor and re-emitted on serialize.
+ * Anything an adapter does NOT recognize forces `code-only` — guessing would
+ * risk silent content destruction, which is structurally forbidden here.
+ */
+import type { MermaidDiagramType } from "../diagram-type.js";
+export interface Diagnostic {
+    line: number;
+    message: string;
+    severity: "error" | "warning";
+}
+/**
+ * One body line of the original source. Lines bound to an entity (`ref`) are
+ * re-emitted from `text` verbatim unless that entity is dirty (regenerate) or
+ * gone (skip). Unbound lines (comments, classDef, blanks, style, click, …)
+ * always re-emit verbatim — that is what makes round-trip lossless by
+ * construction.
+ */
+export interface SourceLine {
+    text: string;
+    ref?: {
+        entity: string;
+        id: string;
+    };
+}
+interface DocBase {
+    diagramType: MermaidDiagramType;
+    /** YAML frontmatter block (--- … ---), verbatim lines, empty when absent. */
+    frontmatter: string[];
+    /** Ordered body lines (everything after frontmatter). */
+    sourceLines: SourceLine[];
+    warnings: Diagnostic[];
+}
+export type FlowDirection = "TB" | "TD" | "LR" | "RL" | "BT";
+export type FlowShape = "rect" | "rounded" | "stadium" | "diamond" | "circle" | "hexagon" | "subroutine" | "cylinder";
+export type FlowEdgeStyle = "arrow" | "open" | "dotted" | "thick";
+export interface FlowNode {
+    id: string;
+    label: string;
+    shape: FlowShape;
+    /** Palette key from the adapter-owned classDef palette (visual color). */
+    paletteKey?: string;
+    /** Non-palette :::classes on the declaration, re-emitted on regeneration. */
+    extraClasses?: string[];
+    /** Original declaration line; absent for nodes declared inline in edges. */
+    raw?: string;
+    dirty?: boolean;
+    /** Created by an edit op (no source line) — serializer appends a decl. */
+    added?: boolean;
+}
+export interface FlowEdge {
+    id: string;
+    from: string;
+    to: string;
+    label?: string;
+    style: FlowEdgeStyle;
+    /** True when this edge's source line also declares the from/to node inline
+     *  (e.g. `A[Start] --> B{X}`) — regeneration must re-emit those decls. */
+    inlineFrom?: boolean;
+    inlineTo?: boolean;
+    raw?: string;
+    dirty?: boolean;
+    added?: boolean;
+}
+export interface FlowSubgraph {
+    id: string;
+    title: string;
+    nodeIds: string[];
+    raw?: string;
+}
+export interface FlowchartDoc extends DocBase {
+    kind: "flowchart";
+    direction: FlowDirection;
+    nodes: FlowNode[];
+    edges: FlowEdge[];
+    subgraphs: FlowSubgraph[];
+    /** Lines declaring several edges at once (chains / & fanout):
+     *  sourceLine ref {entity:"edgeGroup", id} → member edge ids. */
+    edgeGroups: Record<string, string[]>;
+}
+export type MindmapShape = "default" | "square" | "rounded" | "circle" | "cloud" | "bang" | "hexagon";
+export interface MindmapNode {
+    id: string;
+    label: string;
+    shape: MindmapShape;
+    /** ::icon(...) decorator line(s) attached to this node, verbatim. */
+    decorators: string[];
+    children: MindmapNode[];
+    raw?: string;
+    dirty?: boolean;
+}
+export interface MindmapDoc extends DocBase {
+    kind: "mindmap";
+    root: MindmapNode;
+    /** Structural ops (indent/outdent/move) regenerate the whole tree body —
+     *  content-preserving, formatting-normalizing. Set by applyOp. */
+    regenerateAll?: boolean;
+}
+export type SequenceArrow = "->>" | "-->>" | "->" | "-->" | "-x" | "--x" | "-)" | "--)";
+export interface SequenceParticipant {
+    id: string;
+    alias?: string;
+    isActor: boolean;
+    raw?: string;
+    dirty?: boolean;
+}
+export type SequenceItem = {
+    kind: "message";
+    id: string;
+    from: string;
+    to: string;
+    text: string;
+    arrow: SequenceArrow;
+    raw?: string;
+    dirty?: boolean;
+} | {
+    /** Notes, loops, alt/opt/par blocks, activations — locked rows, verbatim. */
+    kind: "passthrough";
+    id: string;
+    raw: string;
+};
+export interface SequenceDoc extends DocBase {
+    kind: "sequence";
+    autonumber: boolean;
+    participants: SequenceParticipant[];
+    items: SequenceItem[];
+}
+export interface PieSlice {
+    id: string;
+    label: string;
+    value: number;
+    raw?: string;
+    dirty?: boolean;
+}
+export interface PieDoc extends DocBase {
+    kind: "pie";
+    title?: string;
+    showData: boolean;
+    slices: PieSlice[];
+}
+export interface TimelineRow {
+    id: string;
+    period: string;
+    events: string[];
+    raw?: string;
+    dirty?: boolean;
+}
+export interface TimelineSection {
+    id: string;
+    /** undefined = the implicit section before any `section` line. */
+    title?: string;
+    rows: TimelineRow[];
+    raw?: string;
+    dirty?: boolean;
+}
+export interface TimelineDoc extends DocBase {
+    kind: "timeline";
+    title?: string;
+    sections: TimelineSection[];
+}
+export interface JourneyTask {
+    id: string;
+    name: string;
+    /** Satisfaction score, conventionally 1-5. */
+    score: number;
+    /** Actor names assigned to the task (comma-separated in source). */
+    actors: string[];
+    raw?: string;
+    dirty?: boolean;
+}
+export interface JourneySection {
+    id: string;
+    /** undefined = the implicit section before any `section` line. */
+    title?: string;
+    tasks: JourneyTask[];
+    raw?: string;
+    dirty?: boolean;
+}
+export interface JourneyDoc extends DocBase {
+    kind: "journey";
+    title?: string;
+    sections: JourneySection[];
+}
+export interface QuadrantPoint {
+    id: string;
+    label: string;
+    x: number;
+    y: number;
+    raw?: string;
+    dirty?: boolean;
+}
+export interface QuadrantDoc extends DocBase {
+    kind: "quadrant";
+    title?: string;
+    /** Axis labels: "Low --> High" forms, stored verbatim of the text portion. */
+    xAxis?: string;
+    yAxis?: string;
+    /** quadrant-1..4 labels (top-right, top-left, bottom-left, bottom-right). */
+    quadrantLabels: (string | undefined)[];
+    points: QuadrantPoint[];
+}
+export interface StateNode {
+    id: string;
+    /** Optional human description (from `id : desc` or `state "desc" as id`). */
+    description?: string;
+    raw?: string;
+    dirty?: boolean;
+    added?: boolean;
+}
+export interface StateTransition {
+    id: string;
+    from: string;
+    to: string;
+    label?: string;
+    raw?: string;
+    dirty?: boolean;
+    added?: boolean;
+}
+export interface StateDoc extends DocBase {
+    kind: "state";
+    /** stateDiagram (v1) vs stateDiagram-v2 — preserved verbatim. */
+    header: string;
+    states: StateNode[];
+    transitions: StateTransition[];
+}
+/** Mermaid ER cardinality token (as written next to the entity). */
+export type ErCardinality = "|o" | "||" | "}o" | "}|" | "o|" | "o{" | "|{";
+export interface ErRelationship {
+    id: string;
+    left: string;
+    right: string;
+    leftCard: string;
+    rightCard: string;
+    identifying: boolean;
+    label: string;
+    raw?: string;
+    dirty?: boolean;
+    added?: boolean;
+}
+export interface ErEntity {
+    id: string;
+    /** Whole `NAME { … }` attribute block, verbatim lines (header..close). */
+    blockRaw?: string[];
+}
+export interface ErDoc extends DocBase {
+    kind: "er";
+    entities: ErEntity[];
+    relationships: ErRelationship[];
+}
+export type MermaidDoc = FlowchartDoc | MindmapDoc | SequenceDoc | PieDoc | TimelineDoc | JourneyDoc | QuadrantDoc | StateDoc | ErDoc;
+export type ParseOutcome = {
+    status: "ok";
+    doc: MermaidDoc;
+} | {
+    status: "code-only";
+    reason: string;
+    diagnostics: Diagnostic[];
+} | {
+    status: "invalid";
+    diagnostics: Diagnostic[];
+};
+export {};

package/dist/mermaid/print-render.d.ts

@@ -0,0 +1,9 @@
+/** The source of every ```mermaid fence, as the print package will hand it back. */
+export declare function mermaidFenceSources(markdown: string): string[];
+export interface PrintedDiagrams {
+    /** SVG by fence source. */
+    pictures: Map<string, string>;
+    /** Fences that could not be drawn (they print as source). */
+    failed: number;
+}
+export declare function drawMermaidForPrint(markdown: string): Promise<PrintedDiagrams>;

package/dist/mermaid/print-render.js

@@ -0,0 +1,39 @@
+import { renderMermaid } from "./runtime.js";
+const PRINT_OPTIONS = { theme: "default", look: "classic", layout: "dagre" };
+function mermaidFenceSources(markdown) {
+  const out = [];
+  const lines = markdown.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const open = /^(\s*)(`{3,}|~{3,})\s*mermaid\b[^`]*$/.exec(lines[i]);
+    if (!open) continue;
+    const marker = open[2];
+    const indent = open[1].length;
+    const body = [];
+    let j = i + 1;
+    for (; j < lines.length; j++) {
+      const close = /^\s*(`{3,}|~{3,})\s*$/.exec(lines[j]);
+      if (close && close[1][0] === marker[0] && close[1].length >= marker.length) break;
+      body.push(lines[j]);
+    }
+    out.push(body.map((l) => l.slice(Math.min(indent, l.length - l.trimStart().length))).join("\n"));
+    i = j;
+  }
+  return out;
+}
+async function drawMermaidForPrint(markdown) {
+  const pictures = /* @__PURE__ */ new Map();
+  let failed = 0;
+  for (const source of new Set(mermaidFenceSources(markdown))) {
+    try {
+      const { svg } = await renderMermaid(source, PRINT_OPTIONS);
+      pictures.set(source, svg);
+    } catch {
+      failed++;
+    }
+  }
+  return { pictures, failed };
+}
+export {
+  drawMermaidForPrint,
+  mermaidFenceSources
+};

package/dist/mermaid/runtime.d.ts

@@ -0,0 +1,25 @@
+import { type MermaidRenderOptions } from "./types.js";
+export declare class MermaidRenderSupersededError extends Error {
+    constructor();
+}
+export declare function pieThemeVariables(theme: MermaidRenderOptions["theme"]): Record<string, string> | undefined;
+/** Fire-and-forget warmup — call when a mermaid block mounts mid-stream. */
+export declare function preloadMermaid(): void;
+export declare function isElkAvailable(): boolean;
+/**
+ * Parse-only validation. Returns ok=false (never throws) on invalid source.
+ */
+export declare function validateMermaid(source: string): Promise<{
+    ok: boolean;
+    error?: string;
+}>;
+/**
+ * Serialized render — mermaid.render is async AND reads global config; two
+ * concurrent renders with different options would corrupt each other. A
+ * failed render must not poison the chain for the next caller.
+ */
+export declare function renderMermaid(source: string, opts: MermaidRenderOptions, consumerId?: string): Promise<{
+    svg: string;
+}>;
+/** Mark a mounted renderer's queued work stale before its next debounce fires. */
+export declare function supersedeMermaidRender(consumerId: string): void;

package/dist/mermaid/runtime.js

@@ -0,0 +1,183 @@
+"use client";
+import { announceBareHost, hostCapability } from "../host/registry.js";
+import { humanizeMermaidError } from "./sanitize.js";
+import { renderOptionsKey } from "./types.js";
+console.log(
+  "%c[MERMAID IMPORT TEST] components/mermaid/runtime.ts",
+  "color: #fff; background: #7c3aed; font-weight: bold; padding: 2px 6px; border-radius: 3px;"
+);
+let mermaidPromise = null;
+let elkPromise = null;
+let elkRegistered = false;
+let lastConfigKey = "";
+let renderChain = Promise.resolve();
+let idCounter = 0;
+const MAX_RENDER_CACHE_ENTRIES = 12;
+const renderCache = /* @__PURE__ */ new Map();
+const inFlightRenders = /* @__PURE__ */ new Map();
+const latestRenderByConsumer = /* @__PURE__ */ new Map();
+class MermaidRenderSupersededError extends Error {
+  constructor() {
+    super("Mermaid render superseded by newer source");
+    this.name = "MermaidRenderSupersededError";
+  }
+}
+function baseConfig() {
+  return {
+    startOnLoad: false,
+    securityLevel: "strict",
+    // Plain-SVG labels (no <foreignObject>) so PNG export via canvas never
+    // taints and Safari rasterization works.
+    flowchart: { htmlLabels: false },
+    fontFamily: "inherit"
+  };
+}
+const PIE_PALETTE = {
+  default: ["#2a78d6", "#eb6834", "#1baf7a", "#eda100", "#e87ba4", "#008300", "#4a3aa7", "#e34948"],
+  dark: ["#3987e5", "#d95926", "#199e70", "#c98500", "#d55181", "#008300", "#9085e9", "#e66767"]
+};
+function pieThemeVariables(theme) {
+  if (theme !== "default" && theme !== "dark") return void 0;
+  const slices = PIE_PALETTE[theme];
+  const vars = {
+    pieSectionTextColor: "#ffffff",
+    pieStrokeColor: theme === "dark" ? "#262626" : "#ffffff",
+    pieStrokeWidth: "2px",
+    pieOuterStrokeWidth: "0px",
+    pieOpacity: "1"
+  };
+  for (let i = 0; i < 12; i++) vars[`pie${i + 1}`] = slices[i % slices.length];
+  return vars;
+}
+async function getMermaid() {
+  if (!mermaidPromise) {
+    mermaidPromise = (async () => {
+      const load = hostCapability("loadMermaid");
+      if (!load) {
+        announceBareHost("loadMermaid", "diagrams show their source");
+        throw new Error("This app has no diagram renderer installed.");
+      }
+      const mermaid = await load();
+      mermaid.initialize(baseConfig());
+      lastConfigKey = "";
+      return mermaid;
+    })();
+  }
+  return mermaidPromise;
+}
+async function ensureElk(mermaid) {
+  if (elkRegistered) return true;
+  if (!elkPromise) {
+    const loadElk = hostCapability("loadMermaidElk");
+    elkPromise = (loadElk ? loadElk() : Promise.reject(new Error("no ELK layout from the host"))).then((elk) => {
+      mermaid.registerLayoutLoaders(elk);
+      elkRegistered = true;
+      return true;
+    }).catch((err) => {
+      console.warn(
+        "[MermaidRuntime] ELK layout plugin failed to load; dagre only",
+        err
+      );
+      return false;
+    });
+  }
+  return elkPromise;
+}
+function preloadMermaid() {
+  if (typeof window === "undefined") return;
+  void getMermaid().catch(() => {
+  });
+}
+function isElkAvailable() {
+  return elkRegistered;
+}
+async function validateMermaid(source) {
+  try {
+    const mermaid = await getMermaid();
+    const result = await mermaid.parse(source, { suppressErrors: true });
+    return result === false ? { ok: false } : { ok: true };
+  } catch (err) {
+    const raw = err instanceof Error ? err.message : String(err);
+    console.warn(
+      "[MermaidRuntime] mermaid.parse threw (not a clean parse failure):",
+      err
+    );
+    return { ok: false, error: humanizeMermaidError(raw) };
+  }
+}
+async function applyOptions(mermaid, opts) {
+  const layout = opts.layout === "elk" && !await ensureElk(mermaid) ? "dagre" : opts.layout;
+  const key = renderOptionsKey({ ...opts, layout });
+  if (key === lastConfigKey) return;
+  mermaid.initialize({
+    ...baseConfig(),
+    theme: opts.theme,
+    look: opts.look,
+    layout,
+    themeVariables: pieThemeVariables(opts.theme),
+    pie: { legendPosition: opts.pieLegend ?? "right" }
+  });
+  lastConfigKey = key;
+}
+async function doRender(source, opts) {
+  const mermaid = await getMermaid();
+  await applyOptions(mermaid, opts);
+  const id = `mmd-${++idCounter}`;
+  try {
+    const { svg } = await mermaid.render(id, source);
+    return { svg };
+  } catch (err) {
+    document.getElementById(id)?.remove();
+    document.getElementById(`d${id}`)?.remove();
+    throw err;
+  }
+}
+function renderMermaid(source, opts, consumerId) {
+  const cacheKey = `${renderOptionsKey(opts)}\0${source}`;
+  if (consumerId) latestRenderByConsumer.set(consumerId, cacheKey);
+  const cached = renderCache.get(cacheKey);
+  if (cached) {
+    renderCache.delete(cacheKey);
+    renderCache.set(cacheKey, cached);
+    return Promise.resolve(cached);
+  }
+  const inFlight = inFlightRenders.get(cacheKey);
+  if (inFlight) {
+    inFlight.consumers.add(consumerId ?? null);
+    return inFlight.promise;
+  }
+  const consumers = /* @__PURE__ */ new Set([consumerId ?? null]);
+  const task = renderChain.then(() => {
+    const stillWanted = [...consumers].some(
+      (id) => id === null || latestRenderByConsumer.get(id) === cacheKey
+    );
+    if (!stillWanted) throw new MermaidRenderSupersededError();
+    return doRender(source, opts);
+  }).then((result) => {
+    renderCache.set(cacheKey, result);
+    while (renderCache.size > MAX_RENDER_CACHE_ENTRIES) {
+      const oldestKey = renderCache.keys().next().value;
+      if (oldestKey === void 0) break;
+      renderCache.delete(oldestKey);
+    }
+    return result;
+  }).finally(() => {
+    inFlightRenders.delete(cacheKey);
+  });
+  inFlightRenders.set(cacheKey, { promise: task, consumers });
+  renderChain = task.catch(() => {
+  });
+  return task;
+}
+function supersedeMermaidRender(consumerId) {
+  latestRenderByConsumer.delete(consumerId);
+}
+export {
+  MermaidRenderSupersededError,
+  isElkAvailable,
+  pieThemeVariables,
+  preloadMermaid,
+  renderMermaid,
+  supersedeMermaidRender,
+  validateMermaid
+};

package/dist/mermaid/sanitize.d.ts

@@ -0,0 +1,46 @@
+/**
+ * The forgiving ladder — progressive auto-repair of LLM-generated mermaid.
+ *
+ * Contract:
+ *  - Pure and mermaid-free: the validator is injected, so this module is unit
+ *    testable and never drags the engine into a bundle.
+ *  - The ORIGINAL source is never destroyed — callers render the fixed source
+ *    but copy/export the original. Fixes are reported, not silent.
+ *  - Recovery SCREAMS (console.warn) — a fixer firing means an agent emitted
+ *    broken syntax, which is a real upstream defect we want visible.
+ *  - Streaming mode runs only the lossless Stage A normalizers: partial text
+ *    is EXPECTED to fail validation, so heavy per-rule work is skipped and the
+ *    caller keeps its last-good render.
+ */
+export interface MermaidFix {
+    rule: string;
+    detail: string;
+}
+export interface LadderResult {
+    /** The source that validated (fixed), or the best-effort source if invalid. */
+    source: string;
+    valid: boolean;
+    fixes: MermaidFix[];
+    /** The engine's parse error message when invalid after all fixers. */
+    error?: string;
+}
+export type MermaidValidator = (source: string) => Promise<{
+    ok: boolean;
+    error?: string;
+}>;
+/**
+ * Turn an engine error into something a human can act on. Mermaid (and the
+ * libraries under it) sometimes throw raw JS runtime errors — most notoriously
+ * a `Converting circular structure to JSON … __reactFiber …` TypeError that
+ * carries a live DOM node — instead of a parse message. Those say nothing
+ * useful to the reader, so we replace them with a clear line. The raw text is
+ * still logged at the call site for debugging.
+ */
+export declare function humanizeMermaidError(raw?: string): string | undefined;
+/**
+ * Run the ladder: raw → Stage A normalizers → per-rule Stage B fixers,
+ * validating cumulatively, until the source parses or every rule is spent.
+ */
+export declare function parseWithLadder(raw: string, validate: MermaidValidator, opts: {
+    streaming: boolean;
+}): Promise<LadderResult>;