@ai-matrx/rich-editor 0.0.0 → 0.1.1

package/dist/core/markdown-format.js

@@ -0,0 +1,354 @@
+const FORMAT_COMMAND_IDS = [
+  "bold",
+  "italic",
+  "strike",
+  "code",
+  "link",
+  "heading1",
+  "heading2",
+  "heading3",
+  "bulletList",
+  "orderedList",
+  "taskList",
+  "quote",
+  "codeBlock"
+];
+function isFormatCommandId(id) {
+  return FORMAT_COMMAND_IDS.includes(id);
+}
+const INLINE = {
+  bold: { marker: "**", chars: ["*", "_"], runs: [2, 3], size: 2 },
+  italic: { marker: "*", chars: ["*", "_"], runs: [1, 3], size: 1 },
+  strike: { marker: "~~", chars: ["~"], runs: [2], size: 2 },
+  code: { marker: "`", chars: ["`"], runs: [1], size: 1 }
+};
+const LINE_PREFIX = /^( {0,3})(#{1,6}[ \t]+|[-*+][ \t]+\[[ xX]\][ \t]+|[-*+][ \t]+|\d{1,9}[.)][ \t]+|>[ \t]?)?/;
+function linesTouched(text, from, to) {
+  const start = text.lastIndexOf("\n", from - 1) + 1;
+  const effectiveTo = to > from && text[to - 1] === "\n" ? to - 1 : to;
+  const endBreak = text.indexOf("\n", effectiveTo);
+  const end = endBreak === -1 ? text.length : endBreak;
+  const out = [];
+  let offset = start;
+  for (const line of text.slice(start, end).split("\n")) {
+    out.push({ start: offset, end: offset + line.length, text: line });
+    offset += line.length + 1;
+  }
+  return out;
+}
+function runLength(text, pos, dir, ch) {
+  let n = 0;
+  let i = dir === -1 ? pos - 1 : pos;
+  while (i >= 0 && i < text.length && text[i] === ch) {
+    n += 1;
+    i += dir;
+  }
+  return n;
+}
+const WORD = /[\p{L}\p{N}_'-]/u;
+function wordAt(text, pos) {
+  let from = pos;
+  let to = pos;
+  while (from > 0 && WORD.test(text[from - 1] ?? "")) from -= 1;
+  while (to < text.length && WORD.test(text[to] ?? "")) to += 1;
+  return to > from ? { from, to } : null;
+}
+function inlineSegments(text, from, to) {
+  const out = [];
+  for (const line of linesTouched(text, from, to)) {
+    const prefix = LINE_PREFIX.exec(line.text)?.[0].length ?? 0;
+    let s = Math.max(from, line.start + (from <= line.start + prefix ? prefix : 0));
+    let e = Math.min(to, line.end);
+    while (s < e && /\s/.test(text[s] ?? "")) s += 1;
+    while (e > s && /\s/.test(text[e - 1] ?? "")) e -= 1;
+    if (e > s) out.push({ from: s, to: e });
+  }
+  return out;
+}
+function wrapOf(text, seg, spec) {
+  for (const ch of spec.chars) {
+    const lead = runLength(text, seg.from, 1, ch);
+    const trail = runLength(text, seg.to, -1, ch);
+    const innerFrom = seg.from + lead;
+    const innerTo = seg.to - trail;
+    if (innerTo <= innerFrom) continue;
+    const before = runLength(text, seg.from, -1, ch) + lead;
+    const after = trail + runLength(text, seg.to, 1, ch);
+    if (spec.runs.includes(before) && spec.runs.includes(after)) return { innerFrom, innerTo };
+  }
+  return null;
+}
+function mapPos(pos, changes, assoc) {
+  let delta = 0;
+  for (const c of changes) {
+    if (c.to < pos || c.to === pos && (c.from < pos || assoc === 1)) {
+      if (c.from >= pos && assoc === -1) continue;
+      delta += c.insert.length - (c.to - c.from);
+    } else if (c.from < pos && pos < c.to) {
+      return c.from + delta + (assoc === 1 ? c.insert.length : 0);
+    }
+  }
+  return pos + delta;
+}
+function sorted(changes) {
+  return [...changes].sort((a, b) => a.from - b.from || a.to - b.to);
+}
+function inlineCommand(text, from, to, spec) {
+  if (from === to) {
+    const word = wordAt(text, from);
+    if (!word) {
+      const insert = `${spec.marker}${spec.marker}`;
+      const caret = from + spec.marker.length;
+      return { changes: [{ from, to, insert }], anchor: caret, head: caret };
+    }
+    const result = inlineCommand(text, word.from, word.to, spec);
+    const shifted = mapPos(from, sorted(result.changes), 1);
+    return { ...result, anchor: shifted, head: shifted };
+  }
+  const segments = inlineSegments(text, from, to);
+  if (segments.length === 0) return { changes: [], anchor: from, head: to };
+  const wraps = segments.map((seg) => wrapOf(text, seg, spec));
+  const allOn = wraps.every((w) => w !== null);
+  const changes = [];
+  segments.forEach((seg, i) => {
+    const w = wraps[i];
+    if (allOn && w) {
+      changes.push({ from: w.innerFrom - spec.size, to: w.innerFrom, insert: "" });
+      changes.push({ from: w.innerTo, to: w.innerTo + spec.size, insert: "" });
+    } else if (!w) {
+      changes.push({ from: seg.from, to: seg.from, insert: spec.marker });
+      changes.push({ from: seg.to, to: seg.to, insert: spec.marker });
+    }
+  });
+  const ordered = sorted(changes);
+  const startAt = allOn ? wraps[0].innerFrom : segments[0].from;
+  const endAt = allOn ? wraps[wraps.length - 1].innerTo : segments[segments.length - 1].to;
+  const anchor = mapPos(startAt, ordered, 1);
+  const head = mapPos(endAt, ordered, -1);
+  return { changes: ordered, anchor, head: Math.max(anchor, head) };
+}
+const WHOLE_LINK = /^\[([^\]\n]*)\]\(([^)\n]*)\)$/;
+const URLISH = /^(https?:\/\/|mailto:|www\.)\S+$/i;
+function linkCommand(text, from, to) {
+  const selected = text.slice(from, to);
+  const whole = WHOLE_LINK.exec(selected);
+  if (whole) {
+    const label2 = whole[1] ?? "";
+    return { changes: [{ from, to, insert: label2 }], anchor: from, head: from + label2.length };
+  }
+  if (text[from - 1] === "[" && text.slice(to, to + 2) === "](") {
+    const close = text.indexOf(")", to + 2);
+    const nl = text.indexOf("\n", to);
+    if (close !== -1 && (nl === -1 || close < nl)) {
+      return {
+        changes: [
+          { from: from - 1, to: from, insert: "" },
+          { from: to, to: close + 1, insert: "" }
+        ],
+        anchor: from - 1,
+        head: to - 1
+      };
+    }
+  }
+  if (URLISH.test(selected)) {
+    const insert2 = `[](${selected})`;
+    return { changes: [{ from, to, insert: insert2 }], anchor: from + 1, head: from + 1 };
+  }
+  const label = selected || "link";
+  const insert = `[${label}]()`;
+  const urlStart = from + label.length + 3;
+  return { changes: [{ from, to, insert }], anchor: urlStart, head: urlStart };
+}
+const QUOTE_PREFIX = /^ {0,3}(?:>[ \t]?)+/;
+function quoteLength(line) {
+  return QUOTE_PREFIX.exec(line)?.[0].length ?? 0;
+}
+function lineKindOf(line) {
+  const m = LINE_PREFIX.exec(line.slice(quoteLength(line)));
+  const p = m?.[2];
+  if (!p) return null;
+  if (p.startsWith("#")) return { kind: "heading", level: p.trim().length };
+  if (/^[-*+][ \t]+\[[ xX]\]/.test(p)) return { kind: "task" };
+  if (/^[-*+]/.test(p)) return { kind: "bullet" };
+  if (/^\d/.test(p)) return { kind: "ordered" };
+  return null;
+}
+function sameKind(a, b) {
+  if (!a || a.kind !== b.kind) return false;
+  return a.kind !== "heading" || b.kind === "heading" && a.level === b.level;
+}
+function lineCommand(text, from, to, want, prefixOf) {
+  const lines = linesTouched(text, from, to);
+  const content = lines.filter((l) => l.text.trim() !== "");
+  const targets = content.length ? content : lines.slice(0, 1);
+  const allOn = content.length > 0 && content.every((l) => sameKind(lineKindOf(l.text), want));
+  const changes = [];
+  let n = 1;
+  for (const line of targets) {
+    const base = quoteLength(line.text);
+    const m = LINE_PREFIX.exec(line.text.slice(base));
+    const existing = m?.[0] ?? "";
+    const indent = m?.[1] ?? "";
+    const next = allOn ? indent : `${indent}${prefixOf(n++)}`;
+    if (existing !== next) changes.push({ from: line.start + base, to: line.start + base + existing.length, insert: next });
+  }
+  const ordered = sorted(changes);
+  const first = lines[0];
+  const last = lines[lines.length - 1];
+  const anchor = mapPos(Math.max(from, first.start), ordered, 1);
+  const head = from === to ? anchor : mapPos(Math.min(to, last.end), ordered, 1);
+  return { changes: ordered, anchor: Math.min(anchor, head), head: Math.max(anchor, head) };
+}
+function quoteCommand(text, from, to) {
+  const lines = linesTouched(text, from, to);
+  const content = lines.filter((l) => l.text.trim() !== "");
+  const allOn = content.length > 0 && content.every((l) => /^ {0,3}>/.test(l.text));
+  const changes = [];
+  for (const line of lines) {
+    if (allOn) {
+      const m = /^( {0,3})>[ \t]?/.exec(line.text);
+      if (m) changes.push({ from: line.start + m[1].length, to: line.start + m[0].length, insert: "" });
+    } else if (!/^ {0,3}>/.test(line.text)) {
+      changes.push({ from: line.start, to: line.start, insert: line.text.trim() === "" ? ">" : "> " });
+    }
+  }
+  const ordered = sorted(changes);
+  const anchor = mapPos(from, ordered, 1);
+  const head = from === to ? anchor : mapPos(to, ordered, 1);
+  return { changes: ordered, anchor, head };
+}
+const FENCE = /^ {0,3}(`{3,}|~{3,})/;
+function codeBlockCommand(text, from, to) {
+  const lines = linesTouched(text, from, to);
+  const first = lines[0];
+  const last = lines[lines.length - 1];
+  if (lines.length >= 2 && FENCE.test(first.text) && FENCE.test(last.text)) {
+    const changes2 = [
+      { from: first.start, to: Math.min(first.end + 1, text.length), insert: "" },
+      { from: last.start - 1, to: last.end, insert: "" }
+    ];
+    const ordered2 = sorted(changes2);
+    return { changes: ordered2, anchor: first.start, head: mapPos(last.start - 1, ordered2, -1) };
+  }
+  const prevEnd = first.start - 1;
+  const prevStart = prevEnd > 0 ? text.lastIndexOf("\n", prevEnd - 1) + 1 : 0;
+  const prevLine = prevEnd >= 0 ? text.slice(prevStart, prevEnd) : "";
+  const nextStart = last.end + 1;
+  const nextBreak = text.indexOf("\n", nextStart);
+  const nextLine = nextStart <= text.length ? text.slice(nextStart, nextBreak === -1 ? text.length : nextBreak) : "";
+  if (prevEnd >= 0 && FENCE.test(prevLine) && nextStart <= text.length && FENCE.test(nextLine) && nextLine.trim().replace(/[`~]/g, "") === "") {
+    const nextEnd = nextBreak === -1 ? text.length : nextBreak;
+    const changes2 = [
+      { from: prevStart, to: first.start, insert: "" },
+      { from: last.end, to: nextEnd, insert: "" }
+    ];
+    const ordered2 = sorted(changes2);
+    return { changes: ordered2, anchor: mapPos(from, ordered2, 1), head: mapPos(to, ordered2, -1) };
+  }
+  const changes = [
+    { from: first.start, to: first.start, insert: "```\n" },
+    { from: last.end, to: last.end, insert: "\n```" }
+  ];
+  const ordered = sorted(changes);
+  const anchor = mapPos(from, ordered, 1);
+  return { changes: ordered, anchor, head: from === to ? anchor : mapPos(to, ordered, -1) };
+}
+function formatMarkdown(text, from, to, command) {
+  const a = Math.max(0, Math.min(from, to, text.length));
+  const b = Math.min(text.length, Math.max(from, to));
+  switch (command) {
+    case "bold":
+    case "italic":
+    case "strike":
+    case "code":
+      return inlineCommand(text, a, b, INLINE[command]);
+    case "link":
+      return linkCommand(text, a, b);
+    case "heading1":
+    case "heading2":
+    case "heading3": {
+      const level = Number(command.slice(-1));
+      return lineCommand(text, a, b, { kind: "heading", level }, () => `${"#".repeat(level)} `);
+    }
+    case "bulletList":
+      return lineCommand(text, a, b, { kind: "bullet" }, () => "- ");
+    case "orderedList":
+      return lineCommand(text, a, b, { kind: "ordered" }, (n) => `${n}. `);
+    case "taskList":
+      return lineCommand(text, a, b, { kind: "task" }, () => "- [ ] ");
+    case "quote":
+      return quoteCommand(text, a, b);
+    case "codeBlock":
+      return codeBlockCommand(text, a, b);
+  }
+}
+function isFormatActive(text, from, to, command) {
+  const a = Math.max(0, Math.min(from, to, text.length));
+  const b = Math.min(text.length, Math.max(from, to));
+  switch (command) {
+    case "bold":
+    case "italic":
+    case "strike":
+    case "code": {
+      const range = a === b ? wordAt(text, a) : { from: a, to: b };
+      if (!range) return false;
+      const segs = inlineSegments(text, range.from, range.to);
+      return segs.length > 0 && segs.every((s) => wrapOf(text, s, INLINE[command]) !== null);
+    }
+    case "link":
+      return WHOLE_LINK.test(text.slice(a, b)) || text[a - 1] === "[" && text.slice(b, b + 2) === "](";
+    case "quote": {
+      const content = linesTouched(text, a, b).filter((l) => l.text.trim() !== "");
+      return content.length > 0 && content.every((l) => /^ {0,3}>/.test(l.text));
+    }
+    case "codeBlock":
+      return false;
+    default: {
+      const want = command === "bulletList" ? { kind: "bullet" } : command === "orderedList" ? { kind: "ordered" } : command === "taskList" ? { kind: "task" } : { kind: "heading", level: Number(command.slice(-1)) };
+      const content = linesTouched(text, a, b).filter((l) => l.text.trim() !== "");
+      return content.length > 0 && content.every((l) => sameKind(lineKindOf(l.text), want));
+    }
+  }
+}
+const FORMAT_COMMAND_KEYS = {
+  bold: ["Mod-b"],
+  italic: ["Mod-i"],
+  strike: ["Mod-Shift-x", "Mod-Shift-s"],
+  code: ["Mod-e"],
+  link: ["Mod-k"],
+  heading1: ["Mod-Alt-1"],
+  heading2: ["Mod-Alt-2"],
+  heading3: ["Mod-Alt-3"],
+  orderedList: ["Mod-Shift-7"],
+  bulletList: ["Mod-Shift-8"],
+  taskList: ["Mod-Shift-9"],
+  quote: ["Mod-Shift-."],
+  codeBlock: ["Mod-Alt-c"]
+};
+function keyNameOf(event, apple) {
+  const mod = apple ? event.metaKey || event.ctrlKey : event.ctrlKey;
+  if (!mod) return null;
+  let base = null;
+  if (/^Digit\d$/.test(event.code)) base = event.code.slice(5);
+  else if (/^Key[A-Z]$/.test(event.code)) base = event.code.slice(3).toLowerCase();
+  else if (event.code === "Period") base = ".";
+  else if (event.key.length === 1) base = event.key.toLowerCase();
+  if (!base) return null;
+  return ["Mod", event.altKey ? "Alt" : null, event.shiftKey ? "Shift" : null, base].filter(Boolean).join("-");
+}
+function formatCommandForKey(keyName) {
+  if (!keyName) return null;
+  for (const id of FORMAT_COMMAND_IDS) {
+    if (FORMAT_COMMAND_KEYS[id].includes(keyName)) return id;
+  }
+  return null;
+}
+export {
+  FORMAT_COMMAND_IDS,
+  FORMAT_COMMAND_KEYS,
+  formatCommandForKey,
+  formatMarkdown,
+  isFormatActive,
+  isFormatCommandId,
+  keyNameOf
+};

