@createiq/htmldiff 1.0.5-beta.2 → 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
@@ -730,17 +830,38 @@ function pairSimilarUnmatched(alignment, threshold, similarity) {
 	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++;
@@ -748,29 +869,20 @@ 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();
 }
-/**
-* Character-level prefix+suffix similarity for a single cell's text
-* content. Same metric as rowSimilarity, scoped to one cell so we can
-* fuzzy-pair unmatched cells (e.g. a cell with a content edit alongside
-* a column add in the same row).
-*/
-function cellSimilarity(oldCell, newCell, oldHtml, newHtml) {
-	const a = cellText(oldHtml, oldCell);
-	const b = cellText(newHtml, newCell);
-	if (a === b) return 1;
-	if (a.length === 0 || b.length === 0) return 0;
-	let prefix = 0;
-	const minLen = Math.min(a.length, b.length);
-	while (prefix < minLen && a[prefix] === b[prefix]) prefix++;
-	let suffix = 0;
-	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 cellText(html, cell) {
 	return html.slice(cell.contentStart, cell.contentEnd).replace(/<[^>]+>/g, " ").replace(/\s+/g, " ").trim().toLowerCase();
 }