@adeu/core 1.6.2

package/src/engine.batch.test.ts

@@ -0,0 +1,93 @@
+import { describe, it, expect } from 'vitest';
+import { createTestDocument, addParagraph } from './test-utils.js';
+import { DocumentObject } from './docx/bridge.js';
+import { extractTextFromBuffer } from './ingest.js';
+import { RedlineEngine } from './engine.js';
+import { ModifyText, AcceptChange, RejectChange } from './models.js';
+
+describe('Batch Reliability (Node.js Port)', () => {
+  it('batch accept does not corrupt the document', async () => {
+    const doc = await createTestDocument();
+    addParagraph(doc, "Para 1");
+    addParagraph(doc, "Para 2");
+    addParagraph(doc, "Para 3");
+
+    const engine = new RedlineEngine(doc);
+    const edits: ModifyText[] = [
+      { type: 'modify', target_text: "Para 1", new_text: "Para One" },
+      { type: 'modify', target_text: "Para 2", new_text: "Para Two" },
+      { type: 'modify', target_text: "Para 3", new_text: "Para Three" },
+    ];
+
+    engine.apply_edits(edits);
+    const redlinedBuf = await doc.save();
+
+    const text = await extractTextFromBuffer(redlinedBuf);
+    expect(text).toContain("[Chg:1 ");
+    expect(text).toContain("[Chg:6 ");
+
+    // BATCH ACCEPT ALL
+    const midDoc = await DocumentObject.load(redlinedBuf);
+    const engine2 = new RedlineEngine(midDoc);
+    
+    const actions: AcceptChange[] = [1, 2, 3, 4, 5, 6].map(id => ({ type: 'accept', target_id: `Chg:${id}` }));
+    
+    // Test direct apply_review_actions (Note: method missing in raw TS port right now, needs implementing)
+    const [applied, skipped] = (engine2 as any).apply_review_actions(actions);
+    
+    expect(applied).toBe(6);
+    expect(skipped).toBe(0);
+
+    const finalBuf = await midDoc.save();
+    const final_text = await extractTextFromBuffer(finalBuf);
+
+    expect(final_text).toContain("Para One");
+    expect(final_text).toContain("Para Two");
+    expect(final_text).toContain("Para Three");
+
+    expect(final_text).not.toContain("Para 1");
+    expect(final_text).not.toContain("Para 2");
+    expect(final_text).not.toContain("Para 3");
+
+    expect(final_text).not.toContain("[Chg:");
+    expect(final_text).not.toContain("{++");
+    expect(final_text).not.toContain("{--");
+  });
+
+  it('batch mixed accept and reject maintains integrity', async () => {
+    const doc = await createTestDocument();
+    addParagraph(doc, "Para 1");
+    addParagraph(doc, "Para 2");
+
+    const engine = new RedlineEngine(doc);
+    const edits: ModifyText[] = [
+      { type: 'modify', target_text: "Para 1", new_text: "Para One" },
+      { type: 'modify', target_text: "Para 2", new_text: "Para Two" },
+    ];
+
+    engine.apply_edits(edits);
+    const redlinedBuf = await doc.save();
+
+    const midDoc = await DocumentObject.load(redlinedBuf);
+    const engine2 = new RedlineEngine(midDoc);
+
+    const actions = [
+      { type: 'accept', target_id: "Chg:3" } as AcceptChange,
+      { type: 'accept', target_id: "Chg:4" } as AcceptChange,
+      { type: 'reject', target_id: "Chg:1" } as RejectChange,
+      { type: 'reject', target_id: "Chg:2" } as RejectChange,
+    ];
+
+    const [applied] = (engine2 as any).apply_review_actions(actions);
+    expect(applied).toBe(4);
+
+    const finalBuf = await midDoc.save();
+    const text_final = await extractTextFromBuffer(finalBuf);
+
+    expect(text_final).toContain("Para One");
+    expect(text_final).not.toContain("Para 1");
+
+    expect(text_final).toContain("Para 2");
+    expect(text_final).not.toContain("Para Two");
+  });
+});

package/src/engine.safety.test.ts

