@createiq/htmldiff 1.0.5-beta.1 → 1.0.5-beta.3

package/dist/HtmlDiff.cjs

@@ -447,8 +447,108 @@ function diffPreservedRow(oldHtml, newHtml, oldRow, newRow, diffCell) {
 	if (oldRow.cells.length === newRow.cells.length) return diffPositionalRow(oldHtml, newHtml, oldRow, newRow, diffCell);
 	const colspanAligned = diffColspanChangedRow(oldHtml, newHtml, oldRow, newRow, diffCell);
 	if (colspanAligned !== null) return colspanAligned;
+	const delta = newRow.cells.length - oldRow.cells.length;
+	const absDelta = Math.abs(delta);
+	if (absDelta > 0 && absDelta <= MAX_COLUMN_DELTA && Math.max(oldRow.cells.length, newRow.cells.length) <= MAX_COLUMN_SEARCH_WIDTH) {
+		if (delta > 0) return diffMultiColumnAddRow(oldHtml, newHtml, oldRow, newRow, delta, diffCell);
+		return diffMultiColumnDeleteRow(oldHtml, newHtml, oldRow, newRow, -delta, diffCell);
+	}
 	return diffStructurallyAlignedRow(oldHtml, newHtml, oldRow, newRow, diffCell);
 }
