@ai-matrx/rich-content 0.2.4 → 0.2.7

package/dist/mermaid/adapters/journey.js

@@ -0,0 +1,207 @@
+import { splitFrontmatter } from "../diagram-type.js";
+import { MermaidOpError } from "../model/ops.js";
+const TASK_RE = /^(.+?)\s*:\s*([0-9]+(?:\.[0-9]+)?)\s*(?::\s*(.*))?$/;
+function parse(source) {
+  const { bodyStartIndex, lines } = splitFrontmatter(source);
+  const doc = {
+    kind: "journey",
+    diagramType: "journey",
+    frontmatter: lines.slice(0, bodyStartIndex),
+    sourceLines: [],
+    warnings: [],
+    sections: []
+  };
+  let headerSeen = false;
+  let counter = 0;
+  let sectionCounter = 0;
+  let currentSection = null;
+  const implicitSection = () => {
+    if (!currentSection) {
+      currentSection = { id: `sec${++sectionCounter}`, tasks: [] };
+      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 (!/^journey\s*$/.test(trimmed)) {
+        return { status: "code-only", reason: "unrecognized journey 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(), tasks: [], raw: rawLine };
+      doc.sections.push(currentSection);
+      doc.sourceLines.push({ text: rawLine, ref: { entity: "section", id: currentSection.id } });
+      continue;
+    }
+    const task = TASK_RE.exec(trimmed);
+    if (task) {
+      const actors = (task[3] ?? "").split(",").map((a) => a.trim()).filter(Boolean);
+      const t = {
+        id: `j${++counter}`,
+        name: task[1].trim(),
+        score: Number(task[2]),
+        actors,
+        raw: rawLine
+      };
+      implicitSection().tasks.push(t);
+      doc.sourceLines.push({ text: rawLine, ref: { entity: "task", id: t.id } });
+      continue;
+    }
+    return {
+      status: "code-only",
+      reason: `unrecognized statement: "${trimmed.slice(0, 40)}"`,
+      diagnostics: []
+    };
+  }
+  if (!headerSeen) {
+    return { status: "invalid", diagnostics: [{ line: 1, message: "missing journey header", severity: "error" }] };
+  }
+  return { status: "ok", doc };
+}
+function taskLine(task) {
+  const actors = task.actors.length > 0 ? `: ${task.actors.join(", ")}` : "";
+  return `${task.name}: ${task.score}${actors}`;
+}
+function serialize(doc) {
+  const jdoc = doc;
+  const out = [...doc.frontmatter];
+  if (jdoc.regenerateAll) {
+    const comments = doc.sourceLines.filter((l) => !l.ref && l.text.trim().startsWith("%%")).map((l) => l.text);
+    out.push("journey", ...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 task of section.tasks) out.push(`    ${taskLine(task)}`);
+    }
+    return out.join("\n");
+  }
+  const taskById = /* @__PURE__ */ new Map();
+  const sectionById = /* @__PURE__ */ new Map();
+  for (const section of doc.sections) {
+    sectionById.set(section.id, section);
+    for (const task of section.tasks) taskById.set(task.id, task);
+  }
+  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(jdoc.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 "task": {
+        const task = taskById.get(line.ref.id);
+        if (!task) break;
+        out.push(task.dirty ? `${indent}${taskLine(task)}` : line.text);
+        break;
+      }
+      default:
+        out.push(line.text);
+    }
+  }
+  return out.join("\n");
+}
+function applyOp(doc, op) {
+  const next = structuredClone(doc);
+  const jop = op;
+  const findTask = (id) => {
+    for (const section of next.sections) {
+      const task = section.tasks.find((t) => t.id === id);
+      if (task) return task;
+    }
+    throw new MermaidOpError("That task 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 (jop.type) {
+    case "setTitle": {
+      next.title = jop.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: jop.title, tasks: [] });
+      next.regenerateAll = true;
+      return next;
+    }
+    case "renameSection": {
+      const s = findSection(jop.id);
+      s.title = jop.title;
+      s.dirty = true;
+      return next;
+    }
+    case "deleteSection": {
+      findSection(jop.id);
+      next.sections = next.sections.filter((s) => s.id !== jop.id);
+      next.regenerateAll = true;
+      return next;
+    }
+    case "addTask": {
+      const s = findSection(jop.sectionId);
+      s.tasks.push({
+        id: `j_a${s.tasks.length + 1}`,
+        name: jop.name,
+        score: jop.score ?? 3,
+        actors: jop.actors ?? []
+      });
+      next.regenerateAll = true;
+      return next;
+    }
+    case "editTask": {
+      const task = findTask(jop.id);
+      if (jop.name !== void 0) task.name = jop.name;
+      if (jop.score !== void 0) task.score = jop.score;
+      if (jop.actors !== void 0) task.actors = jop.actors;
+      task.dirty = true;
+      return next;
+    }
+    case "deleteTask": {
+      findTask(jop.id);
+      for (const section of next.sections) {
+        section.tasks = section.tasks.filter((t) => t.id !== jop.id);
+      }
+      return next;
+    }
+    default:
+      throw new MermaidOpError("Unsupported operation for journeys");
+  }
+}
+const journeyAdapter = {
+  diagramType: "journey",
+  parse,
+  serialize,
+  applyOp,
+  vocabulary: { node: "Task", addNode: "Add task" }
+};
+export {
+  journeyAdapter
+};

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

