@claritylabs/cl-sdk 3.1.11 → 3.1.13

package/dist/index.mjs

@@ -10888,7 +10888,7 @@ function appendDistinctText(base, addition) {
   if (!current) return next || void 0;
   if (!next) return current;
   if (current.toLowerCase().includes(next.toLowerCase())) return current;
-  const delimiter = /(?:[/(:;-]|,\s*)$/.test(current) ? " " : " / ";
+  const delimiter = /(?:[/(:;-]|,\s*)$/.test(current) || /^[a-z]+$/i.test(next) ? " " : " / ";
   return cleanText(`${current}${delimiter}${next}`, current);
 }
 function mergedBbox(nodes) {
@@ -10917,12 +10917,65 @@ function findCellForContinuation(params) {
   }
   return params.cells[1] ?? params.cells[params.cells.length - 1];
 }
+function bboxCenterX(node) {
+  const box = node.bbox?.[0];
+  if (!box) return void 0;
+  return box.x + box.width / 2;
+}
+function findCellByVisualPosition(sourceCell, targetCells) {
+  const sourceX = bboxCenterX(sourceCell);
+  if (sourceX === void 0) return void 0;
+  const positioned = targetCells.map((cell) => ({ cell, centerX: bboxCenterX(cell) })).filter(
+    (entry) => entry.centerX !== void 0
+  );
+  if (positioned.length === 0) return void 0;
+  positioned.sort(
+    (left, right) => Math.abs(left.centerX - sourceX) - Math.abs(right.centerX - sourceX)
+  );
+  return positioned[0]?.cell;
+}
 function columnLabelStartIndex(rows) {
   const headerIndex = rows.findIndex(
     ({ row, cells }) => isSourceTreeHeaderRow(row) && cells.length > 1
   );
   return headerIndex >= 0 ? headerIndex : 0;
 }
+function startsNewVisualTableItem(cells) {
+  const firstText = tableCellText(cells[0]);
+  return /^(?:item\s+\d+\b|[A-Z][.)]\s+|coverage\s+part\b|endorsement\s+(?:no\.?|number|#|\d+)\b)/i.test(firstText);
+}
+function rowMatchesColumnLabels(cells, columnLabels) {
+  if (columnLabels.size === 0 || cells.length < columnLabels.size) return false;
+  return cells.every((cell, index) => {
+    const label = columnLabels.get(tableCellColumnIndex(cell, index));
+    return !label || tableCellText(cell).toLowerCase() === label.toLowerCase();
+  });
+}
+function implicitContinuationRows(rows, columnLabels, firstLabelRowIndex) {
+  const continuations = [];
+  let targetRowId;
+  const targetColumnLabel = columnLabels.get(1);
+  for (const [rowIndex, { row, cells }] of rows.entries()) {
+    if (rowIndex < firstLabelRowIndex) continue;
+    if (rowIndex === firstLabelRowIndex && rowMatchesColumnLabels(cells, columnLabels)) continue;
+    if (startsNewVisualTableItem(cells)) {
+      targetRowId = row.id;
+      continue;
+    }
+    if (!targetRowId || cells.length === 0) continue;
+    const isSpuriousHeader = isSourceTreeHeaderRow(row) && !rowMatchesColumnLabels(cells, columnLabels);
+    const isShortContinuation = !isSourceTreeHeaderRow(row) && cells.length < Math.max(2, columnLabels.size);
+    if (!isSpuriousHeader && !isShortContinuation) continue;
+    continuations.push({
+      sourceRowNodeId: row.id,
+      targetRowNodeId: targetRowId,
+      targetColumnIndex: 1,
+      targetColumnLabel,
+      reason: "Continuation row inferred from repaired table header."
+    });
+  }
+  return continuations;
+}
 function metadataWithColumnLabel(metadata, label) {
   const next = {
     ...metadata ?? {},
@@ -10963,8 +11016,8 @@ function applyVisualTableRepair(sourceTree, repair) {
       const normalized = normalizedRepairLabel(label.label);
       if (normalized) columnLabels.set(label.columnIndex, normalized);
     }
+    const firstLabelRowIndex = columnLabelStartIndex(rows);
     if (columnLabels.size > 0) {
-      const firstLabelRowIndex = columnLabelStartIndex(rows);
       const normalizedLabels = new Set([...columnLabels.values()].map((label) => label.toLowerCase()));
       for (const [rowIndex, { row, cells }] of rows.entries()) {
         if (removeIds.has(row.id)) continue;
@@ -11002,7 +11055,15 @@ function applyVisualTableRepair(sourceTree, repair) {
         if (cells.length > 0) rowsToRebuildText.add(row.id);
       }
     }
-    for (const continuation of tableRepair.continuationRows) {
+    const continuationRows = [
+      ...tableRepair.continuationRows,
+      ...implicitContinuationRows(rows, columnLabels, firstLabelRowIndex)
+    ];
+    const seenContinuationRows = /* @__PURE__ */ new Set();
+    for (const continuation of continuationRows) {
+      const continuationKey = `${continuation.sourceRowNodeId}:${continuation.targetRowNodeId}`;
+      if (seenContinuationRows.has(continuationKey)) continue;
+      seenContinuationRows.add(continuationKey);
       if (!rowIds.has(continuation.sourceRowNodeId) || !rowIds.has(continuation.targetRowNodeId)) continue;
       if (continuation.sourceRowNodeId === continuation.targetRowNodeId) continue;
       const sourceIndex = rowOrder.get(continuation.sourceRowNodeId);
@@ -11024,7 +11085,41 @@ function applyVisualTableRepair(sourceTree, repair) {
       });
       const sourceNodes = [sourceRow, ...sourceCells];
       const sourceSpanIds = sourceSpanIdsForNodes(sourceNodes);
-      if (targetCell) {
+      let mergedIntoCells = false;
+      if (sourceCells.length > 0 && targetCells.length > 0) {
+        for (const sourceCell of sourceCells) {
+          const cellText = tableCellValueText(sourceCell);
+          if (!cellText) continue;
+          const visualTargetCell = findCellByVisualPosition(sourceCell, targetCells) ?? targetCell;
+          if (!visualTargetCell) continue;
+          const currentTargetCell = currentNode(visualTargetCell.id) ?? visualTargetCell;
+          const nextCellText = appendDistinctText(tableCellText(currentTargetCell), cellText);
+          if (!nextCellText) continue;
+          updates.set(visualTargetCell.id, {
+            ...currentTargetCell,
+            textExcerpt: nextCellText,
+            description: cleanText(
+              [currentTargetCell.title, nextCellText].filter(Boolean).join(" | "),
+              currentTargetCell.description
+            ),
+            sourceSpanIds: [
+              .../* @__PURE__ */ new Set([
+                ...currentTargetCell.sourceSpanIds,
+                ...sourceRow.sourceSpanIds,
+                ...sourceCell.sourceSpanIds
+              ])
+            ],
+            bbox: mergedBbox([currentTargetCell, sourceCell]),
+            metadata: {
+              ...currentTargetCell.metadata ?? {},
+              visualTableRepair: "merged_continuation"
+            }
+          });
+          mergedIntoCells = true;
+        }
+        if (mergedIntoCells) rowsToRebuildText.add(targetRow.id);
+      }
+      if (!mergedIntoCells && targetCell) {
         const nextCellText = appendDistinctText(tableCellText(targetCell), sourceText);
         if (nextCellText) {
           const mergedNodes = [targetCell, ...sourceNodes];
@@ -11042,11 +11137,16 @@ function applyVisualTableRepair(sourceTree, repair) {
           rowsToRebuildText.add(targetRow.id);
         }
       }
-      const nextRowText = appendDistinctText(targetRow.textExcerpt ?? targetRow.description, sourceText);
+      const fallbackRowText = mergedIntoCells ? void 0 : appendDistinctText(targetRow.textExcerpt ?? targetRow.description, sourceText);
       updates.set(targetRow.id, {
         ...currentNode(targetRow.id) ?? targetRow,
-        textExcerpt: nextRowText,
-        description: cleanText([targetRow.title, nextRowText].filter(Boolean).join(" | "), targetRow.description),
+        ...mergedIntoCells ? {} : {
+          textExcerpt: fallbackRowText,
+          description: cleanText(
+            [targetRow.title, fallbackRowText].filter(Boolean).join(" | "),
+            targetRow.description
+          )
+        },
         sourceSpanIds: [.../* @__PURE__ */ new Set([...targetRow.sourceSpanIds, ...sourceSpanIds])],
         bbox: mergedBbox([targetRow, ...sourceNodes]),
         metadata: {