@@ -0,0 +1,42 @@
+import { describe, it, expect } from 'vitest';
+import { createTestDocument, addParagraph } from './test-utils.js';
+import { RedlineEngine } from './engine.js';
+import { ModifyText } from './models.js';
+
+describe('Safety Engine Constraints (Node.js Port)', () => {
+  it('rejects empty target heuristic to prevent accidental insertions', async () => {
+    const doc = await createTestDocument();
+    addParagraph(doc, "Content");
+
+    const engine = new RedlineEngine(doc);
+    const edit: ModifyText = { type: 'modify', target_text: "", new_text: "Unexpected Header" };
+
+    const [applied, skipped] = engine.apply_edits([edit]);
+
+    expect(applied).toBe(0);
+    expect(skipped).toBe(1);
+
+    const xml = (doc.element as Element).ownerDocument?.documentElement.toString();
+    expect(xml).not.toContain("Unexpected Header");
+  });
+
+  it('applies heuristic edits strictly once for multiple occurrences', async () => {
+    const doc = await createTestDocument();
+    addParagraph(doc, "Repeat");
+    addParagraph(doc, "Repeat");
+
+    const engine = new RedlineEngine(doc);
+    const edit: ModifyText = { type: 'modify', target_text: "Repeat", new_text: "Changed" };
+
+    const [applied, skipped] = engine.apply_edits([edit]);
+
+    expect(applied).toBe(1);
+    expect(skipped).toBe(0);
+
+    const xml = (doc.element as Element).ownerDocument?.documentElement.toString();
+    
+    // We expect one deletion of Repeat and one insertion of Changed
+    expect((xml?.match(/<w:delText[^>]*>Repeat<\/w:delText>/g) || []).length).toBe(1);
+    expect((xml?.match(/<w:t[^>]*>Changed<\/w:t>/g) || []).length).toBe(1);
+  });
+});

package/src/engine.tables.test.ts

