@ai-matrx/rich-content 0.2.4 → 0.2.6

package/dist/mermaid/adapters/state.js

@@ -0,0 +1,245 @@
+import { splitFrontmatter } from "../diagram-type.js";
+import { MermaidOpError } from "../model/ops.js";
+const HEADER_RE = /^stateDiagram(-v2)?\s*$/;
+const TRANSITION_RE = /^(\[\*\]|\w+)\s*-->\s*(\[\*\]|\w+)\s*(?::\s*(.*))?$/;
+const ALIAS_RE = /^state\s+"([^"]*)"\s+as\s+(\w+)\s*$/;
+const DECL_RE = /^state\s+(\w+)\s*$/;
+const DESC_RE = /^(\w+)\s*:\s*(.+)$/;
+const BARE_RE = /^\w+$/;
+const DIRECTION_RE = /^direction\s+\w+\s*$/;
+function parse(source) {
+  const { bodyStartIndex, lines } = splitFrontmatter(source);
+  const doc = {
+    kind: "state",
+    diagramType: "state",
+    frontmatter: lines.slice(0, bodyStartIndex),
+    sourceLines: [],
+    warnings: [],
+    header: "stateDiagram-v2",
+    states: [],
+    transitions: []
+  };
+  const byId = /* @__PURE__ */ new Map();
+  const ensure = (id) => {
+    let node = byId.get(id);
+    if (!node) {
+      node = { id };
+      byId.set(id, node);
+      doc.states.push(node);
+    }
+    return node;
+  };
+  let headerSeen = false;
+  let counter = 0;
+  for (const rawLine of lines.slice(bodyStartIndex)) {
+    const trimmed = rawLine.trim();
+    if (!trimmed || trimmed.startsWith("%%")) {
+      doc.sourceLines.push({ text: rawLine });
+      continue;
+    }
+    if (!headerSeen) {
+      if (!HEADER_RE.test(trimmed)) {
+        return { status: "code-only", reason: "unrecognized state diagram header", diagnostics: [] };
+      }
+      headerSeen = true;
+      doc.header = trimmed;
+      doc.sourceLines.push({ text: rawLine, ref: { entity: "header", id: "header" } });
+      continue;
+    }
+    if (trimmed.includes("{") || trimmed.includes("}") || trimmed.includes("<<") || trimmed === "--" || /^note\b/.test(trimmed)) {
+      return { status: "code-only", reason: "uses composite states, notes, or forks", diagnostics: [] };
+    }
+    if (DIRECTION_RE.test(trimmed)) {
+      doc.sourceLines.push({ text: rawLine });
+      continue;
+    }
+    const tr = TRANSITION_RE.exec(trimmed);
+    if (tr) {
+      const from = tr[1];
+      const to = tr[2];
+      if (from !== "[*]") ensure(from);
+      if (to !== "[*]") ensure(to);
+      const t = {
+        id: `st${++counter}`,
+        from,
+        to,
+        label: tr[3]?.trim() || void 0,
+        raw: rawLine
+      };
+      doc.transitions.push(t);
+      doc.sourceLines.push({ text: rawLine, ref: { entity: "transition", id: t.id } });
+      continue;
+    }
+    const alias = ALIAS_RE.exec(trimmed);
+    if (alias) {
+      const node = ensure(alias[2]);
+      node.description = alias[1];
+      node.descForm = "alias";
+      node.hasLine = true;
+      node.raw = rawLine;
+      doc.sourceLines.push({ text: rawLine, ref: { entity: "stateLine", id: node.id } });
+      continue;
+    }
+    const decl = DECL_RE.exec(trimmed);
+    if (decl) {
+      const node = ensure(decl[1]);
+      node.hasLine = true;
+      node.raw = rawLine;
+      doc.sourceLines.push({ text: rawLine, ref: { entity: "stateLine", id: node.id } });
+      continue;
+    }
+    const desc = DESC_RE.exec(trimmed);
+    if (desc) {
+      const node = ensure(desc[1]);
+      node.description = desc[2].trim();
+      node.descForm = "colon";
+      node.hasLine = true;
+      node.raw = rawLine;
+      doc.sourceLines.push({ text: rawLine, ref: { entity: "stateLine", id: node.id } });
+      continue;
+    }
+    if (BARE_RE.test(trimmed)) {
+      const node = ensure(trimmed);
+      node.hasLine = true;
+      node.raw = rawLine;
+      doc.sourceLines.push({ text: rawLine, ref: { entity: "stateLine", id: node.id } });
+      continue;
+    }
+    return {
+      status: "code-only",
+      reason: `unrecognized statement: "${trimmed.slice(0, 40)}"`,
+      diagnostics: []
+    };
+  }
+  if (!headerSeen) {
+    return { status: "invalid", diagnostics: [{ line: 1, message: "missing state diagram header", severity: "error" }] };
+  }
+  return { status: "ok", doc };
+}
+function stateLineText(node) {
+  if (node.description !== void 0) {
+    return node.descForm === "alias" ? `state "${node.description}" as ${node.id}` : `${node.id} : ${node.description}`;
+  }
+  return node.id;
+}
+function transitionLine(t) {
+  return t.label ? `${t.from} --> ${t.to} : ${t.label}` : `${t.from} --> ${t.to}`;
+}
+function serialize(doc) {
+  const out = [...doc.frontmatter];
+  const states = doc.states;
+  const stateById = new Map(states.map((s) => [s.id, s]));
+  const transitionById = new Map(doc.transitions.map((t) => [t.id, t]));
+  const emittedState = /* @__PURE__ */ new Set();
+  const emittedTransition = /* @__PURE__ */ new Set();
+  for (const line of doc.sourceLines) {
+    const indent = /^(\s*)/.exec(line.text)?.[1] ?? "";
+    if (!line.ref) {
+      out.push(line.text);
+      continue;
+    }
+    switch (line.ref.entity) {
+      case "transition": {
+        const t = transitionById.get(line.ref.id);
+        if (!t) break;
+        emittedTransition.add(t.id);
+        out.push(t.dirty ? `${indent}${transitionLine(t)}` : line.text);
+        break;
+      }
+      case "stateLine": {
+        const node = stateById.get(line.ref.id);
+        if (!node) break;
+        emittedState.add(node.id);
+        out.push(node.dirty ? `${indent}${stateLineText(node)}` : line.text);
+        break;
+      }
+      default:
+        out.push(line.text);
+    }
+  }
+  const additions = [];
+  for (const node of states) {
+    if (emittedState.has(node.id)) continue;
+    if (node.added || node.dirty && node.description !== void 0) {
+      additions.push(`  ${stateLineText(node)}`);
+    }
+  }
+  for (const t of doc.transitions) {
+    if (!emittedTransition.has(t.id) && !t.raw) additions.push(`  ${transitionLine(t)}`);
+  }
+  return [...out, ...additions].join("\n");
+}
+function applyOp(doc, op) {
+  const next = structuredClone(doc);
+  const sop = op;
+  const findState = (id) => {
+    const s = next.states.find((x) => x.id === id);
+    if (!s) throw new MermaidOpError("That state no longer exists");
+    return s;
+  };
+  const findTransition = (id) => {
+    const t = next.transitions.find((x) => x.id === id);
+    if (!t) throw new MermaidOpError("That transition no longer exists");
+    return t;
+  };
+  switch (sop.type) {
+    case "addState": {
+      const id = sop.name.trim();
+      if (!/^\w+$/.test(id)) throw new MermaidOpError("State names must be a single word (letters, digits, _)");
+      if (next.states.some((s) => s.id === id)) throw new MermaidOpError("A state with that name already exists");
+      next.states.push({ id, added: true });
+      return next;
+    }
+    case "setStateDescription": {
+      const s = findState(sop.id);
+      s.description = sop.description || void 0;
+      s.dirty = true;
+      return next;
+    }
+    case "deleteState": {
+      findState(sop.id);
+      next.states = next.states.filter((s) => s.id !== sop.id);
+      next.transitions = next.transitions.filter((t) => t.from !== sop.id && t.to !== sop.id);
+      return next;
+    }
+    case "addTransition": {
+      next.transitions.push({
+        id: `st_a${next.transitions.length + 1}`,
+        from: sop.from,
+        to: sop.to,
+        label: sop.label?.trim() || void 0,
+        added: true
+      });
+      return next;
+    }
+    case "setTransitionLabel": {
+      const t = findTransition(sop.id);
+      t.label = sop.label.trim() || void 0;
+      t.dirty = true;
+      return next;
+    }
+    case "reverseTransition": {
+      const t = findTransition(sop.id);
+      [t.from, t.to] = [t.to, t.from];
+      t.dirty = true;
+      return next;
+    }
+    case "deleteTransition": {
+      findTransition(sop.id);
+      next.transitions = next.transitions.filter((t) => t.id !== sop.id);
+      return next;
+    }
+    default:
+      throw new MermaidOpError("Unsupported operation for state diagrams");
+  }
+}
+const stateAdapter = {
+  diagramType: "state",
+  parse,
+  serialize,
+  applyOp,
+  vocabulary: { node: "State", addNode: "Add state", edge: "Transition" }
+};
+export {
+  stateAdapter
+};

