@adeu/core 1.10.0 → 1.11.2

package/src/mapper.ts

@@ -95,15 +95,17 @@ export function renumber_snapshot_ids(doc: DocumentObject): [Record<string, stri
 export class DocumentMapper {
   public doc: DocumentObject;
   public clean_view: boolean;
+  public original_view: boolean;
   public comments_map: Record<string, any>;
   public full_text: string = '';
   public spans: TextSpan[] = [];
   public appendix_start_index: number = -1;
   private _text_chunks: string[] = [];
 
-  constructor(doc: DocumentObject, clean_view: boolean = false) {
+  constructor(doc: DocumentObject, clean_view: boolean = false, original_view: boolean = false) {
     this.doc = doc;
     this.clean_view = clean_view;
+    this.original_view = original_view;
     this.comments_map = extract_comments_data(doc.pkg);
     this._build_map();
   }
@@ -200,16 +202,17 @@ export class DocumentMapper {
       const del_node = trPr ? findChild(trPr, 'w:del') : null;
 
       if (this.clean_view && del_node) continue;
+      if (this.original_view && ins) continue;
 
       if (rows_processed > 0) {
         this._add_virtual_text('\n', current, null);
         current += 1;
       }
 
-      if (ins && !this.clean_view) {
+      if (ins && !this.clean_view && !this.original_view) {
         this._add_virtual_text('{++ ', current, null);
         current += 4;
-      } else if (del_node && !this.clean_view) {
+      } else if (del_node && !this.clean_view && !this.original_view) {
         this._add_virtual_text('{-- ', current, null);
         current += 4;
       }
@@ -230,11 +233,11 @@ export class DocumentMapper {
         cells_processed += 1;
       }
 
-      if (ins && !this.clean_view) {
+      if (ins && !this.clean_view && !this.original_view) {
         const suffix = ` |Chg:${ins.getAttribute('w:id')}++}`;
         this._add_virtual_text(suffix, current, null);
         current += suffix.length;
-      } else if (del_node && !this.clean_view) {
+      } else if (del_node && !this.clean_view && !this.original_view) {
         const suffix = ` |Chg:${del_node.getAttribute('w:id')}--}`;
         this._add_virtual_text(suffix, current, null);
         current += suffix.length;
@@ -343,13 +346,16 @@ export class DocumentMapper {
         if (this.clean_view && Object.keys(active_del).length > 0) {
           // pass
         }
+        if (this.original_view && Object.keys(active_ins).length > 0) {
+          // pass
+        }
 
         const full_seg_text = run_parts.map(x => x[1]).join('');
         const curr_ins_id = Object.keys(active_ins).pop() || null;
         const curr_del_id = Object.keys(active_del).pop() || null;
 
-        if (full_seg_text && !(this.clean_view && curr_del_id)) {
-          const new_wrappers = this.clean_view ? ['', ''] as [string, string] : this._get_wrappers(curr_ins_id, curr_del_id, active_ids, active_fmt);
+        if (full_seg_text && !(this.clean_view && curr_del_id) && !(this.original_view && curr_ins_id)) {
+          const new_wrappers = (this.clean_view || this.original_view) ? ['', ''] as [string, string] : this._get_wrappers(curr_ins_id, curr_del_id, active_ids, active_fmt);
           const new_style: [string, string] = [prefix, suffix];
 
           if (pending_runs.length > 0 && new_wrappers[0] === current_wrappers[0] && new_wrappers[1] === current_wrappers[1]) {
@@ -379,7 +385,7 @@ export class DocumentMapper {
           }
         }
 
-        if (!this.clean_view) {
+        if (!this.clean_view && !this.original_view) {
           const has_meta = Object.keys(active_ins).length > 0 || Object.keys(active_del).length > 0 || active_ids.size > 0 || Object.keys(active_fmt).length > 0;
           if (has_meta) {
             deferred_meta_states.push([{...active_ins}, {...active_del}, new Set(active_ids), {...active_fmt}]);

package/src/outline.ts

@@ -40,12 +40,16 @@ export function extract_outline(
   projected_body: string,
   body_pages: string[],
   body_page_offsets: number[],
-  paragraph_offsets: Record<string, [number, number]> | null = null,
+  paragraph_offsets: Record<string, [number, number]> | Map<any, [number, number]> | null = null,
 ): OutlineNode[] {
   if (body_pages.length !== body_page_offsets.length) {
     throw new Error("body_pages and body_page_offsets length mismatch");
   }
 
+  if (paragraph_offsets) {
+    return _extract_outline_fast(doc, projected_body, body_page_offsets, paragraph_offsets);
+  }
+
   const comments_map = extract_comments_data(doc.pkg);
   const block_records = _walk_doc_body(doc, comments_map);
 
@@ -397,6 +401,7 @@ function _determine_heading_style(paragraph: Paragraph): string {
   }
 
   let outline_level: number | null = null;
+  let outline_level_from_style = false;
   if (pPr) {
     const oLvl = findChild(pPr, "w:outlineLvl");
     if (oLvl && /^\d+$/.test(oLvl.getAttribute("w:val") || "")) {
@@ -406,6 +411,7 @@ function _determine_heading_style(paragraph: Paragraph): string {
   
   if (outline_level === null && style_id && style_cache && style_cache[style_id]) {
     outline_level = style_cache[style_id].outline_level;
+    outline_level_from_style = true;
   }
 
   const style_name =
@@ -422,6 +428,15 @@ function _determine_heading_style(paragraph: Paragraph): string {
     }
   }
 
+  if (outline_level_from_style && outline_level !== null) {
+    const is_heading_or_title =
+      normalized_style_name &&
+      (normalized_style_name.startsWith("Heading") || normalized_style_name === "Title");
+    if (!is_heading_or_title) {
+      outline_level = null;
+    }
+  }
+
   if (outline_level !== null && outline_level >= 0 && outline_level <= 8) {
     if (normalized_style_name && (normalized_style_name.startsWith("Heading") || normalized_style_name === "Title")) {
       return normalized_style_name;
@@ -505,3 +520,183 @@ function _offset_to_page(offset: number, body_page_offsets: number[]): number {
   }
   return page;
 }
+
+function _extract_outline_fast(
+  doc: DocumentObject,
+  projected_body: string,
+  body_page_offsets: number[],
+  paragraph_offsets: Map<any, [number, number]> | Record<string, [number, number]>,
+): OutlineNode[] {
+  const paragraphs_and_tables: ["p" | "t", any][] = [];
+  const seen_cells = new Set<any>();
+
+  function walk(container: any) {
+    for (const item of iter_block_items(container)) {
+      const i_type = item.constructor.name;
+      if (i_type === "FootnoteItem") {
+        walk(item);
+      } else if (item instanceof Paragraph) {
+        paragraphs_and_tables.push(["p", item]);
+      } else if (item instanceof Table) {
+        paragraphs_and_tables.push(["t", item]);
+        for (const row of item.rows) {
+          for (const cell of row.cells) {
+            if (seen_cells.has(cell._element)) {
+              continue;
+            }
+            seen_cells.add(cell._element);
+            walk(cell);
+          }
+        }
+      }
+    }
+  }
+
+  walk(doc);
+
+  const heading_indices: number[] = [];
+  for (let idx = 0; idx < paragraphs_and_tables.length; idx++) {
+    const [kind, item] = paragraphs_and_tables[idx];
+    if (kind !== "p") continue;
+
+    let hasOffset = false;
+    if (paragraph_offsets instanceof Map) {
+      hasOffset = paragraph_offsets.has(item._element);
+    } else {
+      hasOffset = item._element in (paragraph_offsets as any);
+    }
+    if (!hasOffset) {
+      continue;
+    }
+
+    if (!_is_heading(item)) continue;
+    if (!_heading_passes_quality_filter_fast(item, projected_body, paragraph_offsets)) continue;
+
+    heading_indices.push(idx);
+  }
+
+  if (heading_indices.length === 0) return [];
+
+  const nodes: OutlineNode[] = [];
+  for (let h_pos = 0; h_pos < heading_indices.length; h_pos++) {
+    const item_idx = heading_indices[h_pos];
+    const paragraph = paragraphs_and_tables[item_idx][1] as Paragraph;
+    const level = _heading_level(paragraph);
+    const text = _heading_text_fast(paragraph, projected_body, paragraph_offsets);
+    const style = _determine_heading_style(paragraph);
+
+    // Owned range: items strictly between this heading and the next equal-or-higher heading.
+    let owned_end = item_idx;
+    for (let next_h_pos = h_pos + 1; next_h_pos < heading_indices.length; next_h_pos++) {
+      const next_idx = heading_indices[next_h_pos];
+      const next_paragraph = paragraphs_and_tables[next_idx][1] as Paragraph;
+      if (_heading_level(next_paragraph) <= level) {
+        owned_end = next_idx;
+        break;
+      }
+    }
+    if (owned_end === item_idx) {
+      owned_end = paragraphs_and_tables.length;
+    }
+
+    const owned = paragraphs_and_tables.slice(item_idx + 1, owned_end);
+
+    // has_table: nearest-claim semantics (no bubbling to ancestors).
+    let has_table = false;
+    for (const [kind2, item2] of owned) {
+      if (kind2 === "p" && _is_heading(item2)) {
+        break;
+      }
+      if (kind2 === "t") {
+        has_table = true;
+        break;
+      }
+    }
+
+    // Footnote IDs in document order, deduped.
+    const footnote_ids = _collect_footnote_ids_fast(owned);
+
+    // Page resolution from the paragraph's known offset.
+    let para_offset: [number, number] | undefined;
+    if (paragraph_offsets instanceof Map) {
+      para_offset = paragraph_offsets.get(paragraph._element);
+    } else {
+      para_offset = paragraph_offsets[paragraph._element as any];
+    }
+
+    let page_num = 1;
+    if (para_offset !== undefined) {
+      const [start_offset] = para_offset;
+      page_num = _offset_to_page(start_offset, body_page_offsets);
+    }
+
+    nodes.push({
+      level,
+      text,
+      page: page_num,
+      style,
+      has_table,
+      footnote_ids,
+    });
+  }
+
+  return nodes;
+}
+
+function _heading_passes_quality_filter_fast(
+  paragraph: Paragraph,
+  projected_body: string,
+  paragraph_offsets: Map<any, [number, number]> | Record<string, [number, number]>,
+): boolean {
+  const style = _determine_heading_style(paragraph);
+  if (style !== "(heuristic)") return true;
+
+  const text = _heading_text_fast(paragraph, projected_body, paragraph_offsets);
+  if (!text) return false;
+  const words = text.match(/\w+/g) || [];
+  return words.length >= _HEURISTIC_MIN_WORDS;
+}
+
+function _heading_text_fast(
+  paragraph: Paragraph,
+  projected_body: string,
+  paragraph_offsets: Map<any, [number, number]> | Record<string, [number, number]>,
+): string {
+  let offset: [number, number] | undefined;
+  if (paragraph_offsets instanceof Map) {
+    offset = paragraph_offsets.get(paragraph._element);
+  } else {
+    offset = paragraph_offsets[paragraph._element as any];
+  }
+
+  if (offset === undefined) {
+    return "";
+  }
+  const [start, length] = offset;
+  const raw = projected_body.substring(start, start + length);
+  let cleaned = _strip_critic_markup(raw);
+  cleaned = _strip_inline_formatting(cleaned);
+  cleaned = cleaned.replace(/^#+\s+/, "");
+  return cleaned.trim();
+}
+
+function _collect_footnote_ids_fast(owned_items: ["p" | "t", any][]): string[] {
+  const seen = new Set<string>();
+  const ordered: string[] = [];
+  for (const [kind, item] of owned_items) {
+    if (kind !== "p") continue;
+    for (const event of iter_paragraph_content(item)) {
+      if (!("type" in event)) continue;
+      let fn_id = "";
+      if (event.type === "footnote") fn_id = `fn-${event.id}`;
+      else if (event.type === "endnote") fn_id = `en-${event.id}`;
+      else continue;
+
+      if (!seen.has(fn_id)) {
+        seen.add(fn_id);
+        ordered.push(fn_id);
+      }
+    }
+  }
+  return ordered;
+}

package/src/parity_gaps.test.ts

@@ -0,0 +1,98 @@
+import { describe, it, expect } from 'vitest';
+import { createTestDocument } from './test-utils.js';
+import { RedlineEngine } from './engine.js';
+import { DocumentMapper } from './mapper.js';
+import { extract_outline } from './outline.js';
+import { _extractTextFromDoc } from './ingest.js';
+import { paginate } from './pagination.js';
+
+describe('Parity Gaps (TDD)', () => {
+  it('GAP 2: original_view maps deleted text and validate_edits throws actionable deletion error', async () => {
+    const doc = await createTestDocument();
+    const xmlDoc = doc.element.ownerDocument!;
+    
+    // Create a paragraph with a tracked deletion: <w:p><w:del w:id="1" w:author="Test Negotiator"><w:r><w:t>Deleted sentence.</w:t></w:r></w:del></w:p>
+    const p = xmlDoc.createElement('w:p');
+    const del = xmlDoc.createElement('w:del');
+    del.setAttribute('w:id', '1');
+    del.setAttribute('w:author', 'Test Negotiator');
+    
+    const r = xmlDoc.createElement('w:r');
+    const t = xmlDoc.createElement('w:t');
+    t.textContent = 'Deleted sentence.';
+    
+    r.appendChild(t);
+    del.appendChild(r);
+    p.appendChild(del);
+    doc.element.appendChild(p);
+
+    // 1. Verify original_view mapping
+    const mapperOrig = new DocumentMapper(doc, false, true);
+    expect(mapperOrig.full_text).toContain('Deleted sentence.');
+
+    const mapperRaw = new DocumentMapper(doc, false, false);
+    expect(mapperRaw.full_text).toContain('{--Deleted sentence.--}');
+
+    // 2. Validate modification targetting deleted text
+    const engine = new RedlineEngine(doc);
+    const errors = engine.validate_edits([
+      {
+        target_text: 'Deleted sentence.',
+        new_text: 'Active replacement text.',
+      }
+    ]);
+
+    expect(errors.length).toBe(1);
+    expect(errors[0]).toContain('Target text matches text inside a tracked deletion by Test Negotiator.');
+    expect(errors[0]).toContain('Reject/accept that change first or target the active replacement text instead.');
+  });
+
+  it('GAP 1: heading inside a deleted region is filtered out when using paragraph_offsets', async () => {
+    const doc = await createTestDocument();
+    const xmlDoc = doc.element.ownerDocument!;
+
+    const p1 = xmlDoc.createElement('w:p');
+    const p1Pr = xmlDoc.createElement('w:pPr');
+    const p1Style = xmlDoc.createElement('w:pStyle');
+    p1Style.setAttribute('w:val', 'Heading1');
+    p1Pr.appendChild(p1Style);
+    p1.appendChild(p1Pr);
+    const r1 = xmlDoc.createElement('w:r');
+    const t1 = xmlDoc.createElement('w:t');
+    t1.textContent = 'Active Heading';
+    r1.appendChild(t1);
+    p1.appendChild(r1);
+    doc.element.appendChild(p1);
+
+    const p2 = xmlDoc.createElement('w:p');
+    const p2Pr = xmlDoc.createElement('w:pPr');
+    const p2Style = xmlDoc.createElement('w:pStyle');
+    p2Style.setAttribute('w:val', 'Heading1');
+    p2Pr.appendChild(p2Style);
+    p2.appendChild(p2Pr);
+    const r2 = xmlDoc.createElement('w:r');
+    const t2 = xmlDoc.createElement('w:t');
+    t2.textContent = 'Deleted Heading';
+    r2.appendChild(t2);
+    p2.appendChild(r2);
+    doc.element.appendChild(p2);
+
+    const extract_res = _extractTextFromDoc(doc, false, false, true) as { text: string; paragraph_offsets: Map<any, [number, number]> };
+    
+    // Simulate deletion/skipping of p2 during projection
+    extract_res.paragraph_offsets.delete(p2);
+
+    const pages = paginate(extract_res.text, '');
+    const nodes = extract_outline(
+      doc,
+      extract_res.text,
+      pages.body_pages,
+      pages.body_page_offsets,
+      extract_res.paragraph_offsets as any,
+    );
+
+    // Only Active Heading should be in the outline, Deleted Heading must be skipped because it is not in paragraph_offsets!
+    expect(nodes.length).toBe(1);
+    expect(nodes[0].text).toBe('Active Heading');
+  });
+});