@pierre/diffs 1.1.20 → 1.2.0-beta.0

package/dist/worker/worker.js

@@ -11,6 +11,17 @@ const DEFAULT_THEMES = {
 	light: "pierre-light"
 };
 const DEFAULT_COLLAPSED_CONTEXT_THRESHOLD = 1;
+const DEFAULT_VIRTUAL_FILE_METRICS = {
+	hunkLineCount: 50,
+	lineHeight: 20,
+	diffHeaderHeight: 44,
+	hunkSeparatorHeight: 32,
+	spacing: 8
+};
+const DEFAULT_CODE_VIEW_FILE_METRICS = {
+	...DEFAULT_VIRTUAL_FILE_METRICS,
+	hunkLineCount: 1
+};
 const DEFAULT_EXPANDED_REGION = Object.freeze({
 	fromStart: 0,
 	fromEnd: 0
@@ -680,13 +691,20 @@ function getLineNodes(nodes) {
 //#endregion
 //#region src/utils/iterateOverDiff.ts
 function iterateOverDiff({ diff, diffStyle, startingLine = 0, totalLines = Infinity, expandedHunks, collapsedContextThreshold = DEFAULT_COLLAPSED_CONTEXT_THRESHOLD, callback }) {
+	const iterationStart = getIterationStartState({
+		diff,
+		diffStyle,
+		startingLine,
+		expandedHunks,
+		collapsedContextThreshold
+	});
 	const state = {
 		finalHunk: diff.hunks.at(-1),
 		viewportStart: startingLine,
 		viewportEnd: startingLine + totalLines,
 		isWindowedHighlight: startingLine > 0 || totalLines < Infinity,
-		splitCount: 0,
-		unifiedCount: 0,
+		splitCount: iterationStart.splitCount,
+		unifiedCount: iterationStart.unifiedCount,
 		shouldBreak() {
 			if (!state.isWindowedHighlight) return false;
 			const breakUnified = state.unifiedCount >= startingLine + totalLines;
@@ -728,7 +746,9 @@ function iterateOverDiff({ diff, diffStyle, startingLine = 0, totalLines = Infin
 			return callback(props) ?? false;
 		}
 	};
-	hunkIterator: for (const [hunkIndex, hunk] of diff.hunks.entries()) {
+	hunkIterator: for (let hunkIndex = iterationStart.hunkIndex; hunkIndex < diff.hunks.length; hunkIndex++) {
+		const hunk = diff.hunks[hunkIndex];
+		if (hunk == null) throw new Error("iterateOverDiff: invalid hunk index");
 		if (state.shouldBreak()) break;
 		const leadingRegion = getExpandedRegion(diff.isPartial, hunk.collapsedBefore, expandedHunks, hunkIndex, collapsedContextThreshold);
 		const trailingRegion = (() => {
@@ -758,8 +778,14 @@ function iterateOverDiff({ diff, diffStyle, startingLine = 0, totalLines = Infin
 			let additionLineIndex$1 = hunk.additionLineIndex - leadingRegion.rangeSize;
 			let deletionLineNumber$1 = hunk.deletionStart - leadingRegion.rangeSize;
 			let additionLineNumber$1 = hunk.additionStart - leadingRegion.rangeSize;
-			let index = 0;
+			const [startIndex, endIndex] = getEqualLineIterationRange(state, leadingRegion.fromStart, diffStyle);
+			if (startIndex > 0) state.incrementCounts(startIndex, startIndex);
+			let index = startIndex;
 			while (index < leadingRegion.fromStart) {
+				if (index >= endIndex) {
+					state.incrementCounts(leadingRegion.fromStart - index, leadingRegion.fromStart - index);
+					break;
+				}
 				if (state.isInWindow(0, 0)) {
 					if (state.emit({
 						hunkIndex,
@@ -791,8 +817,14 @@ function iterateOverDiff({ diff, diffStyle, startingLine = 0, totalLines = Infin
 			additionLineIndex$1 = hunk.additionLineIndex - leadingRegion.fromEnd;
 			deletionLineNumber$1 = hunk.deletionStart - leadingRegion.fromEnd;
 			additionLineNumber$1 = hunk.additionStart - leadingRegion.fromEnd;
-			index = 0;
+			const [fromEndStartIndex, fromEndEndIndex] = getEqualLineIterationRange(state, leadingRegion.fromEnd, diffStyle);
+			if (fromEndStartIndex > 0) state.incrementCounts(fromEndStartIndex, fromEndStartIndex);
+			index = fromEndStartIndex;
 			while (index < leadingRegion.fromEnd) {
+				if (index >= fromEndEndIndex) {
+					state.incrementCounts(leadingRegion.fromEnd - index, leadingRegion.fromEnd - index);
+					break;
+				}
 				if (state.isInWindow(0, 0)) {
 					if (state.emit({
 						hunkIndex,
@@ -834,8 +866,14 @@ function iterateOverDiff({ diff, diffStyle, startingLine = 0, totalLines = Infin
 			const isLastContent = content === lastContent;
 			if (content.type === "context") {
 				if (!state.shouldSkip(content.lines, content.lines)) {
-					let index = 0;
+					const [startIndex, endIndex] = getEqualLineIterationRange(state, content.lines, diffStyle);
+					if (startIndex > 0) state.incrementCounts(startIndex, startIndex);
+					let index = startIndex;
 					while (index < content.lines) {
+						if (index >= endIndex) {
+							state.incrementCounts(content.lines - index, content.lines - index);
+							break;
+						}
 						if (state.isInWindow(0, 0)) {
 							const isLastLine = isLastContent && index === content.lines - 1;
 							const unifiedRowIndex = unifiedLineIndex + index;
@@ -914,9 +952,15 @@ function iterateOverDiff({ diff, diffStyle, startingLine = 0, totalLines = Infin
 		if (trailingRegion != null) {
 			const { collapsedLines, fromStart, fromEnd } = trailingRegion;
 			const len = fromStart + fromEnd;
-			let index = 0;
+			const [startIndex, endIndex] = getEqualLineIterationRange(state, len, diffStyle);
+			if (startIndex > 0) state.incrementCounts(startIndex, startIndex);
+			let index = startIndex;
 			while (index < len) {
 				if (state.shouldBreak()) break hunkIterator;
+				if (index >= endIndex) {
+					state.incrementCounts(len - index, len - index);
+					break;
+				}
 				if (state.isInWindow(0, 0)) {
 					const isLastLine = index === len - 1;
 					if (state.emit({
@@ -946,6 +990,101 @@ function iterateOverDiff({ diff, diffStyle, startingLine = 0, totalLines = Infin
 		}
 	}
 }
+function getIterationStartState({ diff, diffStyle, startingLine, expandedHunks, collapsedContextThreshold }) {
+	if (startingLine <= 0 || diffStyle === "both") return {
+		hunkIndex: 0,
+		splitCount: 0,
+		unifiedCount: 0
+	};
+	const prefixCounts = getHunkPrefixCounts({
+		diff,
+		expandedHunks,
+		collapsedContextThreshold
+	});
+	let low = 0;
+	let high = diff.hunks.length - 1;
+	let result = diff.hunks.length;
+	while (low <= high) {
+		const mid = low + high >> 1;
+		const counts$1 = prefixCounts[mid + 1];
+		if (counts$1 == null) throw new Error("iterateOverDiff: invalid hunk prefix index");
+		if ((diffStyle === "unified" ? counts$1.unifiedCount : counts$1.splitCount) > startingLine) {
+			result = mid;
+			high = mid - 1;
+		} else low = mid + 1;
+	}
+	if (result >= diff.hunks.length) {
+		const counts$1 = prefixCounts[diff.hunks.length];
+		if (counts$1 == null) throw new Error("iterateOverDiff: invalid terminal hunk prefix index");
+		return {
+			hunkIndex: diff.hunks.length,
+			splitCount: counts$1.splitCount,
+			unifiedCount: counts$1.unifiedCount
+		};
+	}
+	const counts = prefixCounts[result];
+	if (counts == null) throw new Error("iterateOverDiff: invalid selected hunk prefix index");
+	return {
+		hunkIndex: result,
+		splitCount: counts.splitCount,
+		unifiedCount: counts.unifiedCount
+	};
+}
+function getHunkPrefixCounts({ diff, expandedHunks, collapsedContextThreshold }) {
+	let splitCount = 0;
+	let unifiedCount = 0;
+	const finalHunkIndex = diff.hunks.length - 1;
+	const prefixCounts = [{
+		splitCount: 0,
+		unifiedCount: 0
+	}];
+	for (let index = 0; index < diff.hunks.length; index++) {
+		const hunk = diff.hunks[index];
+		if (hunk == null) throw new Error("iterateOverDiff: invalid hunk summary index");
+		const leadingRegion = getExpandedRegion(diff.isPartial, hunk.collapsedBefore, expandedHunks, index, collapsedContextThreshold);
+		const leadingCount = leadingRegion.fromStart + leadingRegion.fromEnd;
+		splitCount += leadingCount + hunk.splitLineCount;
+		unifiedCount += leadingCount + hunk.unifiedLineCount;
+		if (index === finalHunkIndex && hasFinalCollapsedHunk(diff)) {
+			const trailingRangeSize = getTrailingRangeSize(diff, hunk);
+			const trailingRegion = getExpandedRegion(diff.isPartial, trailingRangeSize, expandedHunks, diff.hunks.length, collapsedContextThreshold);
+			const trailingCount = trailingRegion.fromStart + trailingRegion.fromEnd;
+			splitCount += trailingCount;
+			unifiedCount += trailingCount;
+		}
+		prefixCounts.push({
+			splitCount,
+			unifiedCount
+		});
+	}
+	return prefixCounts;
+}
+function getEqualLineIterationRange(state, count, diffStyle) {
+	if (!state.isWindowedHighlight || count <= 0) return [0, count];
+	const ranges = [];
+	function pushRange(currentCount) {
+		const start$1 = Math.max(0, state.viewportStart - currentCount);
+		const end$1 = Math.min(count, state.viewportEnd - currentCount);
+		if (end$1 > start$1) ranges.push([start$1, end$1]);
+	}
+	if (diffStyle !== "split") pushRange(state.unifiedCount);
+	if (diffStyle !== "unified") pushRange(state.splitCount);
+	if (ranges.length === 0) return [0, 0];
+	let start = ranges[0][0];
+	let end = ranges[0][1];
+	for (let index = 1; index < ranges.length; index++) {
+		const range = ranges[index];
+		start = Math.min(start, range[0]);
+		end = Math.max(end, range[1]);
+	}
+	return [start, end];
+}
+function getTrailingRangeSize(diff, hunk) {
+	const additionRemaining = diff.additionLines.length - (hunk.additionLineIndex + hunk.additionCount);
+	const deletionRemaining = diff.deletionLines.length - (hunk.deletionLineIndex + hunk.deletionCount);
+	if (additionRemaining !== deletionRemaining) throw new Error(`iterateOverDiff: trailing context mismatch (additions=${additionRemaining}, deletions=${deletionRemaining}) for ${diff.name}`);
+	return Math.min(additionRemaining, deletionRemaining);
+}
 function getExpandedRegion(isPartial, rangeSize, expandedHunks, hunkIndex, collapsedContextThreshold) {
 	rangeSize = Math.max(rangeSize, 0);
 	if (rangeSize === 0 || isPartial) return {