package/dist/mermaid/adapters/timeline.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Timeline adapter. Rows (`period : event : event`) and sections edit
+ * per-line; structural inserts/deletes regenerate the body wholesale
+ * (content-preserving, formatting-normalizing).
+ */
+import type { MermaidAdapter } from "../model/adapter.js";
+import type { TimelineDoc } from "../model/types.js";
+export declare const timelineAdapter: MermaidAdapter<TimelineDoc>;

package/dist/mermaid/adapters/timeline.js

@@ -0,0 +1,245 @@
+import { splitFrontmatter } from "../diagram-type.js";
+import { MermaidOpError } from "../model/ops.js";
+function parse(source) {
+  const { bodyStartIndex, lines } = splitFrontmatter(source);
+  const doc = {
+    kind: "timeline",
+    diagramType: "timeline",
+    frontmatter: lines.slice(0, bodyStartIndex),
+    sourceLines: [],
+    warnings: [],
+    sections: []
+  };
+  let headerSeen = false;
+  let counter = 0;
+  let sectionCounter = 0;
+  let currentSection = null;
+  let lastRow = null;
+  const implicitSection = () => {
+    if (!currentSection) {
+      currentSection = { id: `sec${++sectionCounter}`, rows: [] };
+      doc.sections.push(currentSection);
+    }
+    return currentSection;
+  };
+  for (const rawLine of lines.slice(bodyStartIndex)) {
+    const trimmed = rawLine.trim();
+    if (!trimmed || trimmed.startsWith("%%")) {
+      doc.sourceLines.push({ text: rawLine });
+      continue;
+    }
+    if (!headerSeen) {
+      if (!/^timeline\s*$/.test(trimmed)) {
+        return { status: "code-only", reason: "unrecognized timeline header", diagnostics: [] };
+      }
+      headerSeen = true;
+      doc.sourceLines.push({ text: rawLine, ref: { entity: "header", id: "header" } });
+      continue;
+    }
+    const title = /^title\s+(.+)$/.exec(trimmed);
+    if (title && doc.title === void 0) {
+      doc.title = title[1].trim();
+      doc.sourceLines.push({ text: rawLine, ref: { entity: "title", id: "title" } });
+      continue;
+    }
+    const section = /^section\s+(.+)$/.exec(trimmed);
+    if (section) {
+      currentSection = {
+        id: `sec${++sectionCounter}`,
+        title: section[1].trim(),
+        rows: [],
+        raw: rawLine
+      };
+      doc.sections.push(currentSection);
+      lastRow = null;
+      doc.sourceLines.push({ text: rawLine, ref: { entity: "section", id: currentSection.id } });
+      continue;
+    }
+    if (trimmed.startsWith(":")) {
+      if (!lastRow) {
+        return { status: "code-only", reason: "event continuation with no period", diagnostics: [] };
+      }
+      const events = trimmed.split(":").map((e) => e.trim()).filter(Boolean);
+      lastRow.events.push(...events);
+      doc.sourceLines.push({ text: rawLine, ref: { entity: "rowCont", id: lastRow.id } });
+      continue;
+    }
+    if (trimmed.includes(":")) {
+      const [period, ...events] = trimmed.split(":").map((p) => p.trim());
+      const row2 = {
+        id: `t${++counter}`,
+        period,
+        events: events.filter(Boolean),
+        raw: rawLine
+      };
+      implicitSection().rows.push(row2);
+      lastRow = row2;
+      doc.sourceLines.push({ text: rawLine, ref: { entity: "row", id: row2.id } });
+      continue;
+    }
+    const row = { id: `t${++counter}`, period: trimmed, events: [], raw: rawLine };
+    implicitSection().rows.push(row);
+    lastRow = row;
+    doc.sourceLines.push({ text: rawLine, ref: { entity: "row", id: row.id } });
+  }
+  if (!headerSeen) {
+    return { status: "invalid", diagnostics: [{ line: 1, message: "missing timeline header", severity: "error" }] };
+  }
+  return { status: "ok", doc };
+}
+function rowLine(row) {
+  return row.events.length > 0 ? `${row.period} : ${row.events.join(" : ")}` : row.period;
+}
+function serialize(doc) {
+  const tdoc = doc;
+  const out = [...doc.frontmatter];
+  if (tdoc.regenerateAll) {
+    const comments = doc.sourceLines.filter((l) => !l.ref && l.text.trim().startsWith("%%")).map((l) => l.text);
+    out.push("timeline", ...comments);
+    if (doc.title !== void 0) out.push(`  title ${doc.title}`);
+    for (const section of doc.sections) {
+      if (section.title !== void 0) out.push(`  section ${section.title}`);
+      for (const row of section.rows) out.push(`    ${rowLine(row)}`);
+    }
+    return out.join("\n");
+  }
+  const rowById = /* @__PURE__ */ new Map();
+  const sectionById = /* @__PURE__ */ new Map();
+  for (const section of doc.sections) {
+    sectionById.set(section.id, section);
+    for (const row of section.rows) rowById.set(row.id, row);
+  }
+  const emitted = /* @__PURE__ */ new Set();
+  for (const line of doc.sourceLines) {
+    const indent = /^(\s*)/.exec(line.text)?.[1] ?? "";
+    if (!line.ref) {
+      out.push(line.text);
+      continue;
+    }
+    switch (line.ref.entity) {
+      case "title":
+        if (doc.title === void 0) break;
+        out.push(tdoc.dirtyTitle ? `${indent}title ${doc.title}` : line.text);
+        break;
+      case "section": {
+        const section = sectionById.get(line.ref.id);
+        if (!section) break;
+        out.push(section.dirty ? `${indent}section ${section.title ?? ""}` : line.text);
+        break;
+      }
+      case "row": {
+        const row = rowById.get(line.ref.id);
+        if (!row) break;
+        emitted.add(row.id);
+        out.push(row.dirty ? `${indent}${rowLine(row)}` : line.text);
+        break;
+      }
+      case "rowCont": {
+        const row = rowById.get(line.ref.id);
+        if (!row || row.dirty) break;
+        out.push(line.text);
+        break;
+      }
+      default:
+        out.push(line.text);
+    }
+  }
+  return out.join("\n");
+}
+function applyOp(doc, op) {
+  const next = structuredClone(doc);
+  const top = op;
+  const findRow = (id) => {
+    for (const section of next.sections) {
+      const row = section.rows.find((r) => r.id === id);
+      if (row) return row;
+    }
+    throw new MermaidOpError("That entry no longer exists");
+  };
+  const findSection = (id) => {
+    const s = next.sections.find((x) => x.id === id);
+    if (!s) throw new MermaidOpError("That section no longer exists");
+    return s;
+  };
+  switch (top.type) {
+    case "setTitle": {
+      next.title = top.title || void 0;
+      next.dirtyTitle = true;
+      if (!next.sourceLines.some((l) => l.ref?.entity === "title")) next.regenerateAll = true;
+      return next;
+    }
+    case "addSection": {
+      next.sections.push({ id: `sec_a${next.sections.length + 1}`, title: top.title, rows: [] });
+      next.regenerateAll = true;
+      return next;
+    }
+    case "renameSection": {
+      const s = findSection(top.id);
+      s.title = top.title;
+      s.dirty = true;
+      return next;
+    }
+    case "deleteSection": {
+      findSection(top.id);
+      next.sections = next.sections.filter((s) => s.id !== top.id);
+      next.regenerateAll = true;
+      return next;
+    }
+    case "addRow": {
+      const s = findSection(top.sectionId);
+      s.rows.push({
+        id: `t_a${s.rows.length + 1}`,
+        period: top.period,
+        events: top.event ? [top.event] : []
+      });
+      next.regenerateAll = true;
+      return next;
+    }
+    case "editRow": {
+      const row = findRow(top.id);
+      if (top.period !== void 0) row.period = top.period;
+      row.dirty = true;
+      return next;
+    }
+    case "addEvent": {
+      const row = findRow(top.rowId);
+      row.events.push(top.text);
+      row.dirty = true;
+      return next;
+    }
+    case "editEvent": {
+      const row = findRow(top.rowId);
+      if (top.eventIndex < 0 || top.eventIndex >= row.events.length) {
+        throw new MermaidOpError("That event no longer exists");
+      }
+      row.events[top.eventIndex] = top.text;
+      row.dirty = true;
+      return next;
+    }
+    case "deleteEvent": {
+      const row = findRow(top.rowId);
+      row.events.splice(top.eventIndex, 1);
+      row.dirty = true;
+      return next;
+    }
+    case "deleteRow": {
+      findRow(top.id);
+      for (const section of next.sections) {
+        section.rows = section.rows.filter((r) => r.id !== top.id);
+      }
+      return next;
+    }
+    default:
+      throw new MermaidOpError("Unsupported operation for timelines");
+  }
+}
+const timelineAdapter = {
+  diagramType: "timeline",
+  parse,
+  serialize,
+  applyOp,
+  vocabulary: { node: "Entry", addNode: "Add entry" }
+};
+export {
+  timelineAdapter
+};

