@createiq/htmldiff 1.2.0-beta.4 → 1.2.0-beta.6

package/dist/HtmlDiff.cjs

@@ -1468,8 +1468,8 @@ function preprocessByContent(genesis, cpLatest, meCurrent, gTables, cTables, mTa
 	const gKeys = gTables.map((t) => tableKey(genesis, t));
 	const cKeys = cTables.map((t) => tableKey(cpLatest, t));
 	const mKeys = mTables.map((t) => tableKey(meCurrent, t));
-	const alignCp = lcsAlign(gKeys, cKeys);
-	const alignMe = lcsAlign(gKeys, mKeys);
+	const alignCp = pairSimilarTablesThreeWay(lcsAlign(gKeys, cKeys), genesis, cpLatest, gTables, cTables);
+	const alignMe = pairSimilarTablesThreeWay(lcsAlign(gKeys, mKeys), genesis, meCurrent, gTables, mTables);
 	const gToCp = new Array(gTables.length).fill(-1);
 	const cpToG = new Array(cTables.length).fill(-1);
 	for (const a of alignCp) if (a.oldIdx !== null && a.newIdx !== null) {
@@ -1595,6 +1595,59 @@ function positionallyAligned(genesis, cpLatest, meCurrent, gTables, cTables, mTa
 function tableKey(html, table) {
 	return html.slice(table.tableStart, table.tableEnd).replace(/\s+/g, " ").trim();
 }
+/**
+* Character-level similarity above which the three-way aligner treats
+* two rows / tables as "the same logical entry, edited" rather than
+* an unrelated delete + insert. Matched to TableDiff's
+* `ROW_FUZZY_THRESHOLD` / `CELL_FUZZY_THRESHOLD` so 2-way and 3-way
+* agree on which pairings are reachable; if a row's content overlap
+* is enough to fool the 2-way diff into pairing, it should also be
+* enough for 3-way.
+*/
+const THREE_WAY_FUZZY_THRESHOLD = .5;
+/**
+* Run the same fuzzy-pairing pass `TableDiff.pairSimilarUnmatchedRows`
+* applies after its exact-LCS, but against one side of the genesis
+* spine (either cp or me). The genesis tables/rows are always the
+* "old" side; `newTable` is the cp or me table being aligned. Returns
+* the enriched alignment with additional paired entries.
+*
+* Cell-count guard: only fuzzy-pair when both rows have the same cell
+* count. Without this guard an asymmetric restructure — e.g. CP and
+* Me both added a different column — leads to ONE side fuzzy-pairing
+* its row with genesis (content overlap above threshold) while the
+* other side falls below threshold. That mismatch routes through
+* `diffTableStructural`'s "Me dropped, CP kept" (or the mirror)
+* branch, which emits CP's row as a Me-attributed deletion. In
+* cp-only mode `stripMeAttributedMarkers` then removes the row
+* entirely and CP's edit vanishes from the view — exactly the
+* content-loss case we're meant to prevent. Restricting fuzzy
+* pairing to same-shape rows preserves the common case (single cell
+* edit, identical row shape) while pushing structural mismatches
+* back to the boundary-insertion path that emits both sides
+* explicitly.
+*/
+function pairSimilarRowsThreeWay(alignment, genesis, newHtml, oldTable, newTable) {
+	const oldTexts = oldTable.rows.map((r) => rowText(genesis, r));
+	const newTexts = newTable.rows.map((r) => rowText(newHtml, r));
+	return pairSimilarUnmatched(alignment, THREE_WAY_FUZZY_THRESHOLD, (oldIdx, newIdx) => {
+		if (oldTable.rows[oldIdx].cells.length !== newTable.rows[newIdx].cells.length) return 0;
+		return textSimilarity(oldTexts[oldIdx], newTexts[newIdx]);
+	});
+}
+/**
+* Table-level counterpart: after `lcsAlign(gKeys, otherKeys)` over
+* full table HTML keys, fuzzy-pair unmatched table runs by their
+* row-text-concatenated content. Without this, a table whose body
+* was edited (but not its outer shape) fails the exact-key match
+* and the preprocessing emits whole-table del + whole-table ins
+* instead of recursing into per-cell three-way diffs.
+*/
+function pairSimilarTablesThreeWay(alignment, oldHtml, newHtml, oldTables, newTables) {
+	const oldTexts = oldTables.map((t) => t.rows.map((r) => rowText(oldHtml, r)).join(" "));
+	const newTexts = newTables.map((t) => t.rows.map((r) => rowText(newHtml, r)).join(" "));
+	return pairSimilarUnmatched(alignment, THREE_WAY_FUZZY_THRESHOLD, (oldIdx, newIdx) => textSimilarity(oldTexts[oldIdx], newTexts[newIdx]));
+}
 function diffTableThreeWay(genesis, cpLatest, meCurrent, tG, tC, tM, cellDiff) {
 	if (sameDimensions(tG, tC) && sameDimensions(tC, tM)) return diffTablePositional(genesis, cpLatest, meCurrent, tG, tC, tM, cellDiff);
 	return diffTableStructural(genesis, cpLatest, meCurrent, tG, tC, tM, cellDiff);
@@ -1637,8 +1690,8 @@ function diffTableStructural(genesis, cpLatest, meCurrent, tG, tC, tM, cellDiff)
 	const gKeys = tG.rows.map((r) => rowKey(genesis, r));
 	const cKeys = tC.rows.map((r) => rowKey(cpLatest, r));
 	const mKeys = tM.rows.map((r) => rowKey(meCurrent, r));
-	const alignCp = lcsAlign(gKeys, cKeys);
-	const alignMe = lcsAlign(gKeys, mKeys);
+	const alignCp = pairSimilarRowsThreeWay(lcsAlign(gKeys, cKeys), genesis, cpLatest, tG, tC);
+	const alignMe = pairSimilarRowsThreeWay(lcsAlign(gKeys, mKeys), genesis, meCurrent, tG, tM);
 	const gToCp = new Array(tG.rows.length).fill(-1);
 	for (const a of alignCp) if (a.oldIdx !== null && a.newIdx !== null) gToCp[a.oldIdx] = a.newIdx;
 	const gToMe = new Array(tG.rows.length).fill(-1);
@@ -2134,8 +2187,13 @@ var HtmlDiff = class HtmlDiff {
 		this.oldText = oldText;
 		this.newText = newText;
 	}
-	static execute(oldText, newText) {
-		return new HtmlDiff(oldText, newText).build();
+	static execute(oldText, newText, options = {}) {
+		const inner = new HtmlDiff(oldText, newText);
+		if (options.blockExpressions) for (const expr of options.blockExpressions) inner.addBlockExpression(expr);
+		if (options.repeatingWordsAccuracy !== void 0) inner.repeatingWordsAccuracy = options.repeatingWordsAccuracy;
+		if (options.orphanMatchThreshold !== void 0) inner.orphanMatchThreshold = options.orphanMatchThreshold;
+		if (options.ignoreWhitespaceDifferences !== void 0) inner.ignoreWhitespaceDifferences = options.ignoreWhitespaceDifferences;
+		return inner.build();
 	}
 	/**
 	* Analyse a two-way diff and return its raw building blocks: the word