package/dist/core/markdown-parse.d.ts

@@ -0,0 +1,35 @@
+import type { JSONContent } from "@tiptap/core";
+import type { Schema } from "@tiptap/pm/model";
+import type { LinkDefinition, SourceBlock } from "@ai-matrx/content-ir/source";
+import { type Adjacency } from "./markdown-serialize.js";
+export interface ParsedChild {
+    json: JSONContent;
+    /** The source id of the child (its `mdId`). */
+    id: string;
+    /** The child's exact stored bytes (no trailing line breaks). */
+    raw: string;
+    /** The line breaks that followed it inside the block. */
+    trail: string;
+    /** Why the child is held as source, or null when it is rich text. */
+    lockedReason: string | null;
+}
+export interface ParsedProse {
+    children: ParsedChild[];
+    /** Set when the whole block is held as source. */
+    lockedReason: string | null;
+}
+/** Reason string that marks a held-as-source page-break directive line. */
+export declare const PAGE_BREAK_REASON = "page break";
+/**
+ * Parse one prose block. Every top-level construct is either rich text that
+ * serializes back to its exact bytes, or a `sourceLocked` atom holding them.
+ */
+export declare function parseProseBlock(block: SourceBlock, schema: Schema, adjacency: Map<string, Adjacency>, nextId: () => string, 
+/**
+ * The WHOLE document's link reference definitions (THE link-reference rule,
+ * content-ir `collectLinkDefinitions`): each segment is lexed on its own, so
+ * without them `[Apple Support][1]` in a cell could not see `[1]: …` below
+ * the table (verify-RC-B4 round 9, R9-4). The bytes still round-trip — the
+ * link mark keeps its `[1]` tail.
+ */
+linkDefinitions?: ReadonlyMap<string, LinkDefinition>): ParsedProse;