@singapore-editor/find 0.1.1

package/dist/findController.js

@@ -0,0 +1,681 @@
+import { FIND_MATCHES_LIMIT, FIND_REPLACE_ALL_LIMIT, countMatches, escapeRegExpCharacters, findLineRange, findMatchIndex, findMatches, findNextMatchFrom, findPreviousMatchFrom, findTextSourceFromSnapshot } from "./search.js";
+import { ReplacePattern, parseReplaceString } from "./replacePattern.js";
+import { wordRangeAtOffset } from "@singapore-editor/core/document";
+import { EditorSecondaryViewScheduler } from "@singapore-editor/core/secondary-views";
+//#region src/findController.ts
+var FIND_HIGHLIGHT_Z_INDEX = {
+	scope: 4,
+	match: 5,
+	current: 6
+};
+var FIND_MATCH_STYLE = {
+	dimmable: false,
+	backgroundColor: "rgba(234, 179, 8, 0.34)",
+	zIndex: FIND_HIGHLIGHT_Z_INDEX.match
+};
+var FIND_CURRENT_STYLE = {
+	dimmable: false,
+	backgroundColor: "rgba(245, 158, 11, 0.72)",
+	color: "#111827",
+	zIndex: FIND_HIGHLIGHT_Z_INDEX.current
+};
+var FIND_SCOPE_STYLE = {
+	dimmable: false,
+	backgroundColor: "rgba(59, 130, 246, 0.22)",
+	zIndex: FIND_HIGHLIGHT_Z_INDEX.scope
+};
+function findReveal(match, committed = true) {
+	return {
+		...committed ? { jumpCause: "find" } : {},
+		revealOffset: match.end,
+		revealBlock: "center-if-outside"
+	};
+}
+var SEARCH_STRING_MAX_LENGTH = 524288;
+var FIND_RESEARCH_KEY = "find.research";
+var FIND_RESEARCH_DELAY_MS = 100;
+var FIND_RESEARCH_MAX_DELAY_MS = 400;
+var EditorFindController = class {
+	options;
+	listeners = /* @__PURE__ */ new Set();
+	host = null;
+	editHost = null;
+	matchHighlightName = "";
+	currentHighlightName = "";
+	scopeHighlightName = "";
+	state = {
+		searchString: "",
+		replaceString: "",
+		isRegex: false,
+		matchCase: false,
+		wholeWord: false,
+		preserveCase: false,
+		revealed: false,
+		replaceRevealed: false,
+		inSelection: false
+	};
+	scheduler = new EditorSecondaryViewScheduler();
+	matches = [];
+	highlightsTruncated = false;
+	totalMatches = 0;
+	scope = null;
+	trackedMatches = null;
+	currentMatch = null;
+	replacing = false;
+	pendingResearch = false;
+	constructor(options = {}) {
+		this.options = resolveFindOptions(options);
+	}
+	attachHost(host, highlightPrefix) {
+		if (this.host && this.host !== host) this.clearHighlights();
+		this.host = host;
+		this.matchHighlightName = `${highlightPrefix}-find-match`;
+		this.currentHighlightName = `${highlightPrefix}-find-current`;
+		this.scopeHighlightName = `${highlightPrefix}-find-scope`;
+		return { dispose: () => this.detachHost(host) };
+	}
+	attachEditHost(host) {
+		this.editHost = host;
+		return { dispose: () => this.detachEditHost(host) };
+	}
+	subscribe(listener) {
+		this.listeners.add(listener);
+		return { dispose: () => this.listeners.delete(listener) };
+	}
+	dispose() {
+		this.pendingResearch = false;
+		this.scheduler.dispose();
+		this.clearHighlights();
+		this.listeners.clear();
+		this.host = null;
+		this.editHost = null;
+	}
+	isVisible() {
+		return this.state.revealed;
+	}
+	openFind() {
+		return this.open({
+			replace: false,
+			focus: "find"
+		});
+	}
+	toggleFind() {
+		if (this.state.revealed) return this.close();
+		return this.openFind();
+	}
+	openFindReplace() {
+		return this.open({
+			replace: true,
+			focus: "replace"
+		});
+	}
+	close() {
+		const host = this.host;
+		if (!this.state.revealed || !host) return false;
+		this.pendingResearch = false;
+		this.state = {
+			...this.state,
+			revealed: false,
+			inSelection: false
+		};
+		this.scope = null;
+		this.trackedMatches = null;
+		this.currentMatch = null;
+		this.scheduler.cancel(FIND_RESEARCH_KEY);
+		this.clearHighlights();
+		this.emit({ type: "hide" });
+		host.focusEditor();
+		return true;
+	}
+	findNext() {
+		if (!this.ensureFindReady("none")) return false;
+		const startOffset = this.primarySelection()?.endOffset ?? 0;
+		const match = this.nextMatchAt(startOffset, true);
+		if (match && match.start < startOffset) this.host?.announce("Wrapped to the first match");
+		return this.selectMatch(match);
+	}
+	findPrevious() {
+		if (!this.ensureFindReady("none")) return false;
+		const startOffset = this.primarySelection()?.startOffset ?? 0;
+		const match = this.searchFrom(findPreviousMatchFrom, startOffset, { escapeEmptyMatchAtOffset: true });
+		if (match && match.start > startOffset) this.host?.announce("Wrapped to the last match");
+		return this.selectMatch(match);
+	}
+	replaceOne() {
+		if (!this.ensureFindReady("replace")) return false;
+		if (!this.editHost) return false;
+		const selection = this.primarySelection();
+		if (!selection) return false;
+		const search = this.commandSearchTarget();
+		if (!search) return false;
+		const match = findNextMatchFrom(search.source, this.state, selection.startOffset, search.scopes, {
+			captureMatches: true,
+			loop: this.options.loop
+		});
+		if (!match) return false;
+		if (match.start !== selection.startOffset || match.end !== selection.endOffset) return this.selectMatch(match);
+		const replaceText = this.replacePattern().buildReplaceString(match.matches, this.state.preserveCase);
+		this.applyReplacement([{
+			from: match.start,
+			to: match.end,
+			text: replaceText
+		}], "input.findReplaceOne", {
+			anchor: match.start + replaceText.length,
+			head: match.start + replaceText.length
+		});
+		this.selectNextReplacementMatch();
+		this.research(false);
+		return true;
+	}
+	replaceAll() {
+		if (!this.ensureFindReady("replace")) return false;
+		if (!this.editHost) return false;
+		const search = this.commandSearchTarget();
+		if (!search) return false;
+		const pattern = this.replacePattern();
+		const matches = findMatches(search.source, this.state, search.scopes, pattern.hasReplacementPatterns || this.state.preserveCase, FIND_REPLACE_ALL_LIMIT);
+		if (matches.length === 0) return false;
+		const edits = mergeAdjacentReplaceEdits(matches.map((match) => ({
+			from: match.start,
+			to: match.end,
+			text: pattern.buildReplaceString(match.matches, this.state.preserveCase)
+		})));
+		this.applyReplacement(edits, "input.findReplaceAll");
+		this.research(false);
+		return true;
+	}
+	selectAllMatches() {
+		const host = this.host;
+		if (!host) return false;
+		if (!this.ensureFindReady("none")) return false;
+		const search = this.commandSearchTarget();
+		if (!search) return false;
+		const matches = findMatches(search.source, this.state, search.scopes, false, FIND_REPLACE_ALL_LIMIT);
+		if (matches.length === 0) return false;
+		const selections = orderedMatchSelections(matches, this.primarySelection());
+		host.setSelections(selections, "input.findSelectAll", selections[0]?.head);
+		return true;
+	}
+	toggleMatchCase() {
+		this.state = {
+			...this.state,
+			matchCase: !this.state.matchCase
+		};
+		this.research(this.options.cursorMoveOnType);
+		return true;
+	}
+	toggleWholeWord() {
+		this.state = {
+			...this.state,
+			wholeWord: !this.state.wholeWord
+		};
+		this.research(this.options.cursorMoveOnType);
+		return true;
+	}
+	toggleRegex() {
+		this.state = {
+			...this.state,
+			isRegex: !this.state.isRegex
+		};
+		this.research(this.options.cursorMoveOnType);
+		return true;
+	}
+	togglePreserveCase() {
+		this.state = {
+			...this.state,
+			preserveCase: !this.state.preserveCase
+		};
+		this.updateWidget();
+		return true;
+	}
+	toggleReplace() {
+		this.state = {
+			...this.state,
+			replaceRevealed: !this.state.replaceRevealed
+		};
+		this.updateWidget();
+		return true;
+	}
+	toggleFindInSelection() {
+		if (this.state.inSelection) {
+			this.state = {
+				...this.state,
+				inSelection: false
+			};
+			this.scope = null;
+			this.research(this.options.cursorMoveOnType);
+			return true;
+		}
+		const host = this.host;
+		if (!host) return false;
+		const scopes = nonEmptySelectionRanges(this.commandSelections());
+		if (scopes.length === 0) return false;
+		this.state = {
+			...this.state,
+			inSelection: true
+		};
+		this.scope = host.trackRanges(scopes);
+		this.research(this.options.cursorMoveOnType);
+		return true;
+	}
+	setSearchString(value) {
+		this.state = {
+			...this.state,
+			searchString: value
+		};
+		if (this.options.findOnType) this.research(this.options.cursorMoveOnType);
+	}
+	setReplaceString(value) {
+		this.state = {
+			...this.state,
+			replaceString: value
+		};
+		this.updateWidget();
+	}
+	handleViewUpdate(kind, change) {
+		if (!this.state.revealed) return;
+		if (!isFindDocumentUpdate(kind)) return;
+		if (change?.kind === "selection" || change?.kind === "none") return;
+		if (kind === "clear") {
+			this.close();
+			return;
+		}
+		if (this.replacing) return;
+		if (kind === "document") {
+			this.pendingResearch = false;
+			this.scope = null;
+			this.state = {
+				...this.state,
+				inSelection: false
+			};
+			this.research(false);
+			return;
+		}
+		if (this.pendingResearch) {
+			this.research(false);
+			return;
+		}
+		this.scheduleResearch();
+	}
+	detachHost(host) {
+		if (this.host !== host) return;
+		this.pendingResearch = false;
+		this.clearHighlights();
+		this.host = null;
+		this.matchHighlightName = "";
+		this.currentHighlightName = "";
+		this.scopeHighlightName = "";
+		this.state = {
+			...this.state,
+			revealed: false,
+			inSelection: false
+		};
+		this.matches = [];
+		this.highlightsTruncated = false;
+		this.totalMatches = 0;
+		this.scope = null;
+		this.trackedMatches = null;
+		this.currentMatch = null;
+		this.scheduler.cancel(FIND_RESEARCH_KEY);
+	}
+	detachEditHost(host) {
+		if (this.editHost !== host) return;
+		this.pendingResearch = false;
+		this.editHost = null;
+	}
+	open(options) {
+		const host = this.host;
+		if (!host || !host.hasDocument()) return false;
+		const searchString = this.seedSearchString();
+		this.state = {
+			...this.state,
+			searchString: searchString || this.state.searchString,
+			revealed: true,
+			replaceRevealed: options.replace || this.state.replaceRevealed
+		};
+		this.applyAutoFindInSelection(host);
+		this.emit({
+			type: "show",
+			replaceVisible: this.state.replaceRevealed
+		});
+		this.research(false);
+		this.focusWidget(options.focus);
+		return true;
+	}
+	ensureFindReady(focus) {
+		if (!this.state.revealed) return this.open({
+			replace: focus === "replace",
+			focus
+		});
+		if (this.matches.length === 0) this.research(false);
+		return this.state.searchString.length > 0;
+	}
+	research(moveCursor) {
+		if (!this.host) return;
+		if (!this.canPaintCurrentDocument()) {
+			this.pendingResearch = true;
+			if (moveCursor) this.selectFirstMatchFromSelection();
+			return;
+		}
+		this.pendingResearch = false;
+		this.scheduler.cancel(FIND_RESEARCH_KEY);
+		const found = this.findAll(false, FIND_MATCHES_LIMIT + 1);
+		this.highlightsTruncated = found.length > FIND_MATCHES_LIMIT;
+		this.totalMatches = this.highlightsTruncated ? this.countAll() : found.length;
+		this.adoptMatches(this.highlightsTruncated ? found.slice(0, FIND_MATCHES_LIMIT) : found);
+		this.currentMatch = matchAtSelection(this.matches, this.primarySelection());
+		this.updateHighlights();
+		this.updateWidget();
+		if (moveCursor && found.length > 0) this.selectFirstMatchFromSelection();
+	}
+	scheduleResearch() {
+		this.followPendingMatches();
+		this.scheduler.schedule({
+			key: FIND_RESEARCH_KEY,
+			taskClass: "background-derived",
+			delayMs: FIND_RESEARCH_DELAY_MS,
+			maxDelayMs: FIND_RESEARCH_MAX_DELAY_MS,
+			run: () => this.research(false)
+		});
+	}
+	/**
+	* Adopts a match set and hands it to the host to follow as far as it is painted.
+	*
+	* Handed over now rather than when an edit arrives: find is told about an edit
+	* once the text has already moved, and a range recorded against the document
+	* as it is by then is a range that will never shift.
+	*
+	* What the reader can see is the bound. A set stopping at the paint cap holds
+	* twenty thousand matches, and asking the host to carry all of them costs more
+	* per keystroke than the search this deferral exists to keep off it.
+	*/
+	adoptMatches(matches) {
+		this.matches = matches;
+		this.trackedMatches = this.host?.trackPaintedRanges(matches) ?? null;
+	}
+	/**
+	* Carries the painted matches through the edit that deferred their re-search.
+	*
+	* Until it lands they are what the reader sees, and the offsets they were found
+	* at address text that has since moved — so they are read back from where that
+	* text went. A match whose text is gone resolves to nothing and stops being
+	* painted.
+	*/
+	/** Takes the offsets again from what the host is following, after the line it follows to moved. */
+	refreshTrackedMatches() {
+		this.followPendingMatches();
+	}
+	followPendingMatches() {
+		if (!this.canPaintCurrentDocument()) return;
+		const tracked = this.trackedMatches;
+		if (!tracked || this.matches.length === 0) return;
+		this.matches = tracked.resolve().map((range) => ({
+			...range,
+			matches: null
+		}));
+		this.currentMatch = matchAtSelection(this.matches, this.primarySelection());
+		this.updateHighlights();
+		this.updateWidget();
+	}
+	applyReplacement(edits, timingName, selection) {
+		const editHost = this.editHost;
+		if (!editHost) return;
+		this.replacing = true;
+		try {
+			editHost.applyEdits(edits, timingName, selection);
+		} finally {
+			this.replacing = false;
+		}
+	}
+	selectNextReplacementMatch() {
+		const offset = this.primarySelection()?.endOffset ?? 0;
+		const match = this.searchFrom(findNextMatchFrom, offset, {});
+		if (!match) return;
+		this.host?.setSelection(match.start, match.end, "input.findNavigate", findReveal(match));
+	}
+	canPaintCurrentDocument() {
+		if (!this.editHost) return true;
+		const snapshot = this.editHost.textSnapshot();
+		return snapshot !== null && this.host?.hasTextSnapshot(snapshot) === true;
+	}
+	commandTextSource() {
+		if (!this.editHost) return this.host?.textSource();
+		const snapshot = this.editHost.textSnapshot();
+		return snapshot ? findTextSourceFromSnapshot(snapshot) : void 0;
+	}
+	commandSelections() {
+		return this.editHost?.getSelections() ?? this.host?.getSelections() ?? [];
+	}
+	commandSearchTarget() {
+		const source = this.commandTextSource();
+		return source ? this.searchTarget(source) : null;
+	}
+	findAll(captureMatches, limit = FIND_MATCHES_LIMIT) {
+		const search = this.searchTarget();
+		if (!search) return [];
+		return findMatches(search.source, this.state, search.scopes, captureMatches, limit);
+	}
+	countAll(before) {
+		const search = this.searchTarget();
+		return search ? countMatches(search.source, this.state, search.scopes, before) : 0;
+	}
+	searchFrom(find, offset, options) {
+		const search = this.commandSearchTarget();
+		if (!search) return null;
+		return find(search.source, this.state, offset, search.scopes, {
+			loop: this.options.loop,
+			...options
+		});
+	}
+	searchTarget(source = this.host?.textSource()) {
+		if (!source) return null;
+		const scopes = this.scopeRanges();
+		if (scopes && scopes.length === 0) return null;
+		return {
+			source,
+			scopes
+		};
+	}
+	scopeRanges() {
+		return this.scope?.resolve() ?? null;
+	}
+	selectFirstMatchFromSelection() {
+		const offset = this.primarySelection()?.endOffset ?? 0;
+		this.selectMatch(this.nextMatchAt(offset, false), false);
+	}
+	nextMatchAt(offset, escapeEmptyMatchAtOffset) {
+		return this.searchFrom(findNextMatchFrom, offset, { escapeEmptyMatchAtOffset });
+	}
+	selectMatch(match, committed = true) {
+		const host = this.host;
+		if (!match || !host) return false;
+		if (this.canPaintCurrentDocument()) this.currentMatch = match;
+		host.setSelection(match.start, match.end, "input.findNavigate", findReveal(match, committed));
+		if (!this.canPaintCurrentDocument()) return true;
+		this.updateHighlights();
+		this.updateWidget();
+		return true;
+	}
+	updateHighlights() {
+		if (!this.canPaintCurrentDocument()) return;
+		const host = this.host;
+		if (!host) return;
+		host.setRangeHighlight(this.matchHighlightName, this.matches, FIND_MATCH_STYLE);
+		host.setRangeHighlight(this.currentHighlightName, this.currentMatchRanges(), FIND_CURRENT_STYLE);
+		const scopes = this.scopeRanges();
+		if (scopes) {
+			host.setRangeHighlight(this.scopeHighlightName, scopes, FIND_SCOPE_STYLE);
+			return;
+		}
+		host.clearRangeHighlight(this.scopeHighlightName);
+	}
+	currentMatchRanges() {
+		return this.currentMatch ? [this.currentMatch] : [];
+	}
+	clearHighlights() {
+		const host = this.host;
+		if (!host || !this.matchHighlightName) return;
+		host.clearRangeHighlight(this.matchHighlightName);
+		host.clearRangeHighlight(this.currentHighlightName);
+		host.clearRangeHighlight(this.scopeHighlightName);
+	}
+	updateWidget() {
+		this.emit({
+			type: "update",
+			state: this.widgetState()
+		});
+	}
+	widgetState() {
+		return {
+			...this.state,
+			matchesCount: this.highlightsTruncated ? this.totalMatches : this.matches.length,
+			matchesPosition: this.currentMatchPosition(),
+			highlightsTruncated: this.highlightsTruncated
+		};
+	}
+	currentMatchPosition() {
+		if (!this.currentMatch) return 0;
+		const painted = findMatchIndex(this.matches, this.currentMatch);
+		if (painted >= 0 || !this.highlightsTruncated) return painted + 1;
+		return this.countAll(this.currentMatch.start) + 1;
+	}
+	focusWidget(focus) {
+		if (focus === "find") this.emit({
+			type: "focus",
+			target: "find"
+		});
+		if (focus === "replace") this.emit({
+			type: "focus",
+			target: "replace"
+		});
+	}
+	seedSearchString() {
+		if (this.options.seedSearchStringFromSelection === "never") return "";
+		const selection = this.primarySelection();
+		if (!selection) return "";
+		const source = this.commandTextSource();
+		if (!source) return "";
+		if (!selection.collapsed) return this.seedFromLiteralText(selectedSingleLineText(source, selection));
+		if (this.options.seedSearchStringFromSelection === "selection") return "";
+		return this.seedFromLiteralText(wordTextAtOffset(source, selection.headOffset));
+	}
+	seedFromLiteralText(value) {
+		return this.state.isRegex ? escapeRegExpCharacters(value) : value;
+	}
+	applyAutoFindInSelection(host) {
+		const scopes = nonEmptySelectionRanges(this.commandSelections());
+		if (scopes.length === 0) return;
+		if (this.options.autoFindInSelection === "never") return;
+		if (this.options.autoFindInSelection === "always") {
+			this.state = {
+				...this.state,
+				inSelection: true
+			};
+			this.scope = host.trackRanges(scopes);
+			return;
+		}
+		const source = this.commandTextSource();
+		if (!source || !hasMultilineScope(source, scopes)) return;
+		this.state = {
+			...this.state,
+			inSelection: true
+		};
+		this.scope = host.trackRanges(scopes);
+	}
+	replacePattern() {
+		if (this.state.isRegex) return parseReplaceString(this.state.replaceString);
+		return ReplacePattern.fromStaticValue(this.state.replaceString);
+	}
+	primarySelection() {
+		return this.commandSelections()[0] ?? null;
+	}
+	emit(event) {
+		for (const listener of this.listeners) listener(event);
+	}
+};
+function resolveFindOptions(options) {
+	return {
+		loop: options.loop ?? true,
+		seedSearchStringFromSelection: options.seedSearchStringFromSelection ?? "always",
+		findOnType: options.findOnType ?? true,
+		cursorMoveOnType: options.cursorMoveOnType ?? true,
+		autoFindInSelection: options.autoFindInSelection ?? "never"
+	};
+}
+function isFindDocumentUpdate(kind) {
+	return kind === "document" || kind === "content" || kind === "clear";
+}
+function selectedSingleLineText(source, selection) {
+	if (selection.endOffset - selection.startOffset >= SEARCH_STRING_MAX_LENGTH) return "";
+	if (spansLines(source, selection.startOffset, selection.endOffset)) return "";
+	return source.readRange(selection.startOffset, selection.endOffset);
+}
+function wordTextAtOffset(source, offset) {
+	const line = findLineRange(source, offset);
+	const text = source.readRange(line.start, line.end);
+	const word = wordRangeAtOffset(text, offset - line.start);
+	return text.slice(word.start, word.end);
+}
+function nonEmptySelectionRanges(selections) {
+	return selections.filter((selection) => !selection.collapsed).map((selection) => ({
+		start: selection.startOffset,
+		end: selection.endOffset
+	}));
+}
+function hasMultilineScope(source, scopes) {
+	return scopes.some((scope) => spansLines(source, scope.start, scope.end));
+}
+function spansLines(source, start, end) {
+	const lineStartsView = source.lineStartsView;
+	return lineStartsView.indexForOffset(start) !== lineStartsView.indexForOffset(end);
+}
+function matchAtSelection(matches, selection) {
+	if (!selection) return null;
+	return matches.find((match) => match.start === selection.startOffset && match.end === selection.endOffset) ?? null;
+}
+function orderedMatchSelections(matches, currentSelection) {
+	const selections = matches.map(selectionForMatch);
+	const currentMatch = matchAtSelection(matches, currentSelection);
+	const currentIndex = currentMatch ? findMatchIndex(matches, currentMatch) : -1;
+	if (!currentSelection || currentIndex < 0) return selections;
+	const current = {
+		anchor: currentSelection.anchorOffset,
+		head: currentSelection.headOffset,
+		affinity: currentSelection.affinity
+	};
+	if (currentIndex === 0) return [current, ...selections.slice(1)];
+	return [
+		current,
+		...selections.slice(0, currentIndex),
+		...selections.slice(currentIndex + 1)
+	];
+}
+function selectionForMatch(match) {
+	return {
+		anchor: match.start,
+		head: match.end,
+		affinity: "after"
+	};
+}
+function mergeAdjacentReplaceEdits(edits) {
+	const sorted = edits.toSorted((left, right) => left.from - right.from || left.to - right.to);
+	const merged = [];
+	for (const edit of sorted) mergeReplaceEdit(merged, edit);
+	return merged;
+}
+function mergeReplaceEdit(merged, edit) {
+	const previous = merged.at(-1);
+	if (!previous || previous.to !== edit.from) {
+		merged.push({ ...edit });
+		return;
+	}
+	merged[merged.length - 1] = {
+		from: previous.from,
+		to: edit.to,
+		text: previous.text + edit.text
+	};
+}
+//#endregion
+export { EditorFindController, FIND_HIGHLIGHT_Z_INDEX };
+
+//# sourceMappingURL=findController.js.map