@ephia/dova-sdk 1.0.0

package/src/core/bindings/targets/tiptap.binding.test.ts

@@ -0,0 +1,417 @@
+// @vitest-environment jsdom
+
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { Editor, Node } from "@tiptap/core";
+import type { TargetBinding } from "../TargetBinding";
+import { documentStore } from "../../../shared/store/document-store";
+import {
+  createTiptapBinding,
+  EphiaCommittedMark,
+  EphiaPlaceholderMark,
+  EphiaPreviewMark,
+  EphiaRevisedMark,
+} from "./tiptap.binding";
+
+const DocumentNode = Node.create({
+  name: "doc",
+  topNode: true,
+  content: "block+",
+});
+
+const ParagraphNode = Node.create({
+  name: "paragraph",
+  group: "block",
+  content: "inline*",
+  parseHTML() {
+    return [{ tag: "p" }];
+  },
+  renderHTML() {
+    return ["p", 0];
+  },
+});
+
+const TextNode = Node.create({
+  name: "text",
+  group: "inline",
+});
+
+const HardBreakNode = Node.create({
+  name: "hardBreak",
+  group: "inline",
+  inline: true,
+  selectable: false,
+  parseHTML() {
+    return [{ tag: "br" }];
+  },
+  renderHTML() {
+    return ["br"];
+  },
+});
+
+function createEditor(
+  content = "<p></p>",
+  options: { hardBreak?: boolean } = {}
+): Editor {
+  const includeHardBreak = options.hardBreak ?? true;
+  return new Editor({
+    element: document.createElement("div"),
+    extensions: [
+      DocumentNode,
+      ParagraphNode,
+      TextNode,
+      ...(includeHardBreak ? [HardBreakNode] : []),
+      EphiaPreviewMark,
+      EphiaCommittedMark,
+      EphiaRevisedMark,
+      EphiaPlaceholderMark,
+    ],
+    content,
+  });
+}
+
+async function flushPartial(): Promise<void> {
+  await vi.advanceTimersByTimeAsync(60);
+}
+
+async function flushStoreSync(): Promise<void> {
+  await vi.advanceTimersByTimeAsync(16);
+}
+
+const editors: Editor[] = [];
+const bindings: TargetBinding[] = [];
+
+type JsonNode = { type?: string; content?: JsonNode[] };
+
+function countNodesByType(node: JsonNode | undefined, type: string): number {
+  if (!node) return 0;
+  return (
+    (node.type === type ? 1 : 0) +
+    (node.content?.reduce<number>((sum, child) => sum + countNodesByType(child, type), 0) ?? 0)
+  );
+}
+
+function firstParagraphContentTypes(editor: Editor): string[] {
+  const json = editor.getJSON();
+  return json.content?.[0]?.content?.map((node) => node.type ?? "") ?? [];
+}
+
+beforeEach(() => {
+  vi.useFakeTimers();
+  documentStore.getState().syncFromEditor("", []);
+  documentStore.getState().setSelection(null, null);
+});
+
+afterEach(() => {
+  while (bindings.length) {
+    bindings.pop()?.detach();
+  }
+  while (editors.length) {
+    editors.pop()?.destroy();
+  }
+  vi.useRealTimers();
+});
+
+describe("createTiptapBinding", () => {
+  it("replaces fast partial updates in one stable preview range", async () => {
+    const editor = createEditor("<p></p>");
+    editors.push(editor);
+    const binding = createTiptapBinding(editor);
+    bindings.push(binding);
+
+    binding.beginSession!();
+    binding.insertPartial!("s1", "bonjour", 1);
+    binding.insertPartial!("s1", "bonjour docteur", 2);
+    expect(editor.getText()).toBe("");
+    await flushPartial();
+
+    expect(editor.getText()).toBe("bonjour docteur");
+
+    binding.commitFinal("s1", "bonjour docteur.");
+
+    expect(editor.getText()).toBe("bonjour docteur.");
+  });
+
+  it("flushes a pending partial immediately on commit", async () => {
+    const editor = createEditor("<p></p>");
+    editors.push(editor);
+    const binding = createTiptapBinding(editor);
+    bindings.push(binding);
+
+    binding.beginSession!();
+    binding.insertPartial!("s1", "bonjour", 1);
+    binding.commitFinal("s1", "bonjour.");
+
+    expect(editor.getText()).toBe("bonjour.");
+    await flushPartial();
+    expect(editor.getText()).toBe("bonjour.");
+  });
+
+  it("replaces the initial selection lazily on first insert", async () => {
+    const editor = createEditor("<p>hello old world</p>");
+    editors.push(editor);
+    const binding = createTiptapBinding(editor);
+    bindings.push(binding);
+    editor.commands.focus();
+    editor.commands.setTextSelection({ from: 7, to: 10 });
+
+    binding.beginSession!();
+    expect(editor.getText()).toBe("hello old world");
+
+    binding.insertPartial!("s1", "new", 1);
+    await flushPartial();
+
+    expect(editor.getText()).toBe("hello new world");
+  });
+
+  it("removes absorbed preview segments on commit", async () => {
+    const editor = createEditor("<p></p>");
+    editors.push(editor);
+    const binding = createTiptapBinding(editor);
+    bindings.push(binding);
+
+    binding.beginSession!();
+    binding.insertPartial!("s1", "Bonjour", 1);
+    await flushPartial();
+    binding.insertPartial!("s2", "suite parasite", 1);
+    expect(editor.getText()).not.toContain("suite parasite");
+
+    binding.commitFinal("s1", "Bonjour.", { absorbedSegmentIds: ["s2"] });
+    await flushPartial();
+
+    expect(editor.getText()).toBe("Bonjour.");
+  });
+
+  it("clearAll removes previews without deleting committed text", async () => {
+    const editor = createEditor("<p></p>");
+    editors.push(editor);
+    const binding = createTiptapBinding(editor);
+    bindings.push(binding);
+
+    binding.beginSession!();
+    binding.insertPartial!("s1", "Texte final", 1);
+    await flushPartial();
+    binding.commitFinal("s1", "Texte final");
+    binding.insertPartial!("s2", "preview", 1);
+    await flushPartial();
+
+    binding.clearAll?.();
+
+    expect(editor.getText()).toBe("Texte final");
+  });
+
+  it("does not sync preview-only transactions to the document store", async () => {
+    const editor = createEditor("<p>Base</p>");
+    editors.push(editor);
+    const binding = createTiptapBinding(editor);
+    bindings.push(binding);
+
+    await flushStoreSync();
+    expect(documentStore.getState().content).toBe("Base");
+
+    binding.beginSession!();
+    binding.insertPartial!("s1", "preview", 1);
+    await flushPartial();
+    await flushStoreSync();
+
+    expect(editor.getText()).toBe("Base preview");
+    expect(documentStore.getState().content).toBe("Base");
+
+    binding.commitFinal("s1", "preview.");
+    await flushStoreSync();
+
+    expect(documentStore.getState().content).toBe("Base preview.");
+  });
+
+  it("does not remove committed marks from a stale range after user edits", async () => {
+    const editor = createEditor("<p></p>");
+    editors.push(editor);
+    const binding = createTiptapBinding(editor);
+    bindings.push(binding);
+
+    binding.beginSession!();
+    binding.insertPartial!("s1", "Texte final", 1);
+    await flushPartial();
+    binding.commitFinal("s1", "Texte final");
+
+    editor.commands.setContent("<p>Texte modifié</p>");
+    await vi.advanceTimersByTimeAsync(1300);
+
+    expect(editor.getText()).toBe("Texte modifié");
+  });
+
+  it("commits a single newline as a hardBreak node", () => {
+    const editor = createEditor("<p></p>");
+    editors.push(editor);
+    const binding = createTiptapBinding(editor);
+    bindings.push(binding);
+
+    binding.beginSession!();
+    binding.commitFinal("s1", "ligne 1\nligne 2");
+
+    expect(binding.getText()).toBe("ligne 1\nligne 2");
+    expect(countNodesByType(editor.getJSON(), "hardBreak")).toBe(1);
+  });
+
+  it("replaces realtime committed segment when Small final arrives with same segmentId", () => {
+    const editor = createEditor("<p></p>");
+    editors.push(editor);
+    const binding = createTiptapBinding(editor);
+    bindings.push(binding);
+
+    binding.beginSession!();
+    binding.commitFinal(
+      "efde10b0",
+      "\nTechnique :\nacquisition hélicoïdale sans injection"
+    );
+
+    binding.commitFinal(
+      "efde10b0",
+      "\nTechnique :\nacquisition hélicoïdale sans injection de produit de contraste."
+    );
+
+    expect(binding.getText()).toBe(
+      "\nTechnique :\nacquisition hélicoïdale sans injection de produit de contraste."
+    );
+    expect(binding.getText()).not.toContain(
+      "acquisition hélicoïdale sans injection\nTechnique"
+    );
+  });
+
+  it("keeps segment addressable after committed mark cleanup", async () => {
+    const editor = createEditor("<p></p>");
+    editors.push(editor);
+    const binding = createTiptapBinding(editor);
+    bindings.push(binding);
+
+    binding.beginSession!();
+    binding.commitFinal("efde10b0", "\nTechnique :\nacquisition");
+
+    await vi.advanceTimersByTimeAsync(1400);
+
+    binding.commitFinal(
+      "efde10b0",
+      "\nTechnique :\nacquisition hélicoïdale sans injection."
+    );
+
+    expect(binding.getText()).toBe(
+      "\nTechnique :\nacquisition hélicoïdale sans injection."
+    );
+  });
+
+  it("does not let old realtime cleanup delete segment metadata after Small revision", async () => {
+    const editor = createEditor("<p></p>");
+    editors.push(editor);
+    const binding = createTiptapBinding(editor);
+    bindings.push(binding);
+
+    binding.beginSession!();
+    binding.commitFinal("efde10b0", "\nTechnique :\nacquisition");
+
+    await vi.advanceTimersByTimeAsync(1000);
+
+    binding.commitFinal(
+      "efde10b0",
+      "\nTechnique :\nacquisition hélicoïdale sans injection."
+    );
+
+    await vi.advanceTimersByTimeAsync(500);
+
+    binding.commitFinal(
+      "efde10b0",
+      "\nTechnique :\nacquisition hélicoïdale sans injection de produit de contraste."
+    );
+
+    expect(binding.getText()).toBe(
+      "\nTechnique :\nacquisition hélicoïdale sans injection de produit de contraste."
+    );
+  });
+
+  it("does not clear an already committed segment with clearPartial", () => {
+    const editor = createEditor("<p></p>");
+    editors.push(editor);
+    const binding = createTiptapBinding(editor);
+    bindings.push(binding);
+
+    binding.beginSession!();
+    binding.commitFinal("efde10b0", "\nTechnique :\nacquisition");
+    binding.clearPartial("efde10b0");
+
+    expect(binding.getText()).toBe("\nTechnique :\nacquisition");
+  });
+
+  it("commits a paragraph break as two consecutive hardBreak nodes", () => {
+    const editor = createEditor("<p></p>");
+    editors.push(editor);
+    const binding = createTiptapBinding(editor);
+    bindings.push(binding);
+
+    binding.beginSession!();
+    binding.commitFinal("s1", "ligne 1\n\nligne 2");
+
+    expect(binding.getText()).toBe("ligne 1\n\nligne 2");
+    expect(firstParagraphContentTypes(editor)).toEqual([
+      "text",
+      "hardBreak",
+      "hardBreak",
+      "text",
+    ]);
+  });
+
+  it("preserves hardBreak nodes across incremental partial updates", async () => {
+    const editor = createEditor("<p></p>");
+    editors.push(editor);
+    const binding = createTiptapBinding(editor);
+    bindings.push(binding);
+
+    binding.beginSession!();
+    binding.insertPartial!("s1", "ligne 1\nligne 2", 1);
+    await flushPartial();
+    binding.insertPartial!("s1", "ligne 1\nligne 2 suite", 2);
+    await flushPartial();
+
+    expect(binding.getText()).toBe("ligne 1\nligne 2 suite");
+    expect(countNodesByType(editor.getJSON(), "hardBreak")).toBe(1);
+  });
+
+  it("keeps the next committed segment positioned after a segment with a hardBreak", () => {
+    const editor = createEditor("<p></p>");
+    editors.push(editor);
+    const binding = createTiptapBinding(editor);
+    bindings.push(binding);
+
+    binding.beginSession!();
+    binding.commitFinal("s1", "ligne 1\nligne 2");
+    binding.commitFinal("s2", "suite");
+
+    expect(binding.getText()).toBe("ligne 1\nligne 2 suite");
+    expect(countNodesByType(editor.getJSON(), "hardBreak")).toBe(1);
+  });
+
+  it("applies sequential insert_text and line_break operations in one transaction", () => {
+    const editor = createEditor("<p></p>");
+    editors.push(editor);
+    const binding = createTiptapBinding(editor);
+    bindings.push(binding);
+
+    binding.applyOperations?.([
+      { id: "op1", type: "insert_text", position: "cursor", text: "ligne 1" },
+      { id: "op2", type: "line_break", position: "cursor" },
+      { id: "op3", type: "insert_text", position: "cursor", text: "ligne 2" },
+    ]);
+
+    expect(binding.getText()).toBe("ligne 1\nligne 2");
+    expect(countNodesByType(editor.getJSON(), "hardBreak")).toBe(1);
+  });
+
+  it("falls back to plain newline text when the schema has no hardBreak node", () => {
+    const editor = createEditor("<p></p>", { hardBreak: false });
+    editors.push(editor);
+    const binding = createTiptapBinding(editor);
+    bindings.push(binding);
+
+    binding.applyOperation({ id: "op1", type: "line_break", position: "cursor" });
+
+    expect(binding.getText()).toBe("\n");
+    expect(countNodesByType(editor.getJSON(), "hardBreak")).toBe(0);
+  });
+});