@@ -0,0 +1,12 @@
+/**
+ * Mindmap adapter — indentation-tree parse / serialize / ops.
+ *
+ * Label edits regenerate single lines in place. Structural ops (add / delete /
+ * indent / outdent / move) regenerate the whole tree body with normalized
+ * 2-space indentation — content-preserving (labels, shapes, ::icon decorators
+ * and comments are all re-emitted), formatting-normalizing, and only ever
+ * after the fidelity gate has passed on the untouched document.
+ */
+import type { MermaidAdapter } from "../model/adapter.js";
+import type { MindmapDoc } from "../model/types.js";
+export declare const mindmapAdapter: MermaidAdapter<MindmapDoc>;

package/dist/mermaid/adapters/mindmap.js

@@ -0,0 +1,252 @@
+import { splitFrontmatter } from "../diagram-type.js";
+import { MermaidOpError } from "../model/ops.js";
+const SHAPE_WRAPPERS = [
+  ["bang", "))", "(("],
+  ["circle", "((", "))"],
+  ["cloud", ")", "("],
+  ["hexagon", "{{", "}}"],
+  ["square", "[", "]"],
+  ["rounded", "(", ")"]
+];
+function parseToken(token) {
+  const idMatch = /^([A-Za-z][A-Za-z0-9_-]*)(?=\(|\[|\)|\{)/.exec(token);
+  const declId = idMatch?.[1];
+  const rest = declId ? token.slice(declId.length) : token;
+  for (const [shape, open, close] of SHAPE_WRAPPERS) {
+    if (rest.startsWith(open) && rest.endsWith(close) && rest.length > open.length + close.length - 1) {
+      return { declId, label: rest.slice(open.length, rest.length - close.length).trim(), shape };
+    }
+  }
+  return { label: token.trim(), shape: "default" };
+}
+function wrapToken(node) {
+  const id = node.declId ?? "";
+  for (const [shape, open, close] of SHAPE_WRAPPERS) {
+    if (shape === node.shape) return `${id}${open}${node.label}${close}`;
+  }
+  return node.label;
+}
+function parse(source) {
+  const { bodyStartIndex, lines } = splitFrontmatter(source);
+  const frontmatter = lines.slice(0, bodyStartIndex);
+  const body = lines.slice(bodyStartIndex);
+  const doc = {
+    kind: "mindmap",
+    diagramType: "mindmap",
+    frontmatter,
+    sourceLines: [],
+    warnings: [],
+    root: { id: "m0", label: "", shape: "default", decorators: [], children: [] }
+  };
+  let headerSeen = false;
+  let counter = 0;
+  const stack = [];
+  let rootSet = false;
+  for (let li = 0; li < body.length; li++) {
+    const rawLine = body[li];
+    const trimmed = rawLine.trim();
+    if (!trimmed || trimmed.startsWith("%%")) {
+      doc.sourceLines.push({ text: rawLine });
+      continue;
+    }
+    if (!headerSeen) {
+      if (!/^mindmap\s*$/.test(trimmed)) {
+        return { status: "code-only", reason: "unrecognized mindmap header", diagnostics: [] };
+      }
+      headerSeen = true;
+      doc.sourceLines.push({ text: rawLine, ref: { entity: "header", id: "header" } });
+      continue;
+    }
+    if (trimmed.startsWith("::icon")) {
+      const owner = stack[stack.length - 1];
+      if (!owner) {
+        return { status: "code-only", reason: "icon decorator before any node", diagnostics: [] };
+      }
+      owner.decorators.push(trimmed);
+      doc.sourceLines.push({ text: rawLine, ref: { entity: "decorator", id: owner.id } });
+      continue;
+    }
+    const indent = (/^(\s*)/.exec(rawLine)?.[1] ?? "").length;
+    const token = parseToken(trimmed);
+    const node = {
+      id: `m${++counter}`,
+      label: token.label,
+      shape: token.shape,
+      declId: token.declId,
+      decorators: [],
+      children: [],
+      raw: rawLine,
+      indent
+    };
+    while (stack.length > 0 && (stack[stack.length - 1].indent ?? 0) >= indent) {
+      stack.pop();
+    }
+    if (stack.length === 0) {
+      if (rootSet) {
+        return { status: "code-only", reason: "mindmaps support a single root", diagnostics: [] };
+      }
+      doc.root = node;
+      rootSet = true;
+    } else {
+      stack[stack.length - 1].children.push(node);
+    }
+    stack.push(node);
+    doc.sourceLines.push({ text: rawLine, ref: { entity: "node", id: node.id } });
+  }
+  if (!headerSeen || !rootSet) {
+    return {
+      status: "invalid",
+      diagnostics: [{ line: 1, message: "missing mindmap content", severity: "error" }]
+    };
+  }
+  return { status: "ok", doc };
+}
+function collectNodes(root) {
+  const map = /* @__PURE__ */ new Map();
+  const walk = (n) => {
+    map.set(n.id, n);
+    n.children.forEach((c) => walk(c));
+  };
+  walk(root);
+  return map;
+}
+function findParent(root, id) {
+  let found = null;
+  const walk = (n) => {
+    for (const c of n.children) {
+      if (c.id === id) found = n;
+      walk(c);
+    }
+  };
+  walk(root);
+  return found;
+}
+function serialize(doc) {
+  const out = [...doc.frontmatter];
+  const nodeById = collectNodes(doc.root);
+  if (doc.regenerateAll) {
+    const comments = doc.sourceLines.filter((l) => !l.ref && l.text.trim().startsWith("%%")).map((l) => l.text);
+    const headerLine = doc.sourceLines.find((l) => l.ref?.entity === "header")?.text ?? "mindmap";
+    out.push(headerLine, ...comments);
+    const emit = (node, depth) => {
+      const indent = "  ".repeat(depth + 1);
+      out.push(`${indent}${wrapToken(node)}`);
+      for (const d of node.decorators) out.push(`${indent}${d}`);
+      node.children.forEach((c) => emit(c, depth + 1));
+    };
+    emit(doc.root, 0);
+    return out.join("\n");
+  }
+  for (const line of doc.sourceLines) {
+    if (!line.ref) {
+      out.push(line.text);
+      continue;
+    }
+    if (line.ref.entity === "node") {
+      const node = nodeById.get(line.ref.id);
+      if (!node) continue;
+      const indent = /^(\s*)/.exec(line.text)?.[1] ?? "";
+      out.push(node.dirty ? `${indent}${wrapToken(node)}` : line.text);
+      continue;
+    }
+    out.push(line.text);
+  }
+  return out.join("\n");
+}
+function applyOp(doc, op) {
+  const next = structuredClone(doc);
+  const mop = op;
+  const root = next.root;
+  const nodeById = collectNodes(root);
+  const get = (id) => {
+    const n = nodeById.get(id);
+    if (!n) throw new MermaidOpError("That topic no longer exists");
+    return n;
+  };
+  let counter = nodeById.size;
+  switch (mop.type) {
+    case "renameNode": {
+      const n = get(mop.id);
+      n.label = mop.label;
+      n.dirty = true;
+      return next;
+    }
+    case "setShape": {
+      const n = get(mop.id);
+      n.shape = mop.shape;
+      n.dirty = true;
+      return next;
+    }
+    case "addChild": {
+      const parent = get(mop.parentId);
+      parent.children.push({
+        id: `m_a${++counter}`,
+        label: mop.label,
+        shape: "default",
+        decorators: [],
+        children: []
+      });
+      next.regenerateAll = true;
+      return next;
+    }
+    case "deleteNode": {
+      if (mop.id === root.id) throw new MermaidOpError("The central idea can't be deleted");
+      const parent = findParent(root, mop.id);
+      if (!parent) throw new MermaidOpError("That topic no longer exists");
+      parent.children = parent.children.filter((c) => c.id !== mop.id);
+      next.regenerateAll = true;
+      return next;
+    }
+    case "indent": {
+      const parent = findParent(root, mop.id);
+      if (!parent) throw new MermaidOpError("That topic no longer exists");
+      const idx = parent.children.findIndex((c) => c.id === mop.id);
+      if (idx <= 0) throw new MermaidOpError("Nothing above to nest under");
+      const node = parent.children[idx];
+      parent.children.splice(idx, 1);
+      parent.children[idx - 1].children.push(node);
+      next.regenerateAll = true;
+      return next;
+    }
+    case "outdent": {
+      const parent = findParent(root, mop.id);
+      if (!parent) throw new MermaidOpError("That topic no longer exists");
+      if (parent.id === root.id) throw new MermaidOpError("Already at the top level");
+      const grandparent = findParent(root, parent.id);
+      if (!grandparent) throw new MermaidOpError("Already at the top level");
+      const idx = parent.children.findIndex((c) => c.id === mop.id);
+      const node = parent.children[idx];
+      parent.children.splice(idx, 1);
+      const parentIdx = grandparent.children.findIndex((c) => c.id === parent.id);
+      grandparent.children.splice(parentIdx + 1, 0, node);
+      next.regenerateAll = true;
+      return next;
+    }
+    case "moveBefore": {
+      const parent = findParent(root, mop.id);
+      const siblingParent = findParent(root, mop.siblingId);
+      if (!parent || !siblingParent || parent.id !== siblingParent.id) {
+        throw new MermaidOpError("Topics can only be reordered among siblings");
+      }
+      const node = parent.children.find((c) => c.id === mop.id);
+      if (!node) throw new MermaidOpError("That topic no longer exists");
+      parent.children = parent.children.filter((c) => c.id !== mop.id);
+      const target = parent.children.findIndex((c) => c.id === mop.siblingId);
+      parent.children.splice(target, 0, node);
+      next.regenerateAll = true;
+      return next;
+    }
+    default:
+      throw new MermaidOpError("Unsupported operation for mind maps");
+  }
+}
+const mindmapAdapter = {
+  diagramType: "mindmap",
+  parse,
+  serialize,
+  applyOp,
+  vocabulary: { node: "Topic", addNode: "Add topic" }
+};
+export {
+  mindmapAdapter
+};

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

@@ -0,0 +1,7 @@
+/**
+ * Pie adapter — the simplest grammar: header (+showData/title), title line,
+ * `"label" : value` slices. All edits are per-line; new slices append.
+ */
+import type { MermaidAdapter } from "../model/adapter.js";
+import type { PieDoc } from "../model/types.js";
+export declare const pieAdapter: MermaidAdapter<PieDoc>;

package/dist/mermaid/adapters/pie.js

@@ -0,0 +1,172 @@
+import { splitFrontmatter } from "../diagram-type.js";
+import { MermaidOpError } from "../model/ops.js";
+const HEADER_RE = /^pie(\s+showData)?(?:\s+title\s+(.+))?\s*$/;
+const TITLE_RE = /^title\s+(.+)$/;
+const SLICE_RE = /^"([^"]*)"\s*:\s*([0-9]+(?:\.[0-9]+)?)\s*$/;
+const SLICE_UNQUOTED_RE = /^([^:"]+?)\s*:\s*([0-9]+(?:\.[0-9]+)?)\s*$/;
+function parse(source) {
+  const { bodyStartIndex, lines } = splitFrontmatter(source);
+  const doc = {
+    kind: "pie",
+    diagramType: "pie",
+    frontmatter: lines.slice(0, bodyStartIndex),
+    sourceLines: [],
+    warnings: [],
+    showData: false,
+    slices: []
+  };
+  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) {
+      const header = HEADER_RE.exec(trimmed);
+      if (!header) return { status: "code-only", reason: "unrecognized pie header", diagnostics: [] };
+      headerSeen = true;
+      doc.showData = Boolean(header[1]);
+      if (header[2]) {
+        doc.title = header[2].trim().replace(/^"|"$/g, "");
+        doc.headerTitle = 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().replace(/^"|"$/g, "");
+      doc.sourceLines.push({ text: rawLine, ref: { entity: "title", id: "title" } });
+      continue;
+    }
+    const slice = SLICE_RE.exec(trimmed) ?? SLICE_UNQUOTED_RE.exec(trimmed);
+    if (slice) {
+      const s = {
+        id: `p${++counter}`,
+        label: slice[1].trim(),
+        value: Number(slice[2]),
+        raw: rawLine
+      };
+      doc.slices.push(s);
+      doc.sourceLines.push({ text: rawLine, ref: { entity: "slice", id: s.id } });
+      continue;
+    }
+    return {
+      status: "code-only",
+      reason: `unrecognized statement: "${trimmed.slice(0, 40)}"`,
+      diagnostics: []
+    };
+  }
+  if (!headerSeen) {
+    return { status: "invalid", diagnostics: [{ line: 1, message: "missing pie header", severity: "error" }] };
+  }
+  return { status: "ok", doc };
+}
+function sliceLine(slice) {
+  return `"${slice.label.replace(/"/g, "'")}" : ${slice.value}`;
+}
+function headerLine(doc) {
+  const parts = ["pie"];
+  if (doc.showData) parts.push("showData");
+  if (doc.headerTitle && doc.title) parts.push(`title ${doc.title}`);
+  return parts.join(" ");
+}
+function serialize(doc) {
+  const pdoc = doc;
+  const out = [...doc.frontmatter];
+  const sliceById = new Map(doc.slices.map((s) => [s.id, s]));
+  const emitted = /* @__PURE__ */ new Set();
+  let headerEmitted = false;
+  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":
+        headerEmitted = true;
+        out.push(pdoc.dirtyHeader ? `${indent}${headerLine(pdoc)}` : line.text);
+        break;
+      case "title":
+        if (pdoc.title === void 0) break;
+        out.push(pdoc.dirtyTitle ? `${indent}title ${pdoc.title}` : line.text);
+        break;
+      case "slice": {
+        const slice = sliceById.get(line.ref.id);
+        if (!slice) break;
+        emitted.add(slice.id);
+        out.push(slice.dirty ? `${indent}${sliceLine(slice)}` : line.text);
+        break;
+      }
+      default:
+        out.push(line.text);
+    }
+  }
+  const additions = [];
+  if (pdoc.title !== void 0 && !pdoc.headerTitle && !doc.sourceLines.some((l) => l.ref?.entity === "title")) {
+    const headerIndex = out.findIndex((l) => /^\s*pie\b/.test(l));
+    if (headerIndex >= 0) out.splice(headerIndex + 1, 0, `  title ${pdoc.title}`);
+  }
+  for (const slice of doc.slices) {
+    if (!emitted.has(slice.id) && !slice.raw) additions.push(`  ${sliceLine(slice)}`);
+  }
+  void headerEmitted;
+  return [...out, ...additions].join("\n");
+}
+function applyOp(doc, op) {
+  const next = structuredClone(doc);
+  const pop = op;
+  const slice = (id) => {
+    const s = next.slices.find((x) => x.id === id);
+    if (!s) throw new MermaidOpError("That slice no longer exists");
+    return s;
+  };
+  switch (pop.type) {
+    case "setTitle": {
+      next.title = pop.title || void 0;
+      if (next.headerTitle) next.dirtyHeader = true;
+      else next.dirtyTitle = true;
+      return next;
+    }
+    case "setShowData": {
+      next.showData = pop.enabled;
+      next.dirtyHeader = true;
+      return next;
+    }
+    case "addSlice": {
+      next.slices.push({
+        id: `p_a${next.slices.length + 1}`,
+        label: pop.label,
+        value: pop.value
+      });
+      return next;
+    }
+    case "editSlice": {
+      const s = slice(pop.id);
+      if (pop.label !== void 0) s.label = pop.label;
+      if (pop.value !== void 0) s.value = pop.value;
+      s.dirty = true;
+      return next;
+    }
+    case "deleteSlice": {
+      slice(pop.id);
+      next.slices = next.slices.filter((s) => s.id !== pop.id);
+      return next;
+    }
+    default:
+      throw new MermaidOpError("Unsupported operation for pie charts");
+  }
+}
+const pieAdapter = {
+  diagramType: "pie",
+  parse,
+  serialize,
+  applyOp,
+  vocabulary: { node: "Slice", addNode: "Add slice" }
+};
+export {
+  pieAdapter
+};

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

@@ -0,0 +1,8 @@
+/**
+ * Quadrant chart adapter. Singletons (title, x-axis, y-axis, quadrant-1..4) and
+ * points (`Label: [x, y]`). Edits are per-line; a singleton set for the first
+ * time is inserted after the header; points append. Lossless by construction.
+ */
+import type { MermaidAdapter } from "../model/adapter.js";
+import type { QuadrantDoc } from "../model/types.js";
+export declare const quadrantAdapter: MermaidAdapter<QuadrantDoc>;