@ai-matrx/rich-content 0.2.4 → 0.2.6

package/dist/mermaid/adapters/quadrant.js

@@ -0,0 +1,231 @@
+import { splitFrontmatter } from "../diagram-type.js";
+import { MermaidOpError } from "../model/ops.js";
+const TITLE_RE = /^title\s+(.+)$/;
+const XAXIS_RE = /^x-axis\s+(.+)$/;
+const YAXIS_RE = /^y-axis\s+(.+)$/;
+const QUADRANT_RE = /^quadrant-([1-4])\s+(.+)$/;
+const POINT_RE = /^(.+?):\s*\[\s*([0-9]*\.?[0-9]+)\s*,\s*([0-9]*\.?[0-9]+)\s*\]\s*$/;
+function parse(source) {
+  const { bodyStartIndex, lines } = splitFrontmatter(source);
+  const doc = {
+    kind: "quadrant",
+    diagramType: "quadrant",
+    frontmatter: lines.slice(0, bodyStartIndex),
+    sourceLines: [],
+    warnings: [],
+    quadrantLabels: [void 0, void 0, void 0, void 0],
+    points: [],
+    dirty: {},
+    present: /* @__PURE__ */ new Set()
+  };
+  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 (!/^quadrantChart\s*$/.test(trimmed)) {
+        return { status: "code-only", reason: "unrecognized quadrant header", diagnostics: [] };
+      }
+      headerSeen = true;
+      doc.sourceLines.push({ text: rawLine, ref: { entity: "header", id: "header" } });
+      continue;
+    }
+    const title = TITLE_RE.exec(trimmed);
+    if (title && doc.title === void 0) {
+      doc.title = title[1].trim();
+      doc.present.add("title");
+      doc.sourceLines.push({ text: rawLine, ref: { entity: "title", id: "title" } });
+      continue;
+    }
+    const xaxis = XAXIS_RE.exec(trimmed);
+    if (xaxis && doc.xAxis === void 0) {
+      doc.xAxis = xaxis[1].trim();
+      doc.present.add("xAxis");
+      doc.sourceLines.push({ text: rawLine, ref: { entity: "xAxis", id: "xAxis" } });
+      continue;
+    }
+    const yaxis = YAXIS_RE.exec(trimmed);
+    if (yaxis && doc.yAxis === void 0) {
+      doc.yAxis = yaxis[1].trim();
+      doc.present.add("yAxis");
+      doc.sourceLines.push({ text: rawLine, ref: { entity: "yAxis", id: "yAxis" } });
+      continue;
+    }
+    const quad = QUADRANT_RE.exec(trimmed);
+    if (quad) {
+      const idx = Number(quad[1]) - 1;
+      if (doc.quadrantLabels[idx] === void 0) {
+        doc.quadrantLabels[idx] = quad[2].trim();
+        doc.present.add(`q${idx}`);
+        doc.sourceLines.push({ text: rawLine, ref: { entity: "quadrant", id: String(idx) } });
+        continue;
+      }
+    }
+    const point = POINT_RE.exec(trimmed);
+    if (point) {
+      const p = {
+        id: `q${++counter}`,
+        label: point[1].trim(),
+        x: Number(point[2]),
+        y: Number(point[3]),
+        raw: rawLine
+      };
+      doc.points.push(p);
+      doc.sourceLines.push({ text: rawLine, ref: { entity: "point", id: p.id } });
+      continue;
+    }
+    return {
+      status: "code-only",
+      reason: `unrecognized statement: "${trimmed.slice(0, 40)}"`,
+      diagnostics: []
+    };
+  }
+  if (!headerSeen) {
+    return { status: "invalid", diagnostics: [{ line: 1, message: "missing quadrantChart header", severity: "error" }] };
+  }
+  return { status: "ok", doc };
+}
+function pointLine(p) {
+  return `${p.label}: [${p.x}, ${p.y}]`;
+}
+function serialize(doc) {
+  const qdoc = doc;
+  const out = [...doc.frontmatter];
+  const pointById = new Map(doc.points.map((p) => [p.id, p]));
+  const emitted = /* @__PURE__ */ new Set();
+  let singletonAnchor = -1;
+  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 "header":
+        out.push(line.text);
+        singletonAnchor = out.length - 1;
+        break;
+      case "title":
+        if (doc.title === void 0) break;
+        out.push(qdoc.dirty.title ? `${indent}title ${doc.title}` : line.text);
+        singletonAnchor = out.length - 1;
+        break;
+      case "xAxis":
+        if (doc.xAxis === void 0) break;
+        out.push(qdoc.dirty.xAxis ? `${indent}x-axis ${doc.xAxis}` : line.text);
+        singletonAnchor = out.length - 1;
+        break;
+      case "yAxis":
+        if (doc.yAxis === void 0) break;
+        out.push(qdoc.dirty.yAxis ? `${indent}y-axis ${doc.yAxis}` : line.text);
+        singletonAnchor = out.length - 1;
+        break;
+      case "quadrant": {
+        const idx = Number(line.ref.id);
+        const label = doc.quadrantLabels[idx];
+        if (label === void 0) break;
+        const dirtyKey = `q${idx}`;
+        out.push(qdoc.dirty[dirtyKey] ? `${indent}quadrant-${idx + 1} ${label}` : line.text);
+        singletonAnchor = out.length - 1;
+        break;
+      }
+      case "point": {
+        const p = pointById.get(line.ref.id);
+        if (!p) break;
+        emitted.add(p.id);
+        out.push(p.dirty ? `${indent}${pointLine(p)}` : line.text);
+        break;
+      }
+      default:
+        out.push(line.text);
+    }
+  }
+  const inserts = [];
+  if (doc.title !== void 0 && !qdoc.present.has("title")) inserts.push(`  title ${doc.title}`);
+  if (doc.xAxis !== void 0 && !qdoc.present.has("xAxis")) inserts.push(`  x-axis ${doc.xAxis}`);
+  if (doc.yAxis !== void 0 && !qdoc.present.has("yAxis")) inserts.push(`  y-axis ${doc.yAxis}`);
+  for (let i = 0; i < 4; i++) {
+    if (doc.quadrantLabels[i] !== void 0 && !qdoc.present.has(`q${i}`)) {
+      inserts.push(`  quadrant-${i + 1} ${doc.quadrantLabels[i]}`);
+    }
+  }
+  if (inserts.length > 0 && singletonAnchor >= 0) out.splice(singletonAnchor + 1, 0, ...inserts);
+  const additions = [];
+  for (const p of doc.points) {
+    if (!emitted.has(p.id) && !p.raw) additions.push(`  ${pointLine(p)}`);
+  }
+  return [...out, ...additions].join("\n");
+}
+function clamp01(n) {
+  return Math.max(0, Math.min(1, n));
+}
+function applyOp(doc, op) {
+  const next = structuredClone(doc);
+  const qop = op;
+  const findPoint = (id) => {
+    const p = next.points.find((x) => x.id === id);
+    if (!p) throw new MermaidOpError("That point no longer exists");
+    return p;
+  };
+  switch (qop.type) {
+    case "setTitle": {
+      next.title = qop.title || void 0;
+      next.dirty.title = true;
+      return next;
+    }
+    case "setXAxis": {
+      next.xAxis = qop.text || void 0;
+      next.dirty.xAxis = true;
+      return next;
+    }
+    case "setYAxis": {
+      next.yAxis = qop.text || void 0;
+      next.dirty.yAxis = true;
+      return next;
+    }
+    case "setQuadrantLabel": {
+      if (qop.index < 0 || qop.index > 3) throw new MermaidOpError("Quadrant index out of range");
+      next.quadrantLabels[qop.index] = qop.text || void 0;
+      next.dirty[`q${qop.index}`] = true;
+      return next;
+    }
+    case "addPoint": {
+      next.points.push({
+        id: `q_a${next.points.length + 1}`,
+        label: qop.label,
+        x: clamp01(qop.x ?? 0.5),
+        y: clamp01(qop.y ?? 0.5)
+      });
+      return next;
+    }
+    case "editPoint": {
+      const p = findPoint(qop.id);
+      if (qop.label !== void 0) p.label = qop.label;
+      if (qop.x !== void 0) p.x = clamp01(qop.x);
+      if (qop.y !== void 0) p.y = clamp01(qop.y);
+      p.dirty = true;
+      return next;
+    }
+    case "deletePoint": {
+      findPoint(qop.id);
+      next.points = next.points.filter((p) => p.id !== qop.id);
+      return next;
+    }
+    default:
+      throw new MermaidOpError("Unsupported operation for quadrant charts");
+  }
+}
+const quadrantAdapter = {
+  diagramType: "quadrant",
+  parse,
+  serialize,
+  applyOp,
+  vocabulary: { node: "Point", addNode: "Add point" }
+};
+export {
+  quadrantAdapter
+};

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

