@createiq/htmldiff 1.2.0-beta.3 → 1.2.0-beta.5

package/dist/HtmlDiff.d.cts

@@ -202,22 +202,6 @@ declare class HtmlDiff {
    * why symmetry matters.
    */
   static evaluateProjectionApplicability(oldText: string, newText: string): boolean;
-  /**
-   * Three-way HTML diff. Given V1 (the version Me last sent), V2 (the
-   * version CP sent back), and V3 (Me's current draft), produces a
-   * single attributed HTML output where CP's and Me's changes are
-   * distinguished by `data-author` ('cp' or 'me') and matching
-   * `class='diffins cp'` / `class='diffdel me'` etc. The "Me rejected
-   * CP's proposal" case (Me deleted text CP had inserted) gets a
-   * dedicated marker: `data-rejects='cp'` plus `class='... rejects-cp'`.
-   *
-   * Coordinates the symmetric-projection decision (D1) across both
-   * internal `analyze` calls so V2 tokenises identically on each side
-   * of the spine. When `useProjections` is left undefined, the decision
-   * is the conjunction of both pair-wise heuristics — project iff both
-   * pairs would project on their own. Pass an explicit boolean to
-   * override.
-   */
   /**
    * Three-way HTML diff against a shared genesis. Produces attributed
    * HTML that distinguishes CP's accumulated changes (genesis → cpLatest)
@@ -245,6 +229,17 @@ declare class HtmlDiff {
    * buffer. Reusing the instance keeps the formatting-tag stack
    * (`specialTagDiffStack`) coherent across segments — a `<strong>`
    * opened in one segment and closed in another stays balanced.
+   *
+   * Edge case: an ins/del segment can open a formatting wrap whose
+   * matching closer ends up in an equal segment (`<strong>` deleted
+   * by CP but `</strong>` kept by both — buildSegments emits the open
+   * as del-cp and the close as equal). Equal segments bypass
+   * `insertTag` and push raw, so the stack entry for the open is
+   * never popped. Rather than throw — which forces the caller's UI
+   * into an error boundary — close every leftover wrap with `</ins>`
+   * at the end of emission. The resulting HTML has an extra
+   * `</ins>` next to the formatting closer; DOMParser-normalisation
+   * downstream produces sensible nesting.
    */
   private static emitSegments;
   /**

package/dist/HtmlDiff.d.mts

@@ -202,22 +202,6 @@ declare class HtmlDiff {
    * why symmetry matters.
    */
   static evaluateProjectionApplicability(oldText: string, newText: string): boolean;
-  /**
-   * Three-way HTML diff. Given V1 (the version Me last sent), V2 (the
-   * version CP sent back), and V3 (Me's current draft), produces a
-   * single attributed HTML output where CP's and Me's changes are
-   * distinguished by `data-author` ('cp' or 'me') and matching
-   * `class='diffins cp'` / `class='diffdel me'` etc. The "Me rejected
-   * CP's proposal" case (Me deleted text CP had inserted) gets a
-   * dedicated marker: `data-rejects='cp'` plus `class='... rejects-cp'`.
-   *
-   * Coordinates the symmetric-projection decision (D1) across both
-   * internal `analyze` calls so V2 tokenises identically on each side
-   * of the spine. When `useProjections` is left undefined, the decision
-   * is the conjunction of both pair-wise heuristics — project iff both
-   * pairs would project on their own. Pass an explicit boolean to
-   * override.
-   */
   /**
    * Three-way HTML diff against a shared genesis. Produces attributed
    * HTML that distinguishes CP's accumulated changes (genesis → cpLatest)
@@ -245,6 +229,17 @@ declare class HtmlDiff {
    * buffer. Reusing the instance keeps the formatting-tag stack
    * (`specialTagDiffStack`) coherent across segments — a `<strong>`
    * opened in one segment and closed in another stays balanced.
+   *
+   * Edge case: an ins/del segment can open a formatting wrap whose
+   * matching closer ends up in an equal segment (`<strong>` deleted
+   * by CP but `</strong>` kept by both — buildSegments emits the open
+   * as del-cp and the close as equal). Equal segments bypass
+   * `insertTag` and push raw, so the stack entry for the open is
+   * never popped. Rather than throw — which forces the caller's UI
+   * into an error boundary — close every leftover wrap with `</ins>`
+   * at the end of emission. The resulting HTML has an extra
+   * `</ins>` next to the formatting closer; DOMParser-normalisation
+   * downstream produces sensible nesting.
    */
   private static emitSegments;
   /**

package/dist/HtmlDiff.mjs

@@ -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);
@@ -1695,7 +1748,20 @@ function emitPreservedRow(genesis, cpLatest, meCurrent, rG, rC, rM, cellDiff) {
 		out.push(genesis.slice(cursor, rG.rowEnd));
 		return out.join("");
 	}
-	return emitFullRowAttributed(genesis, rG, "del", "me") + emitFullRowAttributed(meCurrent, rM, "ins", "me");
+	const cpRestructured = rC.cells.length !== rG.cells.length;
+	const meRestructured = rM.cells.length !== rG.cells.length;
+	const blocks = [];
+	if (cpRestructured && meRestructured) {
+		blocks.push(emitFullRowAttributed(cpLatest, rC, "ins", "cp"));
+		blocks.push(emitFullRowAttributed(meCurrent, rM, "ins", "me"));
+	} else if (cpRestructured) {
+		blocks.push(emitFullRowAttributed(genesis, rG, "del", "cp"));
+		blocks.push(emitFullRowAttributed(cpLatest, rC, "ins", "cp"));
+	} else {
+		blocks.push(emitFullRowAttributed(genesis, rG, "del", "me"));
+		blocks.push(emitFullRowAttributed(meCurrent, rM, "ins", "me"));
+	}
+	return blocks.join("");
 }
 /**
 * Returns map "genesis-row-boundary → list of new-side row indices
@@ -2191,22 +2257,6 @@ var HtmlDiff = class HtmlDiff {
 		return HtmlDiff.shouldUseContentProjections(oldWords, newWords, oldProj, newProj);
 	}
 	/**
-	* Three-way HTML diff. Given V1 (the version Me last sent), V2 (the
-	* version CP sent back), and V3 (Me's current draft), produces a
-	* single attributed HTML output where CP's and Me's changes are
-	* distinguished by `data-author` ('cp' or 'me') and matching
-	* `class='diffins cp'` / `class='diffdel me'` etc. The "Me rejected
-	* CP's proposal" case (Me deleted text CP had inserted) gets a
-	* dedicated marker: `data-rejects='cp'` plus `class='... rejects-cp'`.
-	*
-	* Coordinates the symmetric-projection decision (D1) across both
-	* internal `analyze` calls so V2 tokenises identically on each side
-	* of the spine. When `useProjections` is left undefined, the decision
-	* is the conjunction of both pair-wise heuristics — project iff both
-	* pairs would project on their own. Pass an explicit boolean to
-	* override.
-	*/
-	/**
 	* Three-way HTML diff against a shared genesis. Produces attributed
 	* HTML that distinguishes CP's accumulated changes (genesis → cpLatest)
 	* from Me's accumulated changes (genesis → meCurrent). Use this for
@@ -2253,6 +2303,17 @@ var HtmlDiff = class HtmlDiff {
 	* buffer. Reusing the instance keeps the formatting-tag stack
 	* (`specialTagDiffStack`) coherent across segments — a `<strong>`
 	* opened in one segment and closed in another stays balanced.
+	*
+	* Edge case: an ins/del segment can open a formatting wrap whose
+	* matching closer ends up in an equal segment (`<strong>` deleted
+	* by CP but `</strong>` kept by both — buildSegments emits the open
+	* as del-cp and the close as equal). Equal segments bypass
+	* `insertTag` and push raw, so the stack entry for the open is
+	* never popped. Rather than throw — which forces the caller's UI
+	* into an error boundary — close every leftover wrap with `</ins>`
+	* at the end of emission. The resulting HTML has an extra
+	* `</ins>` next to the formatting closer; DOMParser-normalisation
+	* downstream produces sensible nesting.
 	*/
 	static emitSegments(segments) {
 		const emitter = new HtmlDiff("", "");
@@ -2264,7 +2325,13 @@ var HtmlDiff = class HtmlDiff {
 			const { tag, baseClass, metadata } = segmentEmissionShape(seg.attr);
 			emitter.insertTag(tag, baseClass, [...seg.words], metadata);
 		}
-		if (emitter.specialTagDiffStack.length > 0) throw new Error(`HtmlDiff.executeThreeWay: emission left ${emitter.specialTagDiffStack.length} unclosed formatting tag(s) on the stack — input may have unbalanced <strong>/<em>/etc. or there is a bug in segment emission.`);
+		if (emitter.specialTagDiffStack.length > 0) {
+			console.warn(`HtmlDiff.executeThreeWay: emission left ${emitter.specialTagDiffStack.length} unclosed formatting wrap(s) on the stack. Closing defensively. This usually means a formatting tag opens in a del/ins segment and its matching closer is in an equal segment.`);
+			while (emitter.specialTagDiffStack.length > 0) {
+				emitter.content.push("</ins>");
+				emitter.specialTagDiffStack.pop();
+			}
+		}
 		return emitter.content.join("");
 	}
 	/**