@lalternative/editor 0.1.0

package/dist/chunk-7GOSVZTI.js

@@ -0,0 +1,114 @@
+// src/document.ts
+function blocksFromDoc(doc) {
+  return (doc.content ?? []).map(textOf).filter((text) => text.trim() !== "");
+}
+function shapesFromDoc(doc) {
+  return (doc.content ?? []).filter((node) => textOf(node).trim() !== "").map(
+    (node) => node.type === "heading" ? { type: "heading", level: Number(node.attrs?.level ?? 2) } : { type: "paragraph" }
+  );
+}
+function docFromBlocks(blocks, shapes = []) {
+  const content = [];
+  blocks.forEach((block, i) => {
+    const text = block.trim();
+    if (text === "") return;
+    const shape = shapes[i];
+    if (shape?.type === "heading") {
+      content.push({
+        type: "heading",
+        attrs: { level: shape.level ?? 2 },
+        content: [{ type: "text", text }]
+      });
+      return;
+    }
+    content.push({ type: "paragraph", content: [{ type: "text", text }] });
+  });
+  return { type: "doc", content };
+}
+function textOf(node) {
+  if (typeof node.text === "string") return node.text;
+  return (node.content ?? []).map(textOf).join("");
+}
+
+// src/diff.ts
+var PAIR_THRESHOLD = 0.34;
+function diffBlocks(before, after) {
+  const common = longestCommonSubsequence(before, after);
+  const changes = [];
+  let i = 0;
+  let j = 0;
+  let seq = 0;
+  const id = () => `c${seq++}`;
+  const flush = (removed, added) => {
+    const balanced = removed.length === added.length;
+    const paired = Math.min(removed.length, added.length);
+    let p = 0;
+    for (; p < paired; p++) {
+      if (!balanced && similarity(removed[p], added[p]) < PAIR_THRESHOLD) break;
+      changes.push({ id: id(), kind: "replace", before: removed[p], after: added[p] });
+    }
+    for (let r = p; r < removed.length; r++) {
+      changes.push({ id: id(), kind: "delete", before: removed[r], after: "" });
+    }
+    for (let a = p; a < added.length; a++) {
+      changes.push({ id: id(), kind: "insert", before: "", after: added[a] });
+    }
+  };
+  for (const anchor of common) {
+    const removed = [];
+    const added = [];
+    while (i < before.length && before[i] !== anchor) removed.push(before[i++]);
+    while (j < after.length && after[j] !== anchor) added.push(after[j++]);
+    flush(removed, added);
+    changes.push({ id: id(), kind: "keep", before: anchor, after: anchor });
+    i++;
+    j++;
+  }
+  flush(before.slice(i), after.slice(j));
+  return changes;
+}
+function longestCommonSubsequence(a, b) {
+  const table = Array.from(
+    { length: a.length + 1 },
+    () => new Array(b.length + 1).fill(0)
+  );
+  for (let i2 = a.length - 1; i2 >= 0; i2--) {
+    for (let j2 = b.length - 1; j2 >= 0; j2--) {
+      table[i2][j2] = a[i2] === b[j2] ? table[i2 + 1][j2 + 1] + 1 : Math.max(table[i2 + 1][j2], table[i2][j2 + 1]);
+    }
+  }
+  const common = [];
+  let i = 0;
+  let j = 0;
+  while (i < a.length && j < b.length) {
+    if (a[i] === b[j]) {
+      common.push(a[i]);
+      i++;
+      j++;
+    } else if (table[i + 1][j] >= table[i][j + 1]) {
+      i++;
+    } else {
+      j++;
+    }
+  }
+  return common;
+}
+function similarity(a, b) {
+  const left = words(a);
+  const right = words(b);
+  if (left.size === 0 || right.size === 0) return 0;
+  let shared = 0;
+  for (const word of left) if (right.has(word)) shared++;
+  return shared / Math.max(left.size, right.size);
+}
+function words(s) {
+  return new Set(s.toLowerCase().match(/\p{L}+/gu) ?? []);
+}
+
+export {
+  blocksFromDoc,
+  shapesFromDoc,
+  docFromBlocks,
+  diffBlocks
+};
+//# sourceMappingURL=chunk-7GOSVZTI.js.map

