@createiq/htmldiff 1.0.5-beta.3 → 1.1.0-beta.0

package/dist/HtmlDiff.cjs

@@ -411,7 +411,7 @@ function diffPositionalTable(oldHtml, newHtml, oldTable, newTable, diffCell) {
 * sides.
 */
 function diffStructurallyAlignedTable(oldHtml, newHtml, oldTable, newTable, diffCell) {
-	const alignment = pairSimilarUnmatchedRows(lcsAlign(oldTable.rows.map((row) => rowKey(oldHtml, row)), newTable.rows.map((row) => rowKey(newHtml, row))), oldTable, newTable, oldHtml, newHtml);
+	const alignment = orderAlignmentForEmission(pairSimilarUnmatchedRows(lcsAlign(oldTable.rows.map((row) => rowKey(oldHtml, row)), newTable.rows.map((row) => rowKey(newHtml, row))), oldTable, newTable, oldHtml, newHtml));
 	if (newTable.rows.length === 0) return rebuildStructurallyAlignedTable(oldHtml, newHtml, oldTable, newTable, alignment, diffCell);
 	const out = [];
 	out.push(newHtml.slice(newTable.tableStart, newTable.rows[0].rowStart));
@@ -426,6 +426,72 @@ function diffStructurallyAlignedTable(oldHtml, newHtml, oldTable, newTable, diff
 	out.push(newHtml.slice(cursor, newTable.tableEnd));
 	return out.join("");
 }
+/**
+* Reorders the alignment so emission produces rows in the visually-
+* correct order. Each entry is assigned a fractional "position" in
+* new's flow:
+*
+*   • Preserved/paired (oldIdx, newIdx): position = newIdx.
+*   • Pure insert (null, newIdx): position = newIdx.
+*   • Pure delete (oldIdx, null): position = newIdx-of-preserved-just-
+*     before-this-oldIdx + 0.5. Dels at the same gap sort by oldIdx so
+*     they appear in old's row order. The +0.5 places dels BEFORE any
+*     insert at the same gap (insert at newIdx N1+1 has position N1+1
+*     which is > N1+0.5), giving the natural "delete first, insert
+*     second" reading order at a replaced position.
+*
+* This handles the full range:
+*   • Run of unpaired dels at the start (no preserved predecessor):
+*     position -0.5, sorted by oldIdx.
+*   • Dels in the middle: positioned right after their preceding
+*     preserved row.
+*   • Dels at the end (no preserved successor): positioned after the
+*     last preserved row.
+*
+* Without this reordering, a run of unpaired deletes at low alignment
+* indices got emitted at cursor = first-new-row position — putting
+* all deletes before any preserved row in the output, regardless of
+* where they came from in old.
+*/
+function orderAlignmentForEmission(alignment) {
+	const preserved = [];
+	for (const a of alignment) if (a.oldIdx !== null && a.newIdx !== null) preserved.push({
+		oldIdx: a.oldIdx,
+		newIdx: a.newIdx
+	});
+	preserved.sort((a, b) => a.oldIdx - b.oldIdx);
+	function newIdxOfPreservedBefore(oldIdx) {
+		let result = -1;
+		for (const p of preserved) {
+			if (p.oldIdx >= oldIdx) break;
+			result = p.newIdx;
+		}
+		return result;
+	}
+	const decorated = alignment.map((a, i) => {
+		let primary;
+		let secondary;
+		if (a.newIdx !== null) {
+			primary = a.newIdx;
+			secondary = a.oldIdx === null ? 1 : 0;
+		} else {
+			primary = newIdxOfPreservedBefore(a.oldIdx) + .5;
+			secondary = a.oldIdx;
+		}
+		return {
+			entry: a,
+			primary,
+			secondary,
+			originalIdx: i
+		};
+	});
+	decorated.sort((a, b) => {
+		if (a.primary !== b.primary) return a.primary - b.primary;
+		if (a.secondary !== b.secondary) return a.secondary - b.secondary;
+		return a.originalIdx - b.originalIdx;
+	});
+	return decorated.map((d) => d.entry);
+}
 function rebuildStructurallyAlignedTable(oldHtml, newHtml, oldTable, newTable, alignment, diffCell) {
 	const out = [];
 	out.push(headerSlice(newHtml, newTable, oldHtml, oldTable));