@pierre/diffs 1.2.12 → 1.3.0-beta.10

package/dist/renderers/DiffHunksRenderer.js

@@ -1,9 +1,14 @@
 import { DEFAULT_EXPANDED_REGION, DEFAULT_RENDER_RANGE, DEFAULT_THEMES, DEFAULT_TOKENIZE_MAX_LENGTH } from "../constants.js";
+import { cleanLastNewline } from "../utils/cleanLastNewline.js";
+import { getTrailingContextRangeSize } from "../utils/virtualDiffLayout.js";
+import { preserveTrailingEditorBlankLine, recomputeDiffHunksForEdit, recomputeEmptyDocumentDiff, recomputeTopAlignedAdditionDiff, shouldTopAlignAdditionRecompute, updateDiffHunks } from "../utils/updateDiffHunks.js";
+import { applySessionChangedLines, applySessionEditWindow, findChangedLineWindow, normalizeEditorLines, remapExpandedHunksForRegionChange } from "../utils/editSessionHunks.js";
 import { getFileAnnotations, shouldRenderFileAnnotations } from "../utils/includesFileAnnotations.js";
 import { createGutterGap, createGutterItem, createGutterWrapper, createHastElement } from "../utils/hast_utils.js";
 import { areLanguagesAttached } from "../highlighter/languages/areLanguagesAttached.js";
 import { getHighlighterIfLoaded, getSharedHighlighter } from "../highlighter/shared_highlighter.js";
 import { areThemesAttached } from "../highlighter/themes/areThemesAttached.js";
+import { applyLineTextWithNewline } from "../utils/applyLineTextWithNewline.js";
 import { areRenderRangesEqual } from "../utils/areRenderRangesEqual.js";
 import { createAnnotationElement } from "../utils/createAnnotationElement.js";
 import { createContentColumn } from "../utils/createContentColumn.js";
@@ -14,7 +19,6 @@ import { getHighlighterOptions } from "../utils/getHighlighterOptions.js";
 import { getLineAnnotationName } from "../utils/getLineAnnotationName.js";
 import { shouldUseTokenTransformer } from "../utils/shouldUseTokenTransformer.js";
 import { areDiffTargetsEqual } from "../utils/areDiffTargetsEqual.js";
-import { getTrailingContextRangeSize } from "../utils/virtualDiffLayout.js";
 import { iterateOverDiff } from "../utils/iterateOverDiff.js";
 import { areDiffRenderOptionsEqual } from "../utils/areDiffRenderOptionsEqual.js";
 import { createEmptyRowBuffer } from "../utils/createEmptyRowBuffer.js";