@@ -0,0 +1,7 @@
+/**
+ * Adapter registration — import this module once (the workbench does) to make
+ * all structural-editing adapters available via getAdapter()/getAdapterForType().
+ * Import from source per house rule; this is a registration side-effect module,
+ * not a barrel re-export.
+ */
+export {};

package/dist/mermaid/adapters/register.js

@@ -0,0 +1,19 @@
+import { registerAdapter } from "../model/adapter.js";
+import { erAdapter } from "./er.js";
+import { flowchartAdapter } from "./flowchart.js";
+import { journeyAdapter } from "./journey.js";
+import { mindmapAdapter } from "./mindmap.js";
+import { pieAdapter } from "./pie.js";
+import { quadrantAdapter } from "./quadrant.js";
+import { sequenceAdapter } from "./sequence.js";
+import { stateAdapter } from "./state.js";
+import { timelineAdapter } from "./timeline.js";
+registerAdapter(flowchartAdapter);
+registerAdapter(mindmapAdapter);
+registerAdapter(sequenceAdapter);
+registerAdapter(pieAdapter);
+registerAdapter(timelineAdapter);
+registerAdapter(journeyAdapter);
+registerAdapter(quadrantAdapter);
+registerAdapter(stateAdapter);
+registerAdapter(erAdapter);

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