package/dist/mermaid/catalog.d.ts

@@ -0,0 +1,33 @@
+/**
+ * The per-diagram-type catalog — single source of truth for how each mermaid
+ * diagram type is PRESENTED to users as a distinct feature ("Flowchart",
+ * "Mind Map", "Sequence Diagram", …) while one backbone renders them all.
+ *
+ * Drives: block/canvas labels and icons, starter templates, the new-diagram
+ * picker, and which types support structural (visual/outline) editing.
+ */
+import type { LucideIcon } from "lucide-react";
+import type { MermaidDiagramType } from "./diagram-type.js";
+export type MermaidSupportLevel = "full" | "code-only";
+export interface MermaidCatalogEntry {
+    /** User-facing feature name — never says "mermaid". */
+    label: string;
+    icon: LucideIcon;
+    description: string;
+    /** Complete, valid starter source for "create new". */
+    starterTemplate: string;
+    /**
+     * "full"  → structural editing planned/available (visual + outline modes
+     *           gate further on an adapter passing the round-trip fidelity check)
+     * "code-only" → render + code + AI editing only
+     */
+    support: MermaidSupportLevel;
+    /** Featured types appear in the create-new picker. */
+    featured?: boolean;
+}
+export declare const MERMAID_CATALOG: Record<MermaidDiagramType, MermaidCatalogEntry>;
+export declare function getCatalogEntry(type: MermaidDiagramType): MermaidCatalogEntry;
+/** Entries shown in the create-new picker, in catalog order. */
+export declare function getFeaturedCatalogEntries(): Array<MermaidCatalogEntry & {
+    type: MermaidDiagramType;
+}>;