@pierre/diffs 1.1.0-beta.8 → 1.1.0

package/dist/managers/InteractionManager.js

@@ -0,0 +1,813 @@
+import { areSelectionPointsEqual } from "../utils/areSelectionPointsEqual.js";
+import { areSelectionsEqual } from "../utils/areSelectionsEqual.js";
+import { createGutterUtilityElement } from "../utils/createGutterUtilityElement.js";
+import { toHtml } from "hast-util-to-html";
+
+//#region src/managers/InteractionManager.ts
+var InteractionManager = class {
+	hoveredLine;
+	pre;
+	gutterUtilityContainer;
+	gutterUtilityButton;
+	gutterUtilitySlot;
+	interactiveLinesAttr = false;
+	interactiveLineNumbersAttr = false;
+	hasPointerListeners = false;
+	hasDocumentPointerListeners = false;
+	selectedRange = null;
+	renderedSelectionRange;
+	selectionAnchor;
+	queuedSelectionRender;
+	pointerSession = { mode: "idle" };
+	constructor(mode, options) {
+		this.mode = mode;
+		this.options = options;
+	}
+	setOptions(options) {
+		this.options = options;
+	}
+	cleanUp() {
+		this.pre?.removeEventListener("click", this.handlePointerClick);
+		this.pre?.removeEventListener("pointerdown", this.handlePointerDown);
+		this.pre?.removeEventListener("pointermove", this.handlePointerMove);
+		this.pre?.removeEventListener("pointerleave", this.handlePointerLeave);
+		this.pre?.removeAttribute("data-interactive-lines");
+		this.pre?.removeAttribute("data-interactive-line-numbers");
+		this.pre = void 0;
+		this.gutterUtilityContainer?.remove();
+		this.gutterUtilityContainer = void 0;
+		this.gutterUtilityButton = void 0;
+		this.gutterUtilitySlot = void 0;
+		this.clearHoveredLine();
+		this.detachDocumentPointerListeners();
+		this.clearPointerSession();
+		if (this.queuedSelectionRender != null) {
+			cancelAnimationFrame(this.queuedSelectionRender);
+			this.queuedSelectionRender = void 0;
+		}
+		this.interactiveLinesAttr = false;
+		this.interactiveLineNumbersAttr = false;
+		this.hasPointerListeners = false;
+	}
+	setup(pre) {
+		this.setSelectionDirty();
+		const { usesCustomGutterUtility = false, enableGutterUtility = false } = this.options;
+		if (this.pre !== pre) {
+			this.cleanUp();
+			this.pre = pre;
+		}
+		if (enableGutterUtility) this.ensureGutterUtilityNode(usesCustomGutterUtility);
+		else if (this.gutterUtilityContainer != null) {
+			this.gutterUtilityContainer.remove();
+			this.gutterUtilityContainer = void 0;
+			this.gutterUtilityButton = void 0;
+			this.gutterUtilitySlot = void 0;
+			if (this.pointerSession.mode === "gutterSelecting") {
+				this.clearPointerSession();
+				this.detachDocumentPointerListeners();
+			}
+		}
+		this.syncPointerListeners(pre);
+		this.updateInteractiveLineAttributes();
+		this.renderSelection();
+	}
+	setSelectionDirty() {
+		this.renderedSelectionRange = void 0;
+	}
+	isSelectionDirty() {
+		return this.renderedSelectionRange === null;
+	}
+	setSelection(range) {
+		const isRangeChange = !(range === this.selectedRange || areSelectionsEqual(range ?? void 0, this.selectedRange ?? void 0));
+		if (!this.isSelectionDirty() && !isRangeChange) return;
+		this.selectedRange = range;
+		this.renderSelection();
+		if (isRangeChange) this.notifySelectionCommitted();
+	}
+	getSelection() {
+		return this.selectedRange;
+	}
+	getHoveredLine = () => {
+		if (this.hoveredLine != null) {
+			if (this.mode === "diff" && this.hoveredLine.type === "diff-line") return {
+				lineNumber: this.hoveredLine.lineNumber,
+				side: this.hoveredLine.annotationSide
+			};
+			if (this.mode === "file" && this.hoveredLine.type === "line") return { lineNumber: this.hoveredLine.lineNumber };
+		}
+	};
+	handlePointerClick = (event) => {
+		const { onHunkExpand, onLineClick, onLineNumberClick, onMergeConflictActionClick } = this.options;
+		if (onHunkExpand == null && onLineClick == null && onLineNumberClick == null && onMergeConflictActionClick == null) return;
+		if (this.options.onGutterUtilityClick != null && isGutterUtilityPointerPath(event.composedPath())) return;
+		debugLogIfEnabled(this.options.__debugPointerEvents, "click", "FileDiff.DEBUG.handlePointerClick:", event);
+		this.handlePointerEvent({
+			eventType: "click",
+			event
+		});
+	};
+	handlePointerMove = (event) => {
+		const { lineHoverHighlight = "disabled", onLineEnter, onLineLeave, enableGutterUtility = false } = this.options;
+		if (lineHoverHighlight === "disabled" && !enableGutterUtility && onLineEnter == null && onLineLeave == null) return;
+		debugLogIfEnabled(this.options.__debugPointerEvents, "move", "FileDiff.DEBUG.handlePointerMove:", event);
+		this.handlePointerEvent({
+			eventType: "move",
+			event
+		});
+	};
+	handlePointerLeave = (event) => {
+		const { __debugPointerEvents } = this.options;
+		debugLogIfEnabled(__debugPointerEvents, "move", "FileDiff.DEBUG.handlePointerLeave: no event");
+		if (this.hoveredLine == null) {
+			debugLogIfEnabled(__debugPointerEvents, "move", "FileDiff.DEBUG.handlePointerLeave: returned early, no .hoveredLine");
+			return;
+		}
+		this.gutterUtilityContainer?.remove();
+		this.options.onLineLeave?.({
+			...this.hoveredLine,
+			event
+		});
+		this.clearHoveredLine();
+	};
+	handlePointerEvent({ eventType, event }) {
+		const { __debugPointerEvents } = this.options;
+		const composedPath = event.composedPath();
+		debugLogIfEnabled(__debugPointerEvents, eventType, "FileDiff.DEBUG.handlePointerEvent:", {
+			eventType,
+			composedPath
+		});
+		const target = this.resolvePointerTarget(composedPath);
+		debugLogIfEnabled(__debugPointerEvents, eventType, "FileDiff.DEBUG.handlePointerEvent: resolvePointerTarget result:", target);
+		const { onLineClick, onLineNumberClick, onLineEnter, onLineLeave, onHunkExpand, onMergeConflictActionClick } = this.options;
+		switch (eventType) {
+			case "move":
+				if (isLinePointerTarget(target) && this.hoveredLine?.lineElement === target.lineElement) break;
+				if (this.hoveredLine != null) {
+					this.gutterUtilityContainer?.remove();
+					onLineLeave?.({
+						...this.hoveredLine,
+						event
+					});
+					this.clearHoveredLine();
+				}
+				if (isLinePointerTarget(target)) {
+					this.setHoveredLine(this.toEventBaseProps(target));
+					if (this.gutterUtilityContainer != null) target.numberElement.appendChild(this.gutterUtilityContainer);
+					onLineEnter?.({
+						...this.hoveredLine,
+						event
+					});
+				}
+				break;
+			case "click": {
+				if (target == null) break;
+				if (isMergeConflictActionPointerTarget(target) && onMergeConflictActionClick != null) {
+					onMergeConflictActionClick(target);
+					break;
+				}
+				if (isExpandoPointerTarget(target) && onHunkExpand != null) {
+					onHunkExpand(target.hunkIndex, event.shiftKey ? "both" : target.direction, event.shiftKey ? Number.POSITIVE_INFINITY : void 0);
+					break;
+				}
+				if (!isLinePointerTarget(target)) break;
+				const eventBase = this.toEventBaseProps(target);
+				if (onLineNumberClick != null && target.numberColumn) onLineNumberClick({
+					...eventBase,
+					event
+				});
+				else if (onLineClick != null) onLineClick({
+					...eventBase,
+					event
+				});
+				break;
+			}
+		}
+	}
+	syncPointerListeners(pre) {
+		const { __debugPointerEvents, lineHoverHighlight = "disabled", onLineClick, onLineNumberClick, onLineEnter, onLineLeave, onHunkExpand, onMergeConflictActionClick, enableGutterUtility = false, enableLineSelection = false, onGutterUtilityClick } = this.options;
+		const enableGutterSelection = onGutterUtilityClick != null;
+		const shouldAttachPointerListeners = lineHoverHighlight !== "disabled" || onLineClick != null || onLineNumberClick != null || onHunkExpand != null || onMergeConflictActionClick != null || onLineEnter != null || onLineLeave != null || enableGutterUtility || enableLineSelection || enableGutterSelection;
+		if (shouldAttachPointerListeners && !this.hasPointerListeners) {
+			pre.addEventListener("click", this.handlePointerClick);
+			pre.addEventListener("pointerdown", this.handlePointerDown);
+			pre.addEventListener("pointermove", this.handlePointerMove);
+			pre.addEventListener("pointerleave", this.handlePointerLeave);
+			this.hasPointerListeners = true;
+			debugLogIfEnabled(__debugPointerEvents, "click", "FileDiff.DEBUG.attachEventListeners: Attaching click events for:", (() => {
+				const reasons = [];
+				if (__debugPointerEvents === "both" || __debugPointerEvents === "click") {
+					if (onLineClick != null) reasons.push("onLineClick");
+					if (onLineNumberClick != null) reasons.push("onLineNumberClick");
+					if (onHunkExpand != null) reasons.push("expandable hunk separators");
+					if (onMergeConflictActionClick != null) reasons.push("merge conflict actions");
+				}
+				return reasons;
+			})());
+			debugLogIfEnabled(__debugPointerEvents, "move", "FileDiff.DEBUG.attachEventListeners: Attaching pointer move event");
+			debugLogIfEnabled(__debugPointerEvents, "move", "FileDiff.DEBUG.attachEventListeners: Attaching pointer leave event");
+		} else if (!shouldAttachPointerListeners && this.hasPointerListeners) {
+			pre.removeEventListener("click", this.handlePointerClick);
+			pre.removeEventListener("pointerdown", this.handlePointerDown);
+			pre.removeEventListener("pointermove", this.handlePointerMove);
+			pre.removeEventListener("pointerleave", this.handlePointerLeave);
+			this.hasPointerListeners = false;
+		}
+		const hasActiveLineSelectionSession = this.pointerSession.mode === "selecting" || this.pointerSession.mode === "pendingSingleLineUnselect";
+		const hasActiveGutterSelectionSession = this.pointerSession.mode === "gutterSelecting";
+		if (!enableLineSelection && hasActiveLineSelectionSession || !enableGutterSelection && hasActiveGutterSelectionSession) {
+			this.clearPointerSession();
+			this.detachDocumentPointerListeners();
+			this.selectionAnchor = void 0;
+			this.clearPendingSingleLineState();
+		}
+	}
+	updateInteractiveLineAttributes() {
+		if (this.pre == null) return;
+		const { onLineClick, onLineNumberClick, enableLineSelection = false } = this.options;
+		const shouldHaveInteractiveLines = onLineClick != null;
+		const shouldHaveInteractiveLineNumbers = onLineNumberClick != null || enableLineSelection;
+		if (shouldHaveInteractiveLines && !this.interactiveLinesAttr) {
+			this.pre.setAttribute("data-interactive-lines", "");
+			this.interactiveLinesAttr = true;
+		} else if (!shouldHaveInteractiveLines && this.interactiveLinesAttr) {
+			this.pre.removeAttribute("data-interactive-lines");
+			this.interactiveLinesAttr = false;
+		}
+		if (shouldHaveInteractiveLineNumbers && !this.interactiveLineNumbersAttr) {
+			this.pre.setAttribute("data-interactive-line-numbers", "");
+			this.interactiveLineNumbersAttr = true;
+		} else if (!shouldHaveInteractiveLineNumbers && this.interactiveLineNumbersAttr) {
+			this.pre.removeAttribute("data-interactive-line-numbers");
+			this.interactiveLineNumbersAttr = false;
+		}
+	}
+	handlePointerDown = (event) => {
+		if (event.pointerType === "mouse" && event.button !== 0 || this.pre == null || this.pointerSession.mode !== "idle") return;
+		const path = event.composedPath();
+		if (isGutterUtilityPointerPath(path) && this.options.onGutterUtilityClick != null) this.startGutterSelectionFromPointerDown(event, path);
+		else this.startLineSelectionFromPointerDown(event, path);
+	};
+	startLineSelectionFromPointerDown(event, path) {
+		const { enableLineSelection = false } = this.options;
+		if (!enableLineSelection) return;
+		const pointerInfo = this.getSelectionPointerInfo(path, true);
+		if (pointerInfo == null) return;
+		const { pre } = this;
+		if (pre == null) return;
+		event.preventDefault();
+		const { lineNumber, eventSide, lineIndex } = pointerInfo;
+		if (event.shiftKey && this.selectedRange != null) {
+			const rowRange = this.getIndexesFromSelection(this.selectedRange, pre.getAttribute("data-diff-type") === "split");
+			if (rowRange == null) return;
+			const useStart = rowRange.start <= rowRange.end ? lineIndex >= rowRange.start : lineIndex <= rowRange.end;
+			this.selectionAnchor = {
+				lineNumber: useStart ? this.selectedRange.start : this.selectedRange.end,
+				side: useStart ? this.selectedRange.side : this.selectedRange.endSide ?? this.selectedRange.side
+			};
+			this.updateSelection(lineNumber, eventSide, false);
+			this.notifySelectionStart(this.selectedRange);
+			this.pointerSession = {
+				mode: "selecting",
+				pointerId: event.pointerId
+			};
+			this.attachDocumentPointerListeners();
+			return;
+		}
+		if (this.selectedRange?.start === lineNumber && this.selectedRange?.end === lineNumber) {
+			const point = {
+				lineNumber,
+				side: eventSide
+			};
+			this.selectionAnchor = point;
+			this.pointerSession = {
+				mode: "pendingSingleLineUnselect",
+				pointerId: event.pointerId,
+				anchor: point,
+				pending: point
+			};
+			this.attachDocumentPointerListeners();
+			return;
+		}
+		this.selectedRange = null;
+		this.selectionAnchor = {
+			lineNumber,
+			side: eventSide
+		};
+		this.updateSelection(lineNumber, eventSide, false);
+		this.notifySelectionStart(this.selectedRange);
+		this.pointerSession = {
+			mode: "selecting",
+			pointerId: event.pointerId
+		};
+		this.attachDocumentPointerListeners();
+	}
+	startGutterSelectionFromPointerDown(event, path) {
+		const { enableLineSelection = false, onGutterUtilityClick } = this.options;
+		if (onGutterUtilityClick == null) return;
+		const point = this.getSelectionPointFromPath(path);
+		if (point == null) return;
+		event.preventDefault();
+		event.stopPropagation();
+		this.pointerSession = {
+			mode: "gutterSelecting",
+			pointerId: event.pointerId,
+			anchor: point,
+			current: point
+		};
+		if (enableLineSelection) {
+			this.selectionAnchor = {
+				lineNumber: point.lineNumber,
+				side: point.side
+			};
+			this.updateSelection(point.lineNumber, point.side, false);
+			this.notifySelectionStart(this.selectedRange);
+		}
+		this.attachDocumentPointerListeners();
+	}
+	handleDocumentPointerMove = (event) => {
+		const { enableLineSelection = false } = this.options;
+		switch (this.pointerSession.mode) {
+			case "idle": return;
+			case "gutterSelecting": {
+				if (event.pointerId !== this.pointerSession.pointerId) return;
+				const point = this.getSelectionPointFromPath(event.composedPath());
+				if (point == null) return;
+				this.pointerSession.current = point;
+				if (enableLineSelection === true) this.updateSelection(point.lineNumber, point.side);
+				return;
+			}
+			case "selecting": {
+				if (event.pointerId !== this.pointerSession.pointerId) return;
+				const pointerInfo = this.getSelectionPointerInfo(event.composedPath(), false);
+				if (pointerInfo == null || this.selectionAnchor == null) return;
+				this.updateSelection(pointerInfo.lineNumber, pointerInfo.eventSide);
+				return;
+			}
+			case "pendingSingleLineUnselect": {
+				if (event.pointerId !== this.pointerSession.pointerId) return;
+				const pointerInfo = this.getSelectionPointerInfo(event.composedPath(), false);
+				if (pointerInfo == null || this.selectionAnchor == null) return;
+				const point = {
+					lineNumber: pointerInfo.lineNumber,
+					side: pointerInfo.eventSide
+				};
+				if (areSelectionPointsEqual(this.pointerSession.pending, point)) return;
+				this.updateSelection(pointerInfo.lineNumber, pointerInfo.eventSide, false);
+				this.notifySelectionStart(this.selectedRange);
+				this.notifySelectionChangeDelta();
+				this.pointerSession = {
+					mode: "selecting",
+					pointerId: event.pointerId
+				};
+				return;
+			}
+		}
+	};
+	handleDocumentPointerUp = (event) => {
+		const { enableLineSelection = false, onGutterUtilityClick } = this.options;
+		switch (this.pointerSession.mode) {
+			case "idle": return;
+			case "gutterSelecting": {
+				if (event.pointerId !== this.pointerSession.pointerId) return;
+				const point = this.getSelectionPointFromPath(event.composedPath());
+				if (point != null) {
+					this.pointerSession.current = point;
+					if (enableLineSelection) this.updateSelection(point.lineNumber, point.side);
+				}
+				onGutterUtilityClick?.(this.buildSelectedLineRange(this.pointerSession.anchor, this.pointerSession.current));
+				this.selectionAnchor = void 0;
+				if (enableLineSelection) {
+					this.notifySelectionEnd(this.selectedRange);
+					this.notifySelectionCommitted();
+				}
+				this.clearPointerSession();
+				this.detachDocumentPointerListeners();
+				return;
+			}
+			case "pendingSingleLineUnselect":
+				if (event.pointerId !== this.pointerSession.pointerId) return;
+				this.updateSelection(null, void 0, false);
+				this.selectionAnchor = void 0;
+				this.clearPendingSingleLineState();
+				this.detachDocumentPointerListeners();
+				this.notifySelectionEnd(this.selectedRange);
+				this.notifySelectionCommitted();
+				return;
+			case "selecting":
+				if (event.pointerId !== this.pointerSession.pointerId) return;
+				this.selectionAnchor = void 0;
+				this.detachDocumentPointerListeners();
+				this.clearPointerSession();
+				this.notifySelectionEnd(this.selectedRange);
+				this.notifySelectionCommitted();
+		}
+	};
+	handleDocumentPointerCancel = (event) => {
+		switch (this.pointerSession.mode) {
+			case "idle": return;
+			case "gutterSelecting":
+			case "selecting":
+			case "pendingSingleLineUnselect":
+				if ("pointerId" in this.pointerSession) {
+					if (event.pointerId !== this.pointerSession.pointerId) return;
+				}
+				this.selectionAnchor = void 0;
+				this.clearPendingSingleLineState();
+				this.clearPointerSession();
+				this.detachDocumentPointerListeners();
+		}
+	};
+	clearHoveredLine() {
+		if (this.hoveredLine == null) return;
+		this.hoveredLine.lineElement.removeAttribute("data-hovered");
+		this.hoveredLine.numberElement.removeAttribute("data-hovered");
+		this.hoveredLine = void 0;
+	}
+	setHoveredLine(hoveredLine) {
+		const { lineHoverHighlight = "disabled" } = this.options;
+		if (this.hoveredLine != null) this.clearHoveredLine();
+		this.hoveredLine = hoveredLine;
+		if (lineHoverHighlight !== "disabled") {
+			if (lineHoverHighlight === "both" || lineHoverHighlight === "line") this.hoveredLine.lineElement.setAttribute("data-hovered", "");
+			if (lineHoverHighlight === "both" || lineHoverHighlight === "number") this.hoveredLine.numberElement.setAttribute("data-hovered", "");
+		}
+	}
+	ensureGutterUtilityNode(useCustomGutterUtility) {
+		if (this.gutterUtilityContainer == null) {
+			this.gutterUtilityContainer = document.createElement("div");
+			this.gutterUtilityContainer.setAttribute("data-gutter-utility-slot", "");
+		}
+		if (useCustomGutterUtility) {
+			if (this.gutterUtilityButton != null) {
+				this.gutterUtilityButton.remove();
+				this.gutterUtilityButton = void 0;
+			}
+			if (this.gutterUtilitySlot == null) {
+				this.gutterUtilitySlot = document.createElement("slot");
+				this.gutterUtilitySlot.name = "gutter-utility-slot";
+			}
+			if (this.gutterUtilitySlot.parentNode !== this.gutterUtilityContainer) this.gutterUtilityContainer.replaceChildren(this.gutterUtilitySlot);
+		} else {
+			this.gutterUtilitySlot?.remove();
+			this.gutterUtilitySlot = void 0;
+			if (this.gutterUtilityButton == null) {
+				const tempDiv = document.createElement("div");
+				tempDiv.innerHTML = toHtml(createGutterUtilityElement());
+				const utilityButton = tempDiv.firstElementChild;
+				if (!(utilityButton instanceof HTMLButtonElement)) throw new Error("InteractionManager.ensureGutterUtilityNode: Node element should be a button");
+				utilityButton.remove();
+				this.gutterUtilityButton = utilityButton;
+			}
+			if (this.gutterUtilityButton.parentNode !== this.gutterUtilityContainer) this.gutterUtilityContainer.replaceChildren(this.gutterUtilityButton);
+		}
+	}
+	attachDocumentPointerListeners() {
+		if (this.hasDocumentPointerListeners) return;
+		document.addEventListener("pointermove", this.handleDocumentPointerMove);
+		document.addEventListener("pointerup", this.handleDocumentPointerUp);
+		document.addEventListener("pointercancel", this.handleDocumentPointerCancel);
+		this.hasDocumentPointerListeners = true;
+	}
+	detachDocumentPointerListeners() {
+		if (!this.hasDocumentPointerListeners) return;
+		document.removeEventListener("pointermove", this.handleDocumentPointerMove);
+		document.removeEventListener("pointerup", this.handleDocumentPointerUp);
+		document.removeEventListener("pointercancel", this.handleDocumentPointerCancel);
+		this.hasDocumentPointerListeners = false;
+	}
+	clearPointerSession() {
+		this.pointerSession = { mode: "idle" };
+	}
+	clearPendingSingleLineState() {
+		if (this.pointerSession.mode === "pendingSingleLineUnselect") this.pointerSession = { mode: "idle" };
+	}
+	getSelectionPointerInfo(path, requireNumberColumn) {
+		const target = this.resolvePointerTarget(path);
+		if (!isLinePointerTarget(target)) return;
+		if (requireNumberColumn && !target.numberColumn) return;
+		if (target.splitLineIndex == null) return;
+		return {
+			lineIndex: target.splitLineIndex,
+			lineNumber: target.lineNumber,
+			eventSide: this.mode === "diff" ? target.side : void 0
+		};
+	}
+	getSelectionPointFromPath(path) {
+		const target = this.resolvePointerTarget(path);
+		if (!isLinePointerTarget(target)) return;
+		return {
+			lineNumber: target.lineNumber,
+			side: this.mode === "diff" ? target.side : void 0
+		};
+	}
+	getLineIndex(lineNumber, side) {
+		const { getLineIndex } = this.options;
+		return getLineIndex != null ? getLineIndex(lineNumber, side) : [lineNumber - 1, lineNumber - 1];
+	}
+	updateSelection(currentLine, side, emitChange = true) {
+		const { selectedRange: previousRange } = this;
+		let nextRange;
+		if (currentLine == null) nextRange = null;
+		else {
+			const anchorSide = this.selectionAnchor?.side ?? side;
+			const anchorLine = this.selectionAnchor?.lineNumber ?? currentLine;
+			nextRange = this.buildSelectionRange(anchorLine, currentLine, anchorSide, side);
+		}
+		if (areSelectionsEqual(previousRange ?? void 0, nextRange ?? void 0)) return;
+		this.selectedRange = nextRange;
+		if (emitChange) this.notifySelectionChangeDelta();
+		this.queuedSelectionRender ??= requestAnimationFrame(this.renderSelection);
+	}
+	getIndexesFromSelection(selectedRange, split) {
+		if (this.pre == null) return;
+		const startIndexes = this.getLineIndex(selectedRange.start, selectedRange.side);
+		const finalIndexes = this.getLineIndex(selectedRange.end, selectedRange.endSide ?? selectedRange.side);
+		return startIndexes != null && finalIndexes != null ? {
+			start: split ? startIndexes[1] : startIndexes[0],
+			end: split ? finalIndexes[1] : finalIndexes[0]
+		} : void 0;
+	}
+	renderSelection = () => {
+		if (this.queuedSelectionRender != null) {
+			cancelAnimationFrame(this.queuedSelectionRender);
+			this.queuedSelectionRender = void 0;
+		}
+		if (this.pre == null || this.renderedSelectionRange === this.selectedRange) return;
+		const allSelected = this.pre.querySelectorAll("[data-selected-line]");
+		for (const element of allSelected) element.removeAttribute("data-selected-line");
+		this.renderedSelectionRange = this.selectedRange;
+		if (this.selectedRange == null) return;
+		const { children: codeElements } = this.pre;
+		if (codeElements.length === 0) return;
+		if (codeElements.length > 2) {
+			console.error(codeElements);
+			throw new Error("InteractionManager.renderSelection: Somehow there are more than 2 code elements...");
+		}
+		const split = this.pre.getAttribute("data-diff-type") === "split";
+		const rowRange = this.getIndexesFromSelection(this.selectedRange, split);
+		if (rowRange == null) {
+			console.error({
+				rowRange,
+				selectedRange: this.selectedRange
+			});
+			throw new Error("InteractionManager.renderSelection: No valid rowRange");
+		}
+		const isSingle = rowRange.start === rowRange.end;
+		const first = Math.min(rowRange.start, rowRange.end);
+		const last = Math.max(rowRange.start, rowRange.end);
+		for (const code of codeElements) {
+			const [gutter, content] = code.children;
+			const len = content.children.length;
+			if (len !== gutter.children.length) throw new Error("InteractionManager.renderSelection: gutter and content children dont match, something is wrong");
+			for (let i = 0; i < len; i++) {
+				const contentElement = content.children[i];
+				const gutterElement = gutter.children[i];
+				if (!(contentElement instanceof HTMLElement) || !(gutterElement instanceof HTMLElement)) continue;
+				const lineIndex = this.parseLineIndex(contentElement, split);
+				if ((lineIndex ?? 0) > last) break;
+				if (lineIndex == null || lineIndex < first) continue;
+				let attributeValue = isSingle ? "single" : lineIndex === first ? "first" : lineIndex === last ? "last" : "";
+				contentElement.setAttribute("data-selected-line", attributeValue);
+				gutterElement.setAttribute("data-selected-line", attributeValue);
+				if (gutterElement.nextSibling instanceof HTMLElement && contentElement.nextSibling instanceof HTMLElement && (contentElement.nextSibling.hasAttribute("data-line-annotation") || contentElement.nextSibling.hasAttribute("data-merge-conflict-actions"))) {
+					if (isSingle) {
+						attributeValue = "last";
+						contentElement.setAttribute("data-selected-line", "first");
+					} else if (lineIndex === first) attributeValue = "";
+					else if (lineIndex === last) contentElement.setAttribute("data-selected-line", "");
+					contentElement.nextSibling.setAttribute("data-selected-line", attributeValue);
+					gutterElement.nextSibling.setAttribute("data-selected-line", attributeValue);
+				}
+			}
+		}
+	};
+	notifySelectionCommitted() {
+		this.options.onLineSelected?.(this.selectedRange ?? null);
+	}
+	notifySelectionChangeDelta() {
+		this.options.onLineSelectionChange?.(this.selectedRange ?? null);
+	}
+	notifySelectionStart(range) {
+		this.options.onLineSelectionStart?.(range);
+	}
+	notifySelectionEnd(range) {
+		this.options.onLineSelectionEnd?.(range);
+	}
+	toEventBaseProps(target) {
+		if (this.mode === "file") return {
+			type: "line",
+			lineElement: target.lineElement,
+			lineNumber: target.lineNumber,
+			numberColumn: target.numberColumn,
+			numberElement: target.numberElement
+		};
+		return {
+			type: "diff-line",
+			annotationSide: target.side,
+			lineType: target.lineType,
+			lineElement: target.lineElement,
+			numberElement: target.numberElement,
+			lineNumber: target.lineNumber,
+			numberColumn: target.numberColumn
+		};
+	}
+	buildSelectedLineRange(anchor, current) {
+		return this.buildSelectionRange(anchor.lineNumber, current.lineNumber, anchor.side, current.side);
+	}
+	buildSelectionRange(start, end, side, endSide) {
+		return {
+			start,
+			end,
+			...side != null ? { side } : {},
+			...side !== endSide && endSide != null ? { endSide } : {}
+		};
+	}
+	resolvePointerTarget(path) {
+		let numberColumn = false;
+		let lineType;
+		let codeElement;
+		let lineElement;
+		let lineIndexValue;
+		let numberElement;
+		let expandInfo;
+		let lineNumber;
+		let mergeConflictActionTarget;
+		for (const element of path) {
+			if (!(element instanceof HTMLElement)) continue;
+			if (mergeConflictActionTarget == null && element.hasAttribute("data-merge-conflict-action")) {
+				const resolutionValue = element.getAttribute("data-merge-conflict-action") ?? void 0;
+				const conflictIndexValue = element.getAttribute("data-merge-conflict-conflict-index") ?? void 0;
+				const conflictIndex = conflictIndexValue != null ? Number.parseInt(conflictIndexValue, 10) : NaN;
+				if (isMergeConflictResolution(resolutionValue) && Number.isFinite(conflictIndex)) mergeConflictActionTarget = {
+					kind: "merge-conflict-action",
+					resolution: resolutionValue,
+					conflictIndex
+				};
+			}
+			const columnNumber = numberElement == null ? element.getAttribute("data-column-number") ?? void 0 : void 0;
+			if (columnNumber != null) {
+				numberElement = element;
+				lineNumber = Number.parseInt(columnNumber, 10);
+				numberColumn = true;
+				lineType = getLineTypeFromElement(element);
+				lineIndexValue = element.getAttribute("data-line-index") ?? void 0;
+				continue;
+			}
+			const lineAttr = lineElement == null ? element.getAttribute("data-line") ?? void 0 : void 0;
+			if (lineAttr != null) {
+				lineElement = element;
+				lineNumber = Number.parseInt(lineAttr, 10);
+				lineType = getLineTypeFromElement(element);
+				lineIndexValue = element.getAttribute("data-line-index") ?? void 0;
+				continue;
+			}
+			if (expandInfo == null && element.hasAttribute("data-expand-button")) {
+				expandInfo = {
+					hunkIndex: void 0,
+					direction: (() => {
+						if (element.hasAttribute("data-expand-up")) return "up";
+						if (element.hasAttribute("data-expand-down")) return "down";
+						return "both";
+					})()
+				};
+				continue;
+			}
+			const expandIndexValue = expandInfo != null ? element.getAttribute("data-expand-index") ?? void 0 : void 0;
+			if (expandInfo != null && expandIndexValue != null) {
+				const expandIndex = Number.parseInt(expandIndexValue, 10);
+				if (!Number.isNaN(expandIndex)) expandInfo.hunkIndex = expandIndex;
+				continue;
+			}
+			if (codeElement == null && element.hasAttribute("data-code")) {
+				codeElement = element;
+				break;
+			}
+		}
+		if (mergeConflictActionTarget != null) return mergeConflictActionTarget;
+		if (expandInfo?.hunkIndex != null) return {
+			type: "line-info",
+			hunkIndex: expandInfo.hunkIndex,
+			direction: expandInfo.direction
+		};
+		lineElement ??= lineIndexValue != null ? queryHTMLElement(codeElement, `[data-line][data-line-index="${lineIndexValue}"]`) : void 0;
+		numberElement ??= lineIndexValue != null ? queryHTMLElement(codeElement, `[data-column-number][data-line-index="${lineIndexValue}"]`) : void 0;
+		if (codeElement == null || lineElement == null || numberElement == null || lineType == null || lineNumber == null || Number.isNaN(lineNumber)) return;
+		const splitLineIndex = this.parseLineIndex(lineElement, this.isSplitDiff());
+		if (this.mode === "file") return {
+			kind: "line",
+			lineType,
+			lineElement,
+			lineNumber,
+			numberColumn,
+			numberElement,
+			side: void 0,
+			splitLineIndex
+		};
+		const annotationSide = (() => {
+			switch (lineType) {
+				case "change-deletion": return "deletions";
+				case "change-addition": return "additions";
+				default: return codeElement.hasAttribute("data-deletions") ? "deletions" : "additions";
+			}
+		})();
+		return {
+			kind: "line",
+			lineType,
+			lineElement,
+			lineNumber,
+			numberColumn,
+			numberElement,
+			side: annotationSide,
+			splitLineIndex
+		};
+	}
+	isSplitDiff() {
+		return this.pre?.getAttribute("data-diff-type") === "split";
+	}
+	parseLineIndex(element, split) {
+		const lineIndexes = (element.getAttribute("data-line-index") ?? "").split(",").map((value) => Number.parseInt(value, 10)).filter((value) => !Number.isNaN(value));
+		if (split && lineIndexes.length === 2) return lineIndexes[1];
+		if (!split) return lineIndexes[0];
+	}
+};
+function pluckInteractionOptions({ enableGutterUtility, enableHoverUtility, lineHoverHighlight, onGutterUtilityClick, onLineClick, onLineEnter, onLineLeave, onLineNumberClick, renderGutterUtility, renderHoverUtility, __debugPointerEvents, enableLineSelection, onLineSelected, onLineSelectionStart, onLineSelectionChange, onLineSelectionEnd }, onHunkExpand, getLineIndex, onMergeConflictActionClick) {
+	return {
+		enableGutterUtility: resolveEnableGutterUtilityOption({
+			enableGutterUtility,
+			enableHoverUtility,
+			renderGutterUtility,
+			renderHoverUtility,
+			onGutterUtilityClick
+		}),
+		usesCustomGutterUtility: renderGutterUtility != null || renderHoverUtility != null,
+		lineHoverHighlight,
+		onGutterUtilityClick,
+		onHunkExpand,
+		onMergeConflictActionClick,
+		onLineClick,
+		onLineEnter,
+		onLineLeave,
+		onLineNumberClick,
+		__debugPointerEvents,
+		enableLineSelection,
+		onLineSelected,
+		onLineSelectionStart,
+		onLineSelectionChange,
+		onLineSelectionEnd,
+		getLineIndex
+	};
+}
+function resolveEnableGutterUtilityOption({ enableGutterUtility, enableHoverUtility, renderGutterUtility, renderHoverUtility, onGutterUtilityClick }) {
+	if (enableGutterUtility !== void 0 && enableHoverUtility !== void 0) throw new Error("Cannot use both 'enableGutterUtility' and deprecated 'enableHoverUtility'. Use only 'enableGutterUtility'.");
+	if (renderGutterUtility != null && renderHoverUtility != null) throw new Error("Cannot use both 'renderGutterUtility' and deprecated 'renderHoverUtility'. Use only 'renderGutterUtility'.");
+	if (onGutterUtilityClick != null && (renderGutterUtility != null || renderHoverUtility != null)) throw new Error("Cannot use both 'onGutterUtilityClick' and render utility callbacks ('renderGutterUtility'/'renderHoverUtility'). Use only one gutter utility API.");
+	return enableGutterUtility ?? enableHoverUtility ?? false;
+}
+function isLinePointerTarget(target) {
+	return target != null && "kind" in target && target.kind === "line";
+}
+function isExpandoPointerTarget(target) {
+	return "type" in target && target.type === "line-info";
+}
+function isMergeConflictActionPointerTarget(target) {
+	return "kind" in target && target.kind === "merge-conflict-action";
+}
+function isMergeConflictResolution(value) {
+	return value === "current" || value === "incoming" || value === "both";
+}
+function queryHTMLElement(parent, query) {
+	const element = parent?.querySelector(query);
+	return element instanceof HTMLElement ? element : void 0;
+}
+function getLineTypeFromElement(element) {
+	const lineType = element.getAttribute("data-line-type");
+	if (lineType == null) return;
+	switch (lineType) {
+		case "change-deletion":
+		case "change-addition":
+		case "context":
+		case "context-expanded": return lineType;
+		default: return;
+	}
+}
+function isGutterUtilityPointerPath(path) {
+	for (const element of path) if (element instanceof HTMLElement && element.hasAttribute("data-utility-button")) return true;
+	return false;
+}
+function debugLogIfEnabled(debugLogType = "none", logIfType, ...args) {
+	switch (debugLogType) {
+		case "none": return;
+		case "both": break;
+		case "click":
+			if (logIfType !== "click") return;
+			break;
+		case "move":
+			if (logIfType !== "move") return;
+			break;
+	}
+	console.log(...args);
+}
+
+//#endregion
+export { InteractionManager, pluckInteractionOptions };
+//# sourceMappingURL=InteractionManager.js.map