@@ -40,6 +44,8 @@ var DiffHunksRenderer = class {
 	additionAnnotations = {};
 	computedLang = "text";
 	renderCache;
+	editSessionActive = false;
+	editSessionLines;
 	constructor(options = { theme: DEFAULT_THEMES }, onRenderUpdate, workerManager) {
 		this.options = options;
 		this.onRenderUpdate = onRenderUpdate;
@@ -59,9 +65,31 @@ var DiffHunksRenderer = class {
 		this.additionAnnotations = {};
 		this.deletionAnnotations = {};
 		this.workerManager?.cleanUpTasks(this);
+		this.endEditSession();
+	}
+	/**
+	* Enter edit-session mode: hunk updates preserve the current region
+	* skeleton instead of recomputing hunks. Called on every editor attach,
+	* including a re-attach after recycle, which losslessly re-seeds the pass
+	* snapshot because both hunk-update paths keep `diff.additionLines`
+	* current.
+	*/
+	beginEditSession(diff) {
+		this.editSessionActive = true;
+		this.editSessionLines = diff != null ? normalizeEditorLines(diff.additionLines).slice() : void 0;
+	}
+	/** Leave edit-session mode. The exit recompute is the host's concern. */
+	endEditSession() {
+		this.editSessionActive = false;
+		this.editSessionLines = void 0;
+	}
+	get diffCache() {
+		return this.renderCache?.diff ?? this.diff;
 	}
 	clearRenderCache() {
+		const renderCache = this.renderCache;
 		this.renderCache = void 0;
+		if (renderCache != null && renderCache.isDirty === true && renderCache.diff.cacheKey != null) this.workerManager?.evictDiffFromCache(renderCache.diff.cacheKey);
 	}
 	setOptions(options) {
 		this.options = options;
@@ -88,6 +116,10 @@ var DiffHunksRenderer = class {
 	getExpandedHunksMap() {
 		return this.expandedHunks;
 	}
+	/** Replace the whole expansion map (session-exit expansion remapping). */
+	setExpandedHunksMap(expandedHunks) {
+		this.expandedHunks = expandedHunks;
+	}
 	setLineAnnotations(lineAnnotations) {
 		this.additionAnnotations = {};
 		this.deletionAnnotations = {};
@@ -103,12 +135,140 @@ var DiffHunksRenderer = class {
 			arr.push(annotation);
 		}
 	}
+	/**
+	* Returns true when a session-mode pass changed the region skeleton itself
+	* (a gap edit synthesized or merged regions), which changes the rendered
+	* row set without a line-count change — the host must escalate to a full
+	* re-render instead of its cheap refresh path.
+	*/
+	updateRenderCache(dirtyLines, themeType, lineCountChangeInFlight = false) {
+		if (this.renderCache == null) return false;
+		const { result, diff } = this.renderCache;
+		if (result == null) return false;
+		if (diff.isPartial) throw new Error("Could not update render cache for partial diff");
+		const hastLines = result.code.additionLines;
+		const changedAdditionLines = [];
+		for (const [line, tokens] of dirtyLines) {
+			const prevProps = hastLines[line]?.properties ?? {};
+			const lineText = tokens.map((a) => a[2]).join("");
+			const canSyncDiffLine = line < diff.additionLines.length;
+			const prevLine = canSyncDiffLine ? diff.additionLines[line] ?? "" : "";
+			const prevText = cleanLastNewline(prevLine);
+			if (canSyncDiffLine) {
+				diff.additionLines[line] = applyLineTextWithNewline(prevLine, lineText);
+				if (prevText !== lineText) changedAdditionLines.push(line);
+			}
+			hastLines[line] = {
+				type: "element",
+				tagName: "div",
+				properties: {
+					"data-line": prevProps["data-line"] ?? line + 1,
+					"data-line-index": prevProps["data-line-index"] ?? line,
+					"data-line-type": prevProps["data-line-type"] ?? "context"
+				},
+				children: tokens.map(([char, fg, text]) => {
+					if (char === 0 && fg === "") {
+						if (text === "") return {
+							type: "element",
+							tagName: "br",
+							properties: {},
+							children: []
+						};
+						return {
+							type: "text",
+							value: text
+						};
+					}
+					return {
+						type: "element",
+						tagName: "span",
+						properties: {
+							"data-char": char,
+							style: `color:${fg};`
+						},
+						children: [{
+							type: "text",
+							value: text
+						}]
+					};
+				})
+			};
+		}
+		let regionsChanged = false;
+		if (changedAdditionLines.length > 0) if (this.editSessionActive && !diff.isPartial) {
+			if (!lineCountChangeInFlight) {
+				const changes = applySessionChangedLines(diff, changedAdditionLines, this.options.parseDiffOptions);
+				this.applyExpansionRemaps(changes);
+				regionsChanged = changes.length > 0;
+				this.editSessionLines = normalizeEditorLines(diff.additionLines).slice();
+			}
+		} else Object.assign(diff, updateDiffHunks(diff, changedAdditionLines, this.options.parseDiffOptions));
+		result.baseThemeType = themeType;
+		this.renderCache.isDirty = true;
+		return regionsChanged;
+	}
+	applyExpansionRemaps(changes) {
+		for (const change of changes) this.expandedHunks = remapExpandedHunksForRegionChange(this.expandedHunks, change);
+	}
+	applyDocumentChange(textDocument) {
+		if (this.renderCache == null) return;
+		const { diff, result } = this.renderCache;
+		if (result == null) return;
+		diff.additionLines = getEditorDocumentLines(textDocument, diff.additionLines);
+		const newLength = diff.additionLines.length;
+		const additionHastLines = result.code.additionLines;
+		const prevLen = additionHastLines.length;
+		if (newLength < prevLen) additionHastLines.length = newLength;
+		for (let i = prevLen; i < newLength; i++) additionHastLines[i] ??= createPlainAdditionLineElement(i, textDocument);
+		if (!diff.isPartial) if (diff.additionLines.length <= 1 && diff.additionLines.join("") === "") {
+			Object.assign(diff, recomputeEmptyDocumentDiff(diff, this.options.parseDiffOptions));
+			additionHastLines[0] = createPlainAdditionLineElement(0, textDocument);
+			this.markEditSessionPass(diff);
+		} else if (this.editSessionActive) this.applySessionDocumentChange(diff);
+		else Object.assign(diff, recomputeDiffHunksForEdit(diff, this.options.parseDiffOptions));
+		this.renderCache.isDirty = true;
+	}
+	applySessionDocumentChange(diff) {
+		const { parseDiffOptions } = this.options;
+		const rawLines = diff.additionLines;
+		if (shouldTopAlignAdditionRecompute(diff, rawLines)) {
+			Object.assign(diff, recomputeTopAlignedAdditionDiff(diff, rawLines, parseDiffOptions));
+			this.markEditSessionPass(diff);
+			return;
+		}
+		const previousLines = this.editSessionLines;
+		const nextLines = normalizeEditorLines(rawLines);
+		if (previousLines == null) {
+			Object.assign(diff, recomputeDiffHunksForEdit(diff, parseDiffOptions));
+			this.markEditSessionPass(diff);
+			return;
+		}
+		diff.additionLines = nextLines;
+		const window = findChangedLineWindow(previousLines, nextLines);
+		if (window != null) {
+			const change = applySessionEditWindow(diff, window, parseDiffOptions);
+			if (change != null) this.applyExpansionRemaps([change]);
+		}
+		preserveTrailingEditorBlankLine(diff, rawLines);
+		this.editSessionLines = nextLines.slice();
+	}
+	markEditSessionPass(diff) {
+		if (!this.editSessionActive) return;
+		diff.editSessionDirty = true;
+		this.editSessionLines = normalizeEditorLines(diff.additionLines).slice();
+	}
 	getUnifiedLineDecoration({ lineType }) {
-		return { gutterLineType: lineType };
+		return {
+			gutterLineType: lineType,
+			contentProperties: { "data-line-type": lineType }
+		};
 	}
 	getSplitLineDecoration({ side, type }) {
-		if (type !== "change") return { gutterLineType: type };
-		return { gutterLineType: side === "deletions" ? "change-deletion" : "change-addition" };
+		const lineType = type === "change" ? side === "deletions" ? "change-deletion" : "change-addition" : type;
+		return {
+			gutterLineType: lineType,
+			contentProperties: { "data-line-type": lineType }
+		};
 	}
 	createAnnotationElement = (span) => {
 		return createAnnotationElement(span);
@@ -193,7 +353,7 @@ var DiffHunksRenderer = class {
 	}
 	renderDiff(diff = this.renderCache?.diff, renderRange = DEFAULT_RENDER_RANGE) {
 		if (diff == null) return;
-		const { expandUnchanged = false, collapsedContextThreshold } = this.getOptionsWithDefaults();
+		const { expandUnchanged, collapsedContextThreshold } = this.getOptionsWithDefaults();
 		let { options, forceHighlight } = this.getRenderOptions(diff);
 		const cache = this.getMatchingWorkerResultCache(diff, options);
 		if (cache != null && !this.hasHighlightedRenderCache(diff, options)) {
@@ -313,8 +473,11 @@ var DiffHunksRenderer = class {
 	}
 	processDiffResult(fileDiff, renderRange, { code, themeStyles, baseThemeType }) {
 		const { diffStyle, disableFileHeader, expandUnchanged, expansionLineCount, collapsedContextThreshold, hunkSeparators } = this.getOptionsWithDefaults();
+		const isRenderCacheDirty = this.renderCache?.isDirty ?? false;
 		this.diff = fileDiff;
 		const unified = diffStyle === "unified";
+		const canHydrateContext = canHydrateCollapsedContext(fileDiff, this.options.loadDiffFiles != null);
+		const isExpandableDiff = !fileDiff.isPartial || canHydrateContext;
 		let additionsContentAST = [];
 		let deletionsContentAST = [];
 		let unifiedContentAST = [];
@@ -406,7 +569,7 @@ var DiffHunksRenderer = class {
 					hunkSpecs: hunk?.hunkSpecs,
 					isFirstHunk: hunkIndex === 0,
 					isLastHunk: false,
-					isExpandable: !fileDiff.isPartial
+					isExpandable: isExpandableDiff
 				});
 				const lineIndex = diffStyle === "unified" ? unifiedLineIndex : splitLineIndex;
 				const renderedLineContext = {
@@ -436,8 +599,14 @@ var DiffHunksRenderer = class {
 						deletionLineIndex: deletionLine?.lineIndex
 					});
 					pushGutterLineNumber("unified", lineDecoration.gutterLineType, additionLine != null ? additionLine.lineNumber : deletionLine.lineNumber, `${unifiedLineIndex},${splitLineIndex}`, lineDecoration.gutterProperties);
-					if (additionLineContent != null) additionLineContent = withContentProperties(additionLineContent, lineDecoration.contentProperties);
-					else if (deletionLineContent != null) deletionLineContent = withContentProperties(deletionLineContent, lineDecoration.contentProperties);
+					if (additionLineContent != null) additionLineContent = withContentProperties(additionLineContent, lineDecoration.contentProperties, isRenderCacheDirty && additionLine != null ? {
+						"data-line": additionLine.lineNumber,
+						"data-line-index": `${unifiedLineIndex},${splitLineIndex}`
+					} : void 0);
+					else if (deletionLineContent != null) deletionLineContent = withContentProperties(deletionLineContent, lineDecoration.contentProperties, isRenderCacheDirty && deletionLine != null ? {
+						"data-line": deletionLine.lineNumber,
+						"data-line-index": `${unifiedLineIndex},${splitLineIndex}`
+					} : void 0);
 					pushLineWithAnnotation({
 						diffStyle: "unified",
 						type,
@@ -475,19 +644,25 @@ var DiffHunksRenderer = class {
 						}
 					})();
 					if (missingSide != null) {
-						if (pendingSplitContext.side != null && pendingSplitContext.side !== missingSide) throw new Error("DiffHunksRenderer.processDiffResult: iterateOverDiff, invalid pending splits");
+						if (pendingSplitContext.side != null && pendingSplitContext.side !== missingSide) pendingSplitContext.flush();
 						pendingSplitContext.side = missingSide;
 						pendingSplitContext.increment();
-					}
+					} else if (type === "change") pendingSplitContext.flush();
 					const annotationSpans = this.getAnnotations("split", deletionLine?.lineNumber, additionLine?.lineNumber, hunkIndex, lineIndex);
 					if (annotationSpans != null && pendingSplitContext.size > 0) pendingSplitContext.flush();
 					if (deletionLine != null) {
-						const deletionLineDecorated = withContentProperties(deletionLineContent, deletionLineDecoration.contentProperties);
+						const deletionLineDecorated = withContentProperties(deletionLineContent, deletionLineDecoration.contentProperties, isRenderCacheDirty ? {
+							"data-line": deletionLine.lineNumber,
+							"data-line-index": `${deletionLine.unifiedLineIndex},${splitLineIndex}`
+						} : void 0);
 						pushGutterLineNumber("deletions", deletionLineDecoration.gutterLineType, deletionLine.lineNumber, `${deletionLine.unifiedLineIndex},${splitLineIndex}`, deletionLineDecoration.gutterProperties);
 						if (deletionLineDecorated != null) deletionLineContent = deletionLineDecorated;
 					}
 					if (additionLine != null) {
-						const additionLineDecorated = withContentProperties(additionLineContent, additionLineDecoration.contentProperties);
+						const additionLineDecorated = withContentProperties(additionLineContent, additionLineDecoration.contentProperties, isRenderCacheDirty ? {
+							"data-line": additionLine.lineNumber,
+							"data-line-index": `${additionLine.unifiedLineIndex},${splitLineIndex}`
+						} : void 0);
 						pushGutterLineNumber("additions", additionLineDecoration.gutterLineType, additionLine.lineNumber, `${additionLine.unifiedLineIndex},${splitLineIndex}`, additionLineDecoration.gutterProperties);
 						if (additionLineDecorated != null) additionLineContent = additionLineDecorated;
 					}
@@ -503,6 +678,7 @@ var DiffHunksRenderer = class {
 					if (injectedRows?.after != null) pushSplitInjectedRows(injectedRows.after, context, pendingSplitContext);
 				}
 				const isFinalSplitHunkRow = diffStyle === "split" && hunk != null && splitLineIndex === hunk.splitLineStart + hunk.splitLineCount - 1;
+				const isFinalHunkRow = hunkIndex === fileDiff.hunks.length - 1 && hunk != null && (diffStyle === "split" ? splitLineIndex === hunk.splitLineStart + hunk.splitLineCount - 1 : unifiedLineIndex === hunk.unifiedLineStart + hunk.unifiedLineCount - 1);
 				const splitNoEOFCRDeletion = isFinalSplitHunkRow ? hunk.noEOFCRDeletions : false;
 				const splitNoEOFCRAddition = isFinalSplitHunkRow ? hunk.noEOFCRAdditions : false;
 				const noEOFCRDeletion = (deletionLine?.noEOFCR ?? false) || splitNoEOFCRDeletion;
@@ -539,14 +715,14 @@ var DiffHunksRenderer = class {
 					}
 					context.incrementRowCount(1);
 				}
-				if (collapsedAfter > 0 && hunkSeparators !== "simple") pushSeparators({
+				if (hunkSeparators !== "simple" && hunkSeparators !== "metadata" && (collapsedAfter > 0 || isFinalHunkRow && canHydrateContext)) pushSeparators({
 					hunkIndex: type === "context-expanded" ? hunkIndex : hunkIndex + 1,
-					collapsedLines: collapsedAfter,
+					collapsedLines: isFinalHunkRow && canHydrateContext ? "unknown" : collapsedAfter,
 					rangeSize: trailingRangeSize,
 					hunkSpecs: void 0,
 					isFirstHunk: false,
 					isLastHunk: true,
-					isExpandable: !fileDiff.isPartial
+					isExpandable: isExpandableDiff
 				});
 				context.incrementRowCount(1);
 			}
@@ -786,7 +962,7 @@ function pushLineWithAnnotation({ diffStyle, type, deletionLine, additionLine, u
 	if (hasAnnotationRow) context.incrementRowCount(1);
 }
 function pushSeparator(type, { hunkIndex, collapsedLines, rangeSize, hunkSpecs, isFirstHunk, isLastHunk, isExpandable }, context) {
-	if (collapsedLines <= 0) return;
+	if (typeof collapsedLines === "number" && collapsedLines <= 0) return;
 	const linesAST = type === "unified" ? context.unifiedContentAST : type === "deletions" ? context.deletionsContentAST : context.additionsContentAST;
 	if (context.hunkSeparators === "metadata") {
 		if (hunkSpecs != null) {
@@ -825,9 +1001,10 @@ function pushSeparator(type, { hunkIndex, collapsedLines, rangeSize, hunkSpecs,
 	const slotName = getHunkSeparatorSlotName(type, hunkIndex);
 	const chunked = rangeSize > context.expansionLineCount;
 	const expandIndex = isExpandable ? hunkIndex : void 0;
+	const content = typeof collapsedLines === "number" ? getModifiedLinesString(collapsedLines) : "More unchanged context may be available";
 	context.pushToGutter(type, createSeparator({
 		type: context.hunkSeparators,
-		content: getModifiedLinesString(collapsedLines),
+		content,
 		expandIndex,
 		chunked,
 		slotName,
@@ -836,7 +1013,7 @@ function pushSeparator(type, { hunkIndex, collapsedLines, rangeSize, hunkSpecs,
 	}));
 	linesAST.push(createSeparator({
 		type: context.hunkSeparators,
-		content: getModifiedLinesString(collapsedLines),
+		content,
 		expandIndex,
 		chunked,
 		slotName,
@@ -847,7 +1024,8 @@ function pushSeparator(type, { hunkIndex, collapsedLines, rangeSize, hunkSpecs,
 	context.hunkData.push({
 		slotName,
 		hunkIndex,
-		lines: collapsedLines,
+		lines: typeof collapsedLines === "number" ? collapsedLines : 0,
+		lineCountKnown: typeof collapsedLines === "number",
 		type,
 		expandable: isExpandable ? {
 			up: !isFirstHunk,
@@ -856,19 +1034,63 @@ function pushSeparator(type, { hunkIndex, collapsedLines, rangeSize, hunkSpecs,
 		} : void 0
 	});
 }
-function withContentProperties(lineNode, contentProperties) {
-	if (lineNode == null || lineNode.type !== "element" || contentProperties == null) return lineNode;
+function withContentProperties(lineNode, contentProperties, extendProperties) {
+	if (lineNode == null || lineNode.type !== "element" || contentProperties == null && extendProperties == null) return lineNode;
 	return {
 		...lineNode,
 		properties: {
 			...lineNode.properties,
-			...contentProperties
+			...contentProperties,
+			...extendProperties
 		}
 	};
 }
+function createPlainAdditionLineElement(lineIndex, textDocument) {
+	return {
+		type: "element",
+		tagName: "div",
+		properties: {
+			"data-line": lineIndex + 1,
+			"data-line-index": `${lineIndex},${lineIndex}`,
+			"data-line-type": "context"
+		},
+		children: [{
+			type: "element",
+			tagName: "span",
+			properties: { "data-char": 0 },
+			children: [{
+				type: "text",
+				value: textDocument.getLineText(lineIndex)
+			}]
+		}]
+	};
+}
+function getEditorDocumentLines(textDocument, previousLines) {
+	const lines = [];
+	const fallbackLineBreak = getFallbackLineBreak(previousLines);
+	for (let line = 0; line < textDocument.lineCount; line++) {
+		const lineText = textDocument.getLineText(line, true);
+		lines.push(line < textDocument.lineCount - 1 && !hasLineBreakSuffix(lineText) ? lineText + fallbackLineBreak : lineText);
+	}
+	return lines;
+}
+function hasLineBreakSuffix(line) {
+	return line.endsWith("\n") || line.endsWith("\r");
+}
+function getFallbackLineBreak(lines) {
+	for (const line of lines) {
+		if (line.endsWith("\r\n")) return "\r\n";
+		if (line.endsWith("\n")) return "\n";
+		if (line.endsWith("\r")) return "\r";
+	}
+	return "\n";
+}
 function isDiffMassive(diff, tokenizeMaxLength) {
 	return Math.max(diff.additionLines.length, diff.deletionLines.length) > tokenizeMaxLength;
 }
+function canHydrateCollapsedContext(fileDiff, hasFileLoader) {
+	return fileDiff.isPartial && hasFileLoader && (fileDiff.type === "change" || fileDiff.type === "rename-changed");
+}
 //#endregion
 export { DiffHunksRenderer };