package/dist/chunk-7GOSVZTI.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/document.ts","../src/diff.ts"],"sourcesContent":["/**\n * RichNode is one node of a TipTap document.\n *\n * The index signature is what lets a document cross the boundary with an\n * editor handle typed as a plain object, which is how TipTap hands its JSON\n * back. Without it every call site pays for the mismatch in casts.\n */\nexport interface RichNode {\n  type?: string;\n  attrs?: Record<string, unknown>;\n  content?: RichNode[];\n  text?: string;\n  [key: string]: unknown;\n}\n\nexport type RichDoc = RichNode;\n\nexport interface BlockShape {\n  type: \"paragraph\" | \"heading\";\n  level?: number;\n}\n\n/**\n * blocksFromDoc flattens a TipTap document to the text of its top-level nodes.\n *\n * Marks are dropped rather than encoded: the diff compares prose, and a bold\n * span that moved inside an otherwise identical sentence is not a change worth\n * asking the reviewer about.\n */\nexport function blocksFromDoc(doc: RichDoc): string[] {\n  return (doc.content ?? []).map(textOf).filter((text) => text.trim() !== \"\");\n}\n\n/** shapesFromDoc records what each block was, so a revision can be rebuilt\n *  without turning every heading into a paragraph. */\nexport function shapesFromDoc(doc: RichDoc): BlockShape[] {\n  return (doc.content ?? [])\n    .filter((node) => textOf(node).trim() !== \"\")\n    .map((node) =>\n      node.type === \"heading\"\n        ? { type: \"heading\" as const, level: Number(node.attrs?.level ?? 2) }\n        : { type: \"paragraph\" as const },\n    );\n}\n\nexport function docFromBlocks(blocks: string[], shapes: BlockShape[] = []): RichDoc {\n  const content: RichNode[] = [];\n  blocks.forEach((block, i) => {\n    const text = block.trim();\n    if (text === \"\") return;\n\n    const shape = shapes[i];\n    if (shape?.type === \"heading\") {\n      content.push({\n        type: \"heading\",\n        attrs: { level: shape.level ?? 2 },\n        content: [{ type: \"text\", text }],\n      });\n      return;\n    }\n    content.push({ type: \"paragraph\", content: [{ type: \"text\", text }] });\n  });\n  return { type: \"doc\", content };\n}\n\nfunction textOf(node: RichNode): string {\n  if (typeof node.text === \"string\") return node.text;\n  return (node.content ?? []).map(textOf).join(\"\");\n}\n","export type ChangeKind = \"keep\" | \"insert\" | \"delete\" | \"replace\";\n\nexport interface BlockChange {\n  id: string;\n  kind: ChangeKind;\n  before: string;\n  after: string;\n}\n\n// Below this, two blocks are different things rather than one rewritten twice,\n// and pairing them would hide a deletion behind an unrelated insertion.\nconst PAIR_THRESHOLD = 0.34;\n\n/**\n * diffBlocks compares two documents one block at a time.\n *\n * The block is the unit because it is the unit a reviewer accepts or rejects:\n * a finer diff turns one editorial decision into a dozen clicks, and a coarser\n * one makes rejecting a single sentence cost the whole section.\n *\n * Accepting every change rebuilds `after` exactly; rejecting every change\n * rebuilds `before` exactly. The UI relies on both.\n */\nexport function diffBlocks(before: string[], after: string[]): BlockChange[] {\n  const common = longestCommonSubsequence(before, after);\n\n  const changes: BlockChange[] = [];\n  let i = 0;\n  let j = 0;\n  let seq = 0;\n  const id = () => `c${seq++}`;\n\n  const flush = (removed: string[], added: string[]) => {\n    // Blocks that vanish and appear at the same place between two unchanged\n    // anchors are one rewrite, and the reviewer wants one decision rather than\n    // two that can be answered inconsistently. When the counts differ, the\n    // extras are genuine insertions or deletions, so only pair the ones that\n    // read as rewrites of each other.\n    const balanced = removed.length === added.length;\n    const paired = Math.min(removed.length, added.length);\n    let p = 0;\n    for (; p < paired; p++) {\n      if (!balanced && similarity(removed[p], added[p]) < PAIR_THRESHOLD) break;\n      changes.push({ id: id(), kind: \"replace\", before: removed[p], after: added[p] });\n    }\n    for (let r = p; r < removed.length; r++) {\n      changes.push({ id: id(), kind: \"delete\", before: removed[r], after: \"\" });\n    }\n    for (let a = p; a < added.length; a++) {\n      changes.push({ id: id(), kind: \"insert\", before: \"\", after: added[a] });\n    }\n  };\n\n  for (const anchor of common) {\n    const removed: string[] = [];\n    const added: string[] = [];\n    while (i < before.length && before[i] !== anchor) removed.push(before[i++]);\n    while (j < after.length && after[j] !== anchor) added.push(after[j++]);\n    flush(removed, added);\n    changes.push({ id: id(), kind: \"keep\", before: anchor, after: anchor });\n    i++;\n    j++;\n  }\n  flush(before.slice(i), after.slice(j));\n\n  return changes;\n}\n\nfunction longestCommonSubsequence(a: string[], b: string[]): string[] {\n  const table: number[][] = Array.from({ length: a.length + 1 }, () =>\n    new Array<number>(b.length + 1).fill(0),\n  );\n  for (let i = a.length - 1; i >= 0; i--) {\n    for (let j = b.length - 1; j >= 0; j--) {\n      table[i][j] =\n        a[i] === b[j] ? table[i + 1][j + 1] + 1 : Math.max(table[i + 1][j], table[i][j + 1]);\n    }\n  }\n\n  const common: string[] = [];\n  let i = 0;\n  let j = 0;\n  while (i < a.length && j < b.length) {\n    if (a[i] === b[j]) {\n      common.push(a[i]);\n      i++;\n      j++;\n    } else if (table[i + 1][j] >= table[i][j + 1]) {\n      i++;\n    } else {\n      j++;\n    }\n  }\n  return common;\n}\n\n// Word overlap rather than character distance: an LLM rewrite keeps most of the\n// vocabulary and reorders it, which edit distance scores as a near-total change.\nfunction similarity(a: string, b: string): number {\n  const left = words(a);\n  const right = words(b);\n  if (left.size === 0 || right.size === 0) return 0;\n\n  let shared = 0;\n  for (const word of left) if (right.has(word)) shared++;\n  return shared / Math.max(left.size, right.size);\n}\n\nfunction words(s: string): Set<string> {\n  return new Set(s.toLowerCase().match(/\\p{L}+/gu) ?? []);\n}\n"],"mappings":";AA6BO,SAAS,cAAc,KAAwB;AACpD,UAAQ,IAAI,WAAW,CAAC,GAAG,IAAI,MAAM,EAAE,OAAO,CAAC,SAAS,KAAK,KAAK,MAAM,EAAE;AAC5E;AAIO,SAAS,cAAc,KAA4B;AACxD,UAAQ,IAAI,WAAW,CAAC,GACrB,OAAO,CAAC,SAAS,OAAO,IAAI,EAAE,KAAK,MAAM,EAAE,EAC3C;AAAA,IAAI,CAAC,SACJ,KAAK,SAAS,YACV,EAAE,MAAM,WAAoB,OAAO,OAAO,KAAK,OAAO,SAAS,CAAC,EAAE,IAClE,EAAE,MAAM,YAAqB;AAAA,EACnC;AACJ;AAEO,SAAS,cAAc,QAAkB,SAAuB,CAAC,GAAY;AAClF,QAAM,UAAsB,CAAC;AAC7B,SAAO,QAAQ,CAAC,OAAO,MAAM;AAC3B,UAAM,OAAO,MAAM,KAAK;AACxB,QAAI,SAAS,GAAI;AAEjB,UAAM,QAAQ,OAAO,CAAC;AACtB,QAAI,OAAO,SAAS,WAAW;AAC7B,cAAQ,KAAK;AAAA,QACX,MAAM;AAAA,QACN,OAAO,EAAE,OAAO,MAAM,SAAS,EAAE;AAAA,QACjC,SAAS,CAAC,EAAE,MAAM,QAAQ,KAAK,CAAC;AAAA,MAClC,CAAC;AACD;AAAA,IACF;AACA,YAAQ,KAAK,EAAE,MAAM,aAAa,SAAS,CAAC,EAAE,MAAM,QAAQ,KAAK,CAAC,EAAE,CAAC;AAAA,EACvE,CAAC;AACD,SAAO,EAAE,MAAM,OAAO,QAAQ;AAChC;AAEA,SAAS,OAAO,MAAwB;AACtC,MAAI,OAAO,KAAK,SAAS,SAAU,QAAO,KAAK;AAC/C,UAAQ,KAAK,WAAW,CAAC,GAAG,IAAI,MAAM,EAAE,KAAK,EAAE;AACjD;;;ACzDA,IAAM,iBAAiB;AAYhB,SAAS,WAAW,QAAkB,OAAgC;AAC3E,QAAM,SAAS,yBAAyB,QAAQ,KAAK;AAErD,QAAM,UAAyB,CAAC;AAChC,MAAI,IAAI;AACR,MAAI,IAAI;AACR,MAAI,MAAM;AACV,QAAM,KAAK,MAAM,IAAI,KAAK;AAE1B,QAAM,QAAQ,CAAC,SAAmB,UAAoB;AAMpD,UAAM,WAAW,QAAQ,WAAW,MAAM;AAC1C,UAAM,SAAS,KAAK,IAAI,QAAQ,QAAQ,MAAM,MAAM;AACpD,QAAI,IAAI;AACR,WAAO,IAAI,QAAQ,KAAK;AACtB,UAAI,CAAC,YAAY,WAAW,QAAQ,CAAC,GAAG,MAAM,CAAC,CAAC,IAAI,eAAgB;AACpE,cAAQ,KAAK,EAAE,IAAI,GAAG,GAAG,MAAM,WAAW,QAAQ,QAAQ,CAAC,GAAG,OAAO,MAAM,CAAC,EAAE,CAAC;AAAA,IACjF;AACA,aAAS,IAAI,GAAG,IAAI,QAAQ,QAAQ,KAAK;AACvC,cAAQ,KAAK,EAAE,IAAI,GAAG,GAAG,MAAM,UAAU,QAAQ,QAAQ,CAAC,GAAG,OAAO,GAAG,CAAC;AAAA,IAC1E;AACA,aAAS,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK;AACrC,cAAQ,KAAK,EAAE,IAAI,GAAG,GAAG,MAAM,UAAU,QAAQ,IAAI,OAAO,MAAM,CAAC,EAAE,CAAC;AAAA,IACxE;AAAA,EACF;AAEA,aAAW,UAAU,QAAQ;AAC3B,UAAM,UAAoB,CAAC;AAC3B,UAAM,QAAkB,CAAC;AACzB,WAAO,IAAI,OAAO,UAAU,OAAO,CAAC,MAAM,OAAQ,SAAQ,KAAK,OAAO,GAAG,CAAC;AAC1E,WAAO,IAAI,MAAM,UAAU,MAAM,CAAC,MAAM,OAAQ,OAAM,KAAK,MAAM,GAAG,CAAC;AACrE,UAAM,SAAS,KAAK;AACpB,YAAQ,KAAK,EAAE,IAAI,GAAG,GAAG,MAAM,QAAQ,QAAQ,QAAQ,OAAO,OAAO,CAAC;AACtE;AACA;AAAA,EACF;AACA,QAAM,OAAO,MAAM,CAAC,GAAG,MAAM,MAAM,CAAC,CAAC;AAErC,SAAO;AACT;AAEA,SAAS,yBAAyB,GAAa,GAAuB;AACpE,QAAM,QAAoB,MAAM;AAAA,IAAK,EAAE,QAAQ,EAAE,SAAS,EAAE;AAAA,IAAG,MAC7D,IAAI,MAAc,EAAE,SAAS,CAAC,EAAE,KAAK,CAAC;AAAA,EACxC;AACA,WAASA,KAAI,EAAE,SAAS,GAAGA,MAAK,GAAGA,MAAK;AACtC,aAASC,KAAI,EAAE,SAAS,GAAGA,MAAK,GAAGA,MAAK;AACtC,YAAMD,EAAC,EAAEC,EAAC,IACR,EAAED,EAAC,MAAM,EAAEC,EAAC,IAAI,MAAMD,KAAI,CAAC,EAAEC,KAAI,CAAC,IAAI,IAAI,KAAK,IAAI,MAAMD,KAAI,CAAC,EAAEC,EAAC,GAAG,MAAMD,EAAC,EAAEC,KAAI,CAAC,CAAC;AAAA,IACvF;AAAA,EACF;AAEA,QAAM,SAAmB,CAAC;AAC1B,MAAI,IAAI;AACR,MAAI,IAAI;AACR,SAAO,IAAI,EAAE,UAAU,IAAI,EAAE,QAAQ;AACnC,QAAI,EAAE,CAAC,MAAM,EAAE,CAAC,GAAG;AACjB,aAAO,KAAK,EAAE,CAAC,CAAC;AAChB;AACA;AAAA,IACF,WAAW,MAAM,IAAI,CAAC,EAAE,CAAC,KAAK,MAAM,CAAC,EAAE,IAAI,CAAC,GAAG;AAC7C;AAAA,IACF,OAAO;AACL;AAAA,IACF;AAAA,EACF;AACA,SAAO;AACT;AAIA,SAAS,WAAW,GAAW,GAAmB;AAChD,QAAM,OAAO,MAAM,CAAC;AACpB,QAAM,QAAQ,MAAM,CAAC;AACrB,MAAI,KAAK,SAAS,KAAK,MAAM,SAAS,EAAG,QAAO;AAEhD,MAAI,SAAS;AACb,aAAW,QAAQ,KAAM,KAAI,MAAM,IAAI,IAAI,EAAG;AAC9C,SAAO,SAAS,KAAK,IAAI,KAAK,MAAM,MAAM,IAAI;AAChD;AAEA,SAAS,MAAM,GAAwB;AACrC,SAAO,IAAI,IAAI,EAAE,YAAY,EAAE,MAAM,UAAU,KAAK,CAAC,CAAC;AACxD;","names":["i","j"]}