+const MAX_COLUMN_DELTA = 6;
+const MAX_COLUMN_SEARCH_WIDTH = 40;
+/**
+* For a row where new has K more cells than old, find the K column
+* positions in new where cells were inserted by scanning all C(newCount,
+* K) combinations and picking the one that maximises positional content
+* similarity with the remaining cells. The inserted cells are emitted
+* with diff markers; the rest are aligned positionally with content
+* diff for matched pairs.
+*/
+function diffMultiColumnAddRow(oldHtml, newHtml, oldRow, newRow, k, diffCell) {
+	const insertedPositions = findBestColumnInsertPositions(oldRow, newRow, k, oldHtml, newHtml);
+	const inserted = new Set(insertedPositions);
+	const out = [rowHeaderSlice(newHtml, newRow)];
+	let oldIdx = 0;
+	for (let c = 0; c < newRow.cells.length; c++) if (inserted.has(c)) out.push(emitFullCell(newHtml, newRow.cells[c], "ins", diffCell));
+	else {
+		out.push(emitDiffedCell(oldHtml, newHtml, oldRow.cells[oldIdx], newRow.cells[c], diffCell));
+		oldIdx++;
+	}
+	out.push("</tr>");
+	return out.join("");
+}
+function diffMultiColumnDeleteRow(oldHtml, newHtml, oldRow, newRow, k, diffCell) {
+	const deletedPositions = findBestColumnDeletePositions(oldRow, newRow, k, oldHtml, newHtml);
+	const deleted = new Set(deletedPositions);
+	const out = [rowHeaderSlice(newHtml, newRow)];
+	let newIdx = 0;
+	for (let oldIdx = 0; oldIdx < oldRow.cells.length; oldIdx++) {
+		if (deleted.has(oldIdx)) {
+			out.push(emitFullCell(oldHtml, oldRow.cells[oldIdx], "del", diffCell));
+			continue;
+		}
+		out.push(emitDiffedCell(oldHtml, newHtml, oldRow.cells[oldIdx], newRow.cells[newIdx], diffCell));
+		newIdx++;
+	}
+	out.push("</tr>");
+	return out.join("");
+}
+function findBestColumnInsertPositions(oldRow, newRow, k, oldHtml, newHtml) {
+	let bestPositions = [];
+	let bestScore = -1;
+	for (const combo of combinationsOfRange(newRow.cells.length, k)) {
+		const inserted = new Set(combo);
+		let score = 0;
+		let oldIdx = 0;
+		for (let newIdx = 0; newIdx < newRow.cells.length; newIdx++) {
+			if (inserted.has(newIdx)) continue;
+			score += cellSimilarity(oldRow.cells[oldIdx], newRow.cells[newIdx], oldHtml, newHtml);
+			oldIdx++;
+		}
+		if (score > bestScore) {
+			bestScore = score;
+			bestPositions = combo;
+		}
+	}
+	return bestPositions;
+}
+function findBestColumnDeletePositions(oldRow, newRow, k, oldHtml, newHtml) {
+	let bestPositions = [];
+	let bestScore = -1;
+	for (const combo of combinationsOfRange(oldRow.cells.length, k)) {
+		const deleted = new Set(combo);
+		let score = 0;
+		let newIdx = 0;
+		for (let oldIdx = 0; oldIdx < oldRow.cells.length; oldIdx++) {
+			if (deleted.has(oldIdx)) continue;
+			score += cellSimilarity(oldRow.cells[oldIdx], newRow.cells[newIdx], oldHtml, newHtml);
+			newIdx++;
+		}
+		if (score > bestScore) {
+			bestScore = score;
+			bestPositions = combo;
+		}
+	}
+	return bestPositions;
+}
+/**
+* Yields all sorted-ascending combinations of `k` distinct integers
+* from [0, n). Iterative implementation avoids recursion overhead and
+* keeps memory at O(k).
+*/
+function* combinationsOfRange(n, k) {
+	if (k === 0 || k > n) return;
+	const indices = Array.from({ length: k }, (_, i) => i);
+	while (true) {
+		yield indices.slice();
+		let i = k - 1;
+		while (i >= 0 && indices[i] === n - k + i) i--;
+		if (i < 0) return;
+		indices[i]++;
+		for (let j = i + 1; j < k; j++) indices[j] = indices[j - 1] + 1;
+	}
+}
 /**
 * Try to align cells by logical column position (sum of colspans). When
 * one side has a colspan'd cell that absorbs multiple cells on the other
@@ -544,7 +644,7 @@ function diffPositionalRow(oldHtml, newHtml, oldRow, newRow, diffCell) {
 	return out.join("");
 }
 function diffStructurallyAlignedRow(oldHtml, newHtml, oldRow, newRow, diffCell) {
-	const alignment = lcsAlign(oldRow.cells.map((cell) => cellKey(oldHtml, cell)), newRow.cells.map((cell) => cellKey(newHtml, cell)));
+	const alignment = pairSimilarUnmatchedCells(lcsAlign(oldRow.cells.map((cell) => cellKey(oldHtml, cell)), newRow.cells.map((cell) => cellKey(newHtml, cell))), oldRow, newRow, oldHtml, newHtml);
 	const out = [];
 	out.push(rowHeaderSlice(newHtml, newRow));
 	for (const align of alignment) if (align.oldIdx !== null && align.newIdx !== null) {
@@ -643,9 +743,16 @@ function rowHeaderSlice(html, row) {
 	if (row.cells.length === 0) return html.slice(row.rowStart, opening.end);
 	return html.slice(row.rowStart, row.cells[0].cellStart);
 }
-/** Jaccard similarity threshold above which we treat two rows as "the same row, edited". */
+/** Character-level similarity threshold above which we treat two rows as "the same row, edited". */
 const ROW_FUZZY_THRESHOLD = .5;
 /**
+* Threshold for "this cell is a content-edit of that cell." Tuned the same
+* as ROW_FUZZY_THRESHOLD; cells in legal docs that share most of their
+* content typically ARE the same logical cell with a body edit, so 0.5
+* works for both granularities in practice.
+*/
+const CELL_FUZZY_THRESHOLD = .5;
+/**
 * After exact LCS, scan the alignment for runs of "old deleted, then new
 * inserted" (or vice versa) and pair entries whose content is similar
 * enough to be treated as an edit rather than a delete+insert. This keeps
@@ -654,6 +761,26 @@ const ROW_FUZZY_THRESHOLD = .5;
 * expect from a typical track-changes view.
 */
 function pairSimilarUnmatchedRows(alignment, oldTable, newTable, oldHtml, newHtml) {
+	return pairSimilarUnmatched(alignment, ROW_FUZZY_THRESHOLD, (oldIdx, newIdx) => rowSimilarity(oldTable.rows[oldIdx], newTable.rows[newIdx], oldHtml, newHtml));
+}
+function pairSimilarUnmatchedCells(alignment, oldRow, newRow, oldHtml, newHtml) {
+	return pairSimilarUnmatched(alignment, CELL_FUZZY_THRESHOLD, (oldIdx, newIdx) => cellSimilarity(oldRow.cells[oldIdx], newRow.cells[newIdx], oldHtml, newHtml));
+}
+/**
+* Identify pairings inside each unmatched-only run, then build the output
+* alignment by walking the original and substituting paired entries at
+* the *ins position* (not the del position). This keeps the result
+* monotonic in newIdx — critical because the cursor-based emission
+* downstream walks new's html in order. Emitting at the del position
+* would be fine when del<ins in the alignment array (the typical case),
+* but can violate monotonicity when there are mixed unpaired entries in
+* between (column-add + row-add together, content-edit + column-add,
+* etc.).
+*
+* Generic over what's being paired — works for both rows (by full row
+* content similarity) and cells (by per-cell content similarity).
+*/
+function pairSimilarUnmatched(alignment, threshold, similarity) {
 	const pairs = /* @__PURE__ */ new Map();
 	let i = 0;
 	while (i < alignment.length) {
@@ -671,10 +798,10 @@ function pairSimilarUnmatchedRows(alignment, oldTable, newTable, oldHtml, newHtm
 		const usedIns = /* @__PURE__ */ new Set();
 		for (const di of delIndices) {
 			let bestIi = -1;
-			let bestSim = ROW_FUZZY_THRESHOLD;
+			let bestSim = threshold;
 			for (const ii of insIndices) {
 				if (usedIns.has(ii)) continue;
-				const sim = rowSimilarity(oldTable.rows[alignment[di].oldIdx], newTable.rows[alignment[ii].newIdx], oldHtml, newHtml);
+				const sim = similarity(alignment[di].oldIdx, alignment[ii].newIdx);
 				if (sim > bestSim) {
 					bestSim = sim;
 					bestIi = ii;
@@ -703,17 +830,38 @@ function pairSimilarUnmatchedRows(alignment, oldTable, newTable, oldHtml, newHtm
 	return result;
 }
 /**
-* Character-level similarity using shared prefix + suffix as a fraction
-* of the longer string. Catches "single edit somewhere in a long row"
-* (which token-Jaccard misses on short rows) while still correctly
-* rejecting rows with no positional overlap. HTML tags are stripped to
-* keep the comparison content-focused.
+* Combined similarity metric used for both row-level and cell-level
+* fuzzy pairing. Returns the MAX of two complementary metrics:
+*
+*   1. **Character prefix+suffix similarity** — fraction of the longer
+*      string covered by shared prefix + shared suffix. Catches small
+*      edits in the middle of a string (one word changed in a row).
+*      Misses cases where the bulk of common content is in the middle
+*      and the ends differ.
+*
+*   2. **Token Jaccard similarity** — intersection-over-union of the
+*      whitespace-split tokens. Catches "most of the content is the
+*      same but bookended by different bits" — e.g. a row whose only
+*      edit is a column added at the start and another at the end,
+*      where the ~50 chars in the middle that DO match would be
+*      invisible to prefix+suffix.
+*
+* Either metric exceeding the threshold means pair. Neither alone is
+* sufficient for the full range of legal-doc edits we see in
+* production tables.
 */
 function rowSimilarity(oldRow, newRow, oldHtml, newHtml) {
-	const a = rowText(oldHtml, oldRow);
-	const b = rowText(newHtml, newRow);
+	return textSimilarity(rowText(oldHtml, oldRow), rowText(newHtml, newRow));
+}
+function cellSimilarity(oldCell, newCell, oldHtml, newHtml) {
+	return textSimilarity(cellText(oldHtml, oldCell), cellText(newHtml, newCell));
+}
+function textSimilarity(a, b) {
 	if (a === b) return 1;
 	if (a.length === 0 || b.length === 0) return 0;
+	return Math.max(charPrefixSuffixSimilarity(a, b), tokenJaccardSimilarity(a, b));
+}
+function charPrefixSuffixSimilarity(a, b) {
 	let prefix = 0;
 	const minLen = Math.min(a.length, b.length);
 	while (prefix < minLen && a[prefix] === b[prefix]) prefix++;
@@ -721,11 +869,23 @@ function rowSimilarity(oldRow, newRow, oldHtml, newHtml) {
 	while (suffix < a.length - prefix && suffix < b.length - prefix && a[a.length - 1 - suffix] === b[b.length - 1 - suffix]) suffix++;
 	return (prefix + suffix) / Math.max(a.length, b.length);
 }
+function tokenJaccardSimilarity(a, b) {
+	const tokensA = new Set(a.split(/\s+/).filter(Boolean));
+	const tokensB = new Set(b.split(/\s+/).filter(Boolean));
+	if (tokensA.size === 0 && tokensB.size === 0) return 1;
+	let intersection = 0;
+	for (const t of tokensA) if (tokensB.has(t)) intersection++;
+	const union = tokensA.size + tokensB.size - intersection;
+	return union === 0 ? 0 : intersection / union;
+}
 function rowText(html, row) {
 	const parts = [];
 	for (const cell of row.cells) parts.push(html.slice(cell.contentStart, cell.contentEnd).replace(/<[^>]+>/g, " "));
 	return parts.join(" ").replace(/\s+/g, " ").trim().toLowerCase();
 }
+function cellText(html, cell) {
+	return html.slice(cell.contentStart, cell.contentEnd).replace(/<[^>]+>/g, " ").replace(/\s+/g, " ").trim().toLowerCase();
+}
 /**
 * Standard LCS alignment: walks both sequences and emits a list of pairs
 * where `(oldIdx, newIdx)` are both set for matching positions, and one