@@ -0,0 +1,8 @@
+/**
+ * Sequence adapter. Messages and participants edit per-line; blocks (loop,
+ * alt, notes, activations) are locked passthrough rows preserved verbatim.
+ * Reorders and inserts regenerate the body wholesale (content-preserving).
+ */
+import type { MermaidAdapter } from "../model/adapter.js";
+import type { SequenceDoc } from "../model/types.js";
+export declare const sequenceAdapter: MermaidAdapter<SequenceDoc>;

package/dist/mermaid/adapters/sequence.js

@@ -0,0 +1,251 @@
+import { splitFrontmatter } from "../diagram-type.js";
+import { MermaidOpError } from "../model/ops.js";
+const ARROWS = ["-->>", "->>", "--x", "-x", "--)", "-)", "-->", "->"];
+const MESSAGE_RE = new RegExp(
+  `^([A-Za-z0-9_]+)\\s*(${ARROWS.map((a) => a.replace(/[-)>(x]/g, (c) => `\\${c}`)).join("|")})\\s*([A-Za-z0-9_]+)\\s*:\\s*(.*)$`
+);
+const PARTICIPANT_RE = /^(participant|actor)\s+([A-Za-z0-9_]+)(?:\s+as\s+(.+))?$/;
+const BLOCK_RE = /^(note\b|loop\b|alt\b|else\b|opt\b|par\b|and\b|critical\b|option\b|break\b|rect\b|end\s*$|activate\b|deactivate\b|box\b|create\b|destroy\b|link\b|links\b|properties\b|title\b|autonumber\s+\S)/i;
+function parse(source) {
+  const { bodyStartIndex, lines } = splitFrontmatter(source);
+  const doc = {
+    kind: "sequence",
+    diagramType: "sequence",
+    frontmatter: lines.slice(0, bodyStartIndex),
+    sourceLines: [],
+    warnings: [],
+    autonumber: false,
+    participants: [],
+    items: []
+  };
+  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 (!/^sequenceDiagram\s*$/.test(trimmed)) {
+        return { status: "code-only", reason: "unrecognized sequence header", diagnostics: [] };
+      }
+      headerSeen = true;
+      doc.sourceLines.push({ text: rawLine, ref: { entity: "header", id: "header" } });
+      continue;
+    }
+    if (/^autonumber\s*$/.test(trimmed)) {
+      doc.autonumber = true;
+      doc.sourceLines.push({ text: rawLine, ref: { entity: "autonumber", id: "autonumber" } });
+      continue;
+    }
+    const participant = PARTICIPANT_RE.exec(trimmed);
+    if (participant) {
+      const p = {
+        id: participant[2],
+        alias: participant[3]?.trim(),
+        isActor: participant[1] === "actor",
+        raw: rawLine
+      };
+      doc.participants.push(p);
+      doc.sourceLines.push({ text: rawLine, ref: { entity: "participant", id: p.id } });
+      continue;
+    }
+    const message = MESSAGE_RE.exec(trimmed);
+    if (message && !/[+-]\s*:/.test(trimmed.split(":")[0] + ":")) {
+      const item = {
+        kind: "message",
+        id: `s${++counter}`,
+        from: message[1],
+        to: message[3],
+        text: message[4],
+        arrow: message[2],
+        raw: rawLine
+      };
+      doc.items.push(item);
+      doc.sourceLines.push({ text: rawLine, ref: { entity: "item", id: item.id } });
+      continue;
+    }
+    if (BLOCK_RE.test(trimmed) || message) {
+      const item = { kind: "passthrough", id: `s${++counter}`, raw: rawLine };
+      doc.items.push(item);
+      doc.sourceLines.push({ text: rawLine, ref: { entity: "item", id: item.id } });
+      continue;
+    }
+    return {
+      status: "code-only",
+      reason: `unrecognized statement: "${trimmed.slice(0, 40)}"`,
+      diagnostics: []
+    };
+  }
+  if (!headerSeen) {
+    return { status: "invalid", diagnostics: [{ line: 1, message: "missing sequenceDiagram header", severity: "error" }] };
+  }
+  return { status: "ok", doc };
+}
+function participantLine(p) {
+  const kind = p.isActor ? "actor" : "participant";
+  return p.alias ? `${kind} ${p.id} as ${p.alias}` : `${kind} ${p.id}`;
+}
+function messageLine(item) {
+  return `${item.from}${item.arrow}${item.to}: ${item.text}`;
+}
+function serialize(doc) {
+  const sdoc = doc;
+  const out = [...doc.frontmatter];
+  if (sdoc.regenerateAll) {
+    const comments = doc.sourceLines.filter((l) => !l.ref && l.text.trim().startsWith("%%")).map((l) => l.text);
+    out.push("sequenceDiagram", ...comments);
+    if (doc.autonumber) out.push("  autonumber");
+    for (const p of doc.participants) out.push(`  ${participantLine(p)}`);
+    for (const item of doc.items) {
+      if (item.kind === "passthrough") out.push(item.raw);
+      else out.push(`  ${messageLine(item)}`);
+    }
+    return out.join("\n");
+  }
+  const participantById = new Map(doc.participants.map((p) => [p.id, p]));
+  const itemById = new Map(doc.items.map((i) => [i.id, i]));
+  const emittedParticipants = /* @__PURE__ */ new Set();
+  const emittedItems = /* @__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 "autonumber":
+        if (doc.autonumber) out.push(line.text);
+        break;
+      case "participant": {
+        const p = participantById.get(line.ref.id);
+        if (!p) break;
+        emittedParticipants.add(p.id);
+        out.push(p.dirty ? `${indent}${participantLine(p)}` : line.text);
+        break;
+      }
+      case "item": {
+        const item = itemById.get(line.ref.id);
+        if (!item) break;
+        emittedItems.add(item.id);
+        if (item.kind === "passthrough" || !item.dirty) out.push(line.text);
+        else out.push(`${indent}${messageLine(item)}`);
+        break;
+      }
+      default:
+        out.push(line.text);
+    }
+  }
+  const additions = [];
+  if (doc.autonumber && !doc.sourceLines.some((l) => l.ref?.entity === "autonumber")) {
+    additions.push("  autonumber");
+  }
+  for (const p of doc.participants) {
+    if (!emittedParticipants.has(p.id) && !p.raw) additions.push(`  ${participantLine(p)}`);
+  }
+  for (const item of doc.items) {
+    if (item.kind === "message" && !emittedItems.has(item.id) && !item.raw) {
+      additions.push(`  ${messageLine(item)}`);
+    }
+  }
+  return [...out, ...additions].join("\n");
+}
+function applyOp(doc, op) {
+  const next = structuredClone(doc);
+  const sop = op;
+  const participant = (id) => {
+    const p = next.participants.find((x) => x.id === id);
+    if (!p) throw new MermaidOpError("That participant no longer exists");
+    return p;
+  };
+  const message = (id) => {
+    const m = next.items.find((x) => x.id === id);
+    if (!m || m.kind !== "message") throw new MermaidOpError("That message no longer exists");
+    return m;
+  };
+  switch (sop.type) {
+    case "addParticipant": {
+      const base = sop.label.replace(/[^A-Za-z0-9_]/g, "") || "P";
+      let id = base;
+      let n = 1;
+      while (next.participants.some((p) => p.id === id)) id = `${base}${++n}`;
+      next.participants.push({
+        id,
+        alias: sop.label === id ? void 0 : sop.label,
+        isActor: Boolean(sop.isActor)
+      });
+      return next;
+    }
+    case "renameParticipant": {
+      const p = participant(sop.id);
+      p.alias = sop.label === p.id ? void 0 : sop.label;
+      p.dirty = true;
+      return next;
+    }
+    case "deleteParticipant": {
+      participant(sop.id);
+      const used = next.items.some(
+        (i) => i.kind === "message" && (i.from === sop.id || i.to === sop.id)
+      );
+      if (used) {
+        throw new MermaidOpError("Remove this participant's messages first");
+      }
+      next.participants = next.participants.filter((p) => p.id !== sop.id);
+      next.regenerateAll = true;
+      return next;
+    }
+    case "addMessage": {
+      participant(sop.from);
+      participant(sop.to);
+      next.items.push({
+        kind: "message",
+        id: `s_a${next.items.length + 1}`,
+        from: sop.from,
+        to: sop.to,
+        text: sop.text,
+        arrow: sop.arrow ?? "->>"
+      });
+      return next;
+    }
+    case "editMessage": {
+      const m = message(sop.id);
+      if (sop.from) m.from = sop.from;
+      if (sop.to) m.to = sop.to;
+      if (sop.text !== void 0) m.text = sop.text;
+      if (sop.arrow) m.arrow = sop.arrow;
+      m.dirty = true;
+      return next;
+    }
+    case "deleteMessage": {
+      message(sop.id);
+      next.items = next.items.filter((i) => i.id !== sop.id);
+      return next;
+    }
+    case "moveMessage": {
+      const idx = next.items.findIndex((i) => i.id === sop.id);
+      if (idx === -1) throw new MermaidOpError("That message no longer exists");
+      const target = sop.direction === "up" ? idx - 1 : idx + 1;
+      if (target < 0 || target >= next.items.length) return next;
+      [next.items[idx], next.items[target]] = [next.items[target], next.items[idx]];
+      next.regenerateAll = true;
+      return next;
+    }
+    case "setAutonumber": {
+      next.autonumber = sop.enabled;
+      return next;
+    }
+    default:
+      throw new MermaidOpError("Unsupported operation for sequence diagrams");
+  }
+}
+const sequenceAdapter = {
+  diagramType: "sequence",
+  parse,
+  serialize,
+  applyOp,
+  vocabulary: { node: "Participant", addNode: "Add participant", edge: "Message" }
+};
+export {
+  sequenceAdapter
+};

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

@@ -0,0 +1,12 @@
+/**
+ * State diagram adapter (flat stateDiagram / stateDiagram-v2).
+ *
+ * Supports transitions (`A --> B : label`) and state descriptions
+ * (`A : desc` or `state "desc" as A`). Composite states (`{ … }`), notes,
+ * concurrency (`--`), and fork/choice/join (`<<…>>`) are NOT structurally
+ * editable — like flowchart's nested-subgraph rule, those downgrade the whole
+ * document to code-only rather than risk guessing.
+ */
+import type { MermaidAdapter } from "../model/adapter.js";
+import type { StateDoc } from "../model/types.js";
+export declare const stateAdapter: MermaidAdapter<StateDoc>;