package/dist/editor.css

@@ -0,0 +1,32 @@
+/* Colours are variables so a host theme can override them without forking the
+   package. The defaults read on both a light and a dark background. */
+:root {
+  --lalt-editor-insert: #1d4ed8;
+  --lalt-editor-insert-bg: rgb(29 78 216 / 0.08);
+  --lalt-editor-delete: #b91c1c;
+  --lalt-editor-delete-bg: rgb(185 28 28 / 0.06);
+}
+
+.lalt-revision {
+  display: block;
+  border-radius: 0.375rem;
+  padding: 0.125rem 0.25rem;
+}
+
+.lalt-revision--insert {
+  color: var(--lalt-editor-insert);
+  background: var(--lalt-editor-insert-bg);
+}
+
+.lalt-revision--delete {
+  color: var(--lalt-editor-delete);
+  background: var(--lalt-editor-delete-bg);
+  text-decoration: line-through;
+}
+
+/* A decided suggestion stops competing for attention but stays visible, so the
+   reviewer can see what they already answered without re-reading the diff. */
+.lalt-revision--decided {
+  opacity: 0.45;
+  background: none;
+}

package/dist/index.d.ts

@@ -0,0 +1,52 @@
+/**
+ * RichNode is one node of a TipTap document.
+ *
+ * The index signature is what lets a document cross the boundary with an
+ * editor handle typed as a plain object, which is how TipTap hands its JSON
+ * back. Without it every call site pays for the mismatch in casts.
+ */
+interface RichNode {
+    type?: string;
+    attrs?: Record<string, unknown>;
+    content?: RichNode[];
+    text?: string;
+    [key: string]: unknown;
+}
+type RichDoc = RichNode;
+interface BlockShape {
+    type: "paragraph" | "heading";
+    level?: number;
+}
+/**
+ * blocksFromDoc flattens a TipTap document to the text of its top-level nodes.
+ *
+ * Marks are dropped rather than encoded: the diff compares prose, and a bold
+ * span that moved inside an otherwise identical sentence is not a change worth
+ * asking the reviewer about.
+ */
+declare function blocksFromDoc(doc: RichDoc): string[];
+/** shapesFromDoc records what each block was, so a revision can be rebuilt
+ *  without turning every heading into a paragraph. */
+declare function shapesFromDoc(doc: RichDoc): BlockShape[];
+declare function docFromBlocks(blocks: string[], shapes?: BlockShape[]): RichDoc;
+
+type ChangeKind = "keep" | "insert" | "delete" | "replace";
+interface BlockChange {
+    id: string;
+    kind: ChangeKind;
+    before: string;
+    after: string;
+}
+/**
+ * diffBlocks compares two documents one block at a time.
+ *
+ * The block is the unit because it is the unit a reviewer accepts or rejects:
+ * a finer diff turns one editorial decision into a dozen clicks, and a coarser
+ * one makes rejecting a single sentence cost the whole section.
+ *
+ * Accepting every change rebuilds `after` exactly; rejecting every change
+ * rebuilds `before` exactly. The UI relies on both.
+ */
+declare function diffBlocks(before: string[], after: string[]): BlockChange[];
+
+export { type BlockChange, type BlockShape, type ChangeKind, type RichDoc, type RichNode, blocksFromDoc, diffBlocks, docFromBlocks, shapesFromDoc };