@@ -0,0 +1,166 @@
+import { describe, it, expect } from 'vitest';
+import { createTestDocument, addParagraph, addTable, setCellText, mergeCells, addNestedTable } from './test-utils.js';
+import { DocumentObject } from './docx/bridge.js';
+import { extractTextFromBuffer } from './ingest.js';
+import { RedlineEngine } from './engine.js';
+import { ModifyText, InsertTableRow, DeleteTableRow, RejectChange } from './models.js';
+
+describe('Table Interop & Engine (Node.js Port)', () => {
+  it('interleaved tables and text remain ordered', async () => {
+    const doc = await createTestDocument();
+    addParagraph(doc, "Section 1");
+    const tbl = addTable(doc, 1, 1);
+    setCellText(tbl, 0, 0, "TableContent");
+    addParagraph(doc, "Section 2");
+
+    const buf = await doc.save();
+    const text = await extractTextFromBuffer(buf);
+
+    expect(text).toContain("Section 1");
+    expect(text).toContain("TableContent");
+    expect(text).toContain("Section 2");
+
+    const p1 = text.indexOf("Section 1");
+    const tIdx = text.indexOf("TableContent");
+    const p2 = text.indexOf("Section 2");
+
+    expect(p1).toBeLessThan(tIdx);
+    expect(tIdx).toBeLessThan(p2);
+  });
+
+  it('extracts and edits nested tables correctly', async () => {
+    const doc = await createTestDocument();
+    const outerTbl = addTable(doc, 1, 1);
+    
+    const rows = Array.from(outerTbl.childNodes).filter(n => (n as Element).tagName === 'w:tr') as Element[];
+    const cells = Array.from(rows[0].childNodes).filter(n => (n as Element).tagName === 'w:tc') as Element[];
+    
+    const nestedTbl = addNestedTable(cells[0], 1, 1);
+    setCellText(nestedTbl, 0, 0, "InnerSecret");
+
+    const buf = await doc.save();
+    const text = await extractTextFromBuffer(buf);
+    expect(text).toContain("InnerSecret");
+
+    const midDoc = await DocumentObject.load(buf);
+    const engine = new RedlineEngine(midDoc);
+    const [applied] = engine.apply_edits([{ type: 'modify', target_text: "InnerSecret", new_text: "OuterSecret" } as ModifyText]);
+    expect(applied).toBe(1);
+
+    const finalBuf = await midDoc.save();
+    const final_text = await extractTextFromBuffer(finalBuf);
+    expect(final_text).toContain("{--InnerSecret--}{++OuterSecret++}");
+  });
+
+  it('merged cells do not duplicate content extraction', async () => {
+    const doc = await createTestDocument();
+    const tbl = addTable(doc, 1, 2);
+    setCellText(tbl, 0, 0, "MergedUnique");
+    
+    // Simulate python-docx's cell.merge(cell)
+    mergeCells(tbl, 0, 0, 1);
+
+    const buf = await doc.save();
+    const text = await extractTextFromBuffer(buf);
+
+    const count = (text.match(/MergedUnique/g) || []).length;
+    expect(count).toBe(1);
+
+    const midDoc = await DocumentObject.load(buf);
+    const engine = new RedlineEngine(midDoc);
+    const [applied] = engine.apply_edits([{ type: 'modify', target_text: "MergedUnique", new_text: "ChangedUnique" } as ModifyText]);
+    expect(applied).toBe(1);
+  });
+
+  it('empty row mapping alignment stays synchronized', async () => {
+    const doc = await createTestDocument();
+    const tbl = addTable(doc, 3, 1);
+    setCellText(tbl, 0, 0, "RowA");
+    setCellText(tbl, 1, 0, ""); // Empty
+    setCellText(tbl, 2, 0, "RowB");
+
+    const buf = await doc.save();
+    const midDoc = await DocumentObject.load(buf);
+    
+    const engine = new RedlineEngine(midDoc);
+    const [applied] = engine.apply_edits([{ type: 'modify', target_text: "RowB", new_text: "RowC" } as ModifyText]);
+    
+    expect(applied).toBe(1);
+
+    const resBuf = await midDoc.save();
+    const resText = await extractTextFromBuffer(resBuf);
+
+    expect(resText).toContain("RowA");
+    expect(resText).toContain("{--RowB--}{++RowC++}");
+  });
+
+  it('inserts table row below', async () => {
+    const doc = await createTestDocument();
+    const tbl = addTable(doc, 2, 2);
+    setCellText(tbl, 0, 0, "A1"); setCellText(tbl, 0, 1, "A2");
+    setCellText(tbl, 1, 0, "B1"); setCellText(tbl, 1, 1, "B2");
+
+    const buf = await doc.save();
+    const midDoc = await DocumentObject.load(buf);
+
+    const engine = new RedlineEngine(midDoc);
+    const stats = engine.process_batch([
+      { type: 'insert_row', target_text: "A1 | A2", position: "below", cells: ["New B1", "New B2"] } as InsertTableRow
+    ]);
+
+    expect(stats.edits_applied).toBe(1);
+
+    // Call accept_all_revisions (requires implementation in engine.ts)
+    (engine as any).accept_all_revisions();
+    const finalBuf = await midDoc.save();
+    const clean_text = await extractTextFromBuffer(finalBuf, true);
+
+    expect(clean_text).toContain("A1 | A2");
+    expect(clean_text).toContain("New B1 | New B2");
+    expect(clean_text).toContain("B1 | B2");
+  });
+
+  it('deletes table row', async () => {
+    const doc = await createTestDocument();
+    const tbl = addTable(doc, 3, 2);
+    setCellText(tbl, 0, 0, "A1"); setCellText(tbl, 0, 1, "A2");
+    setCellText(tbl, 1, 0, "B1"); setCellText(tbl, 1, 1, "B2");
+    setCellText(tbl, 2, 0, "C1"); setCellText(tbl, 2, 1, "C2");
+
+    const buf = await doc.save();
+    const midDoc = await DocumentObject.load(buf);
+
+    const engine = new RedlineEngine(midDoc);
+    const stats = engine.process_batch([{ type: 'delete_row', target_text: "B1" } as DeleteTableRow]);
+
+    expect(stats.edits_applied).toBe(1);
+
+    (engine as any).accept_all_revisions();
+    const finalBuf = await midDoc.save();
+    const clean_text = await extractTextFromBuffer(finalBuf, true);
+
+    expect(clean_text).toContain("A1 | A2");
+    expect(clean_text).not.toContain("B1 | B2");
+    expect(clean_text).toContain("C1 | C2");
+  });
+
+  it('clean view naturally omits deleted row', async () => {
+    const doc = await createTestDocument();
+    const tbl = addTable(doc, 2, 2);
+    setCellText(tbl, 0, 0, "A1"); setCellText(tbl, 0, 1, "A2");
+    setCellText(tbl, 1, 0, "B1"); setCellText(tbl, 1, 1, "B2");
+
+    const buf = await doc.save();
+    const midDoc = await DocumentObject.load(buf);
+
+    const engine = new RedlineEngine(midDoc);
+    engine.process_batch([{ type: 'delete_row', target_text: "B1" } as DeleteTableRow]);
+
+    // Do NOT accept revisions, extract as Clean View directly
+    const finalBuf = await midDoc.save();
+    const clean_text = await extractTextFromBuffer(finalBuf, true);
+
+    expect(clean_text).toContain("A1 | A2");
+    expect(clean_text).not.toContain("B1 | B2");
+  });
+});