package/dist/index.js

@@ -0,0 +1,13 @@
+import {
+  blocksFromDoc,
+  diffBlocks,
+  docFromBlocks,
+  shapesFromDoc
+} from "./chunk-7GOSVZTI.js";
+export {
+  blocksFromDoc,
+  diffBlocks,
+  docFromBlocks,
+  shapesFromDoc
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/revisions.d.ts

@@ -0,0 +1,63 @@
+import { BlockChange, RichDoc } from './index.js';
+export { ChangeKind } from './index.js';
+
+type Decision = "pending" | "accepted" | "rejected";
+interface RevisionState {
+    changes: BlockChange[];
+    decisions: Record<string, Decision>;
+    pending: number;
+}
+/**
+ * openRevision starts a review of what the model returned.
+ *
+ * Nothing is applied yet: the document the user sees keeps reading as it did,
+ * with the proposals shown beside it, until they decide one at a time.
+ */
+declare function openRevision(before: string[], after: string[]): RevisionState;
+declare function accept(state: RevisionState, id: string): RevisionState;
+declare function reject(state: RevisionState, id: string): RevisionState;
+declare function acceptAll(state: RevisionState): RevisionState;
+declare function rejectAll(state: RevisionState): RevisionState;
+/**
+ * resolvedBlocks is the document as it currently stands, counting every
+ * decision made so far and leaving undecided changes at their original text.
+ *
+ * It is always a valid document, so the editor can save mid-review rather than
+ * forcing the user to finish before they are allowed to keep their work.
+ */
+declare function resolvedBlocks(state: RevisionState): string[];
+/**
+ * resolved is resolvedBlocks with the origin of each block.
+ *
+ * `sourceIndex` is where the block sat in the document under review, or -1 for
+ * one the model added. A caller restoring block shapes needs it: accepting an
+ * insertion shifts every later block, so positions in the result no longer
+ * line up with positions in the source.
+ */
+declare function resolved(state: RevisionState): Array<{
+    text: string;
+    sourceIndex: number;
+}>;
+
+interface UseRevisions {
+    state: RevisionState | null;
+    /** The document as it stands, counting the decisions made so far. */
+    doc: RichDoc | null;
+    pending: number;
+    open: (revised: string[]) => void;
+    accept: (id: string) => void;
+    reject: (id: string) => void;
+    acceptAll: () => void;
+    rejectAll: () => void;
+    /** Ends the review, keeping whatever `doc` currently reads as. */
+    close: () => void;
+}
+/**
+ * useRevisions holds one review of what a model proposed.
+ *
+ * The suggestions never enter the document: they live here, beside it, so the
+ * editor's own content stays valid and saveable at every point of the review.
+ */
+declare function useRevisions(source: RichDoc | null): UseRevisions;
+
+export { BlockChange, type Decision, type RevisionState, type UseRevisions, accept, acceptAll, openRevision, reject, rejectAll, resolved, resolvedBlocks, useRevisions };

package/dist/revisions.js

@@ -0,0 +1,111 @@
+import {
+  blocksFromDoc,
+  diffBlocks,
+  docFromBlocks,
+  shapesFromDoc
+} from "./chunk-7GOSVZTI.js";
+
+// src/revision-state.ts
+function openRevision(before, after) {
+  const changes = diffBlocks(before, after);
+  const decisions = {};
+  for (const change of changes) {
+    decisions[change.id] = change.kind === "keep" ? "accepted" : "pending";
+  }
+  return { changes, decisions, pending: countPending(changes, decisions) };
+}
+function accept(state, id) {
+  return decide(state, id, "accepted");
+}
+function reject(state, id) {
+  return decide(state, id, "rejected");
+}
+function acceptAll(state) {
+  return decideAll(state, "accepted");
+}
+function rejectAll(state) {
+  return decideAll(state, "rejected");
+}
+function resolvedBlocks(state) {
+  return resolved(state).map((entry) => entry.text);
+}
+function resolved(state) {
+  const blocks = [];
+  let source = 0;
+  for (const change of state.changes) {
+    const decided = state.decisions[change.id] === "accepted";
+    switch (change.kind) {
+      case "keep":
+        blocks.push({ text: change.after, sourceIndex: source++ });
+        break;
+      case "insert":
+        if (decided) blocks.push({ text: change.after, sourceIndex: -1 });
+        break;
+      case "delete":
+        if (!decided) blocks.push({ text: change.before, sourceIndex: source });
+        source++;
+        break;
+      case "replace":
+        blocks.push({ text: decided ? change.after : change.before, sourceIndex: source++ });
+        break;
+    }
+  }
+  return blocks;
+}
+function decide(state, id, decision) {
+  if (!(id in state.decisions) || state.decisions[id] === decision) return state;
+  const decisions = { ...state.decisions, [id]: decision };
+  return { ...state, decisions, pending: countPending(state.changes, decisions) };
+}
+function decideAll(state, decision) {
+  const decisions = {};
+  for (const change of state.changes) {
+    decisions[change.id] = change.kind === "keep" ? "accepted" : decision;
+  }
+  return { ...state, decisions, pending: 0 };
+}
+function countPending(changes, decisions) {
+  return changes.filter((c) => c.kind !== "keep" && decisions[c.id] === "pending").length;
+}
+
+// src/useRevisions.ts
+import { useCallback, useMemo, useState } from "react";
+function useRevisions(source) {
+  const [state, setState] = useState(null);
+  const original = useMemo(() => source ? blocksFromDoc(source) : [], [source]);
+  const shapes = useMemo(() => source ? shapesFromDoc(source) : [], [source]);
+  const open = useCallback(
+    (revised) => setState(openRevision(original, revised)),
+    [original]
+  );
+  const doc = useMemo(() => {
+    if (!state) return null;
+    const entries = resolved(state);
+    return docFromBlocks(
+      entries.map((entry) => entry.text),
+      entries.map((entry) => shapes[entry.sourceIndex] ?? { type: "paragraph" })
+    );
+  }, [state, shapes]);
+  return {
+    state,
+    doc,
+    pending: state?.pending ?? 0,
+    open,
+    accept: useCallback((id) => setState((s) => s ? accept(s, id) : s), []),
+    reject: useCallback((id) => setState((s) => s ? reject(s, id) : s), []),
+    acceptAll: useCallback(() => setState((s) => s ? acceptAll(s) : s), []),
+    rejectAll: useCallback(() => setState((s) => s ? rejectAll(s) : s), []),
+    close: useCallback(() => setState(null), [])
+  };
+}
+export {
+  accept,
+  acceptAll,
+  openRevision,
+  reject,
+  rejectAll,
+  resolved,
+  resolvedBlocks,
+  useRevisions
+};
+//# sourceMappingURL=revisions.js.map

package/dist/revisions.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/revision-state.ts","../src/useRevisions.ts"],"sourcesContent":["import { diffBlocks, type BlockChange, type ChangeKind } from \"./diff\";\n\nexport type { BlockChange, ChangeKind };\n\nexport type Decision = \"pending\" | \"accepted\" | \"rejected\";\n\nexport interface RevisionState {\n  changes: BlockChange[];\n  decisions: Record<string, Decision>;\n  pending: number;\n}\n\n/**\n * openRevision starts a review of what the model returned.\n *\n * Nothing is applied yet: the document the user sees keeps reading as it did,\n * with the proposals shown beside it, until they decide one at a time.\n */\nexport function openRevision(before: string[], after: string[]): RevisionState {\n  const changes = diffBlocks(before, after);\n  const decisions: Record<string, Decision> = {};\n  for (const change of changes) {\n    decisions[change.id] = change.kind === \"keep\" ? \"accepted\" : \"pending\";\n  }\n  return { changes, decisions, pending: countPending(changes, decisions) };\n}\n\nexport function accept(state: RevisionState, id: string): RevisionState {\n  return decide(state, id, \"accepted\");\n}\n\nexport function reject(state: RevisionState, id: string): RevisionState {\n  return decide(state, id, \"rejected\");\n}\n\nexport function acceptAll(state: RevisionState): RevisionState {\n  return decideAll(state, \"accepted\");\n}\n\nexport function rejectAll(state: RevisionState): RevisionState {\n  return decideAll(state, \"rejected\");\n}\n\n/**\n * resolvedBlocks is the document as it currently stands, counting every\n * decision made so far and leaving undecided changes at their original text.\n *\n * It is always a valid document, so the editor can save mid-review rather than\n * forcing the user to finish before they are allowed to keep their work.\n */\nexport function resolvedBlocks(state: RevisionState): string[] {\n  return resolved(state).map((entry) => entry.text);\n}\n\n/**\n * resolved is resolvedBlocks with the origin of each block.\n *\n * `sourceIndex` is where the block sat in the document under review, or -1 for\n * one the model added. A caller restoring block shapes needs it: accepting an\n * insertion shifts every later block, so positions in the result no longer\n * line up with positions in the source.\n */\nexport function resolved(state: RevisionState): Array<{ text: string; sourceIndex: number }> {\n  const blocks: Array<{ text: string; sourceIndex: number }> = [];\n  let source = 0;\n  for (const change of state.changes) {\n    const decided = state.decisions[change.id] === \"accepted\";\n    switch (change.kind) {\n      case \"keep\":\n        blocks.push({ text: change.after, sourceIndex: source++ });\n        break;\n      case \"insert\":\n        if (decided) blocks.push({ text: change.after, sourceIndex: -1 });\n        break;\n      case \"delete\":\n        if (!decided) blocks.push({ text: change.before, sourceIndex: source });\n        source++;\n        break;\n      case \"replace\":\n        blocks.push({ text: decided ? change.after : change.before, sourceIndex: source++ });\n        break;\n    }\n  }\n  return blocks;\n}\n\nfunction decide(state: RevisionState, id: string, decision: Decision): RevisionState {\n  if (!(id in state.decisions) || state.decisions[id] === decision) return state;\n\n  const decisions = { ...state.decisions, [id]: decision };\n  return { ...state, decisions, pending: countPending(state.changes, decisions) };\n}\n\nfunction decideAll(state: RevisionState, decision: Decision): RevisionState {\n  const decisions: Record<string, Decision> = {};\n  for (const change of state.changes) {\n    decisions[change.id] = change.kind === \"keep\" ? \"accepted\" : decision;\n  }\n  return { ...state, decisions, pending: 0 };\n}\n\nfunction countPending(changes: BlockChange[], decisions: Record<string, Decision>): number {\n  return changes.filter((c) => c.kind !== \"keep\" && decisions[c.id] === \"pending\").length;\n}\n","import { useCallback, useMemo, useState } from \"react\";\n\nimport { blocksFromDoc, docFromBlocks, shapesFromDoc, type RichDoc } from \"./document\";\nimport {\n  accept,\n  acceptAll,\n  openRevision,\n  reject,\n  rejectAll,\n  resolved,\n  type RevisionState,\n} from \"./revision-state\";\n\nexport interface UseRevisions {\n  state: RevisionState | null;\n  /** The document as it stands, counting the decisions made so far. */\n  doc: RichDoc | null;\n  pending: number;\n  open: (revised: string[]) => void;\n  accept: (id: string) => void;\n  reject: (id: string) => void;\n  acceptAll: () => void;\n  rejectAll: () => void;\n  /** Ends the review, keeping whatever `doc` currently reads as. */\n  close: () => void;\n}\n\n/**\n * useRevisions holds one review of what a model proposed.\n *\n * The suggestions never enter the document: they live here, beside it, so the\n * editor's own content stays valid and saveable at every point of the review.\n */\nexport function useRevisions(source: RichDoc | null): UseRevisions {\n  const [state, setState] = useState<RevisionState | null>(null);\n\n  const original = useMemo(() => (source ? blocksFromDoc(source) : []), [source]);\n  const shapes = useMemo(() => (source ? shapesFromDoc(source) : []), [source]);\n\n  const open = useCallback(\n    (revised: string[]) => setState(openRevision(original, revised)),\n    [original],\n  );\n\n  const doc = useMemo(() => {\n    if (!state) return null;\n    const entries = resolved(state);\n    return docFromBlocks(\n      entries.map((entry) => entry.text),\n      entries.map((entry) => shapes[entry.sourceIndex] ?? { type: \"paragraph\" as const }),\n    );\n  }, [state, shapes]);\n\n  return {\n    state,\n    doc,\n    pending: state?.pending ?? 0,\n    open,\n    accept: useCallback((id: string) => setState((s) => (s ? accept(s, id) : s)), []),\n    reject: useCallback((id: string) => setState((s) => (s ? reject(s, id) : s)), []),\n    acceptAll: useCallback(() => setState((s) => (s ? acceptAll(s) : s)), []),\n    rejectAll: useCallback(() => setState((s) => (s ? rejectAll(s) : s)), []),\n    close: useCallback(() => setState(null), []),\n  };\n}\n"],"mappings":"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","names":[]}

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@lalternative/editor",
+  "version": "0.1.0",
+  "description": "Shared TipTap editor for L'Alternative apps: rich text, format menu, selection toolbar and inline AI revisions",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./revisions": {
+      "import": "./dist/revisions.js",
+      "types": "./dist/revisions.d.ts"
+    },
+    "./styles.css": "./dist/editor.css"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run"
+  },
+  "peerDependencies": {
+    "@tiptap/core": ">=3.0.0",
+    "@tiptap/pm": ">=3.0.0",
+    "@tiptap/react": ">=3.0.0",
+    "@tiptap/starter-kit": ">=3.0.0",
+    "react": ">=18.0.0",
+    "react-dom": ">=18.0.0"
+  },
+  "devDependencies": {
+    "@tiptap/core": "^3.29.2",
+    "@tiptap/pm": "^3.29.2",
+    "@tiptap/react": "^3.29.2",
+    "@tiptap/starter-kit": "^3.29.2",
+    "@types/react": "^19.0.0",
+    "@types/react-dom": "^19.0.0",
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0",
+    "tsup": "^8.5.1",
+    "typescript": "^5.7.0",
+    "vitest": "^3.0.0"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org",
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/lalternative/packages.git",
+    "directory": "editor"
+  }
+}