M2.4: Find tool window in a new bottom panel

- Bottom panel under editor and project tree (resizable, collapsible,
  closable) for Find and later tool windows.
- Find store: search.find with options and include/exclude globs, results
  streamed and sorted by file, events held until the searchId answer, a
  new search cancels the running one, refused queries shown in place.
- Find tool window: toggles, counts, cancel, truncated hint, highlighted
  previews, keyboard navigation, Enter or click runs editor.reveal.
- UI command find.open (Mod+Alt+F) with prefill from the selection or the
  word at the cursor; find.open {query} from agents searches at once.
- 26 Vitest tests; progress docs and architecture updated.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
danny 2026-10-17 12:42:53 +02:00
parent 864a468b34
commit 097bbd9409
16 changed files with 1923 additions and 25 deletions

View file

@ -22,6 +22,7 @@ export interface UiCommandSpec {
/** The frontend's UI commands. */
export const UI_COMMANDS: readonly UiCommandSpec[] = [
{ id: "editor.reveal", labelKey: "command.editor.reveal" },
{ id: "find.open", labelKey: "command.find.open", defaultShortcut: "Mod+Alt+F" },
{ id: "palette.open", labelKey: "command.palette.open", defaultShortcut: "Mod+Shift+P" },
{ id: "settings.open", labelKey: "command.settings.open", defaultShortcut: "Mod+," },
{ id: "view.toggleProjectTree", labelKey: "command.view.toggleProjectTree", defaultShortcut: "Mod+1" },

View file

@ -0,0 +1,566 @@
<script setup lang="ts">
/**
* The Find tool window (M2.4), shown in the bottom panel: a query field
* with case, whole-word and regex toggles, include and exclude globs
* (comma-separated), a status line with counts, and the results grouped by
* file with the match highlighted in the line preview.
*
* - **Searching:** Enter in any field or the search button starts a search;
* toggling an option repeats the last one. The cancel button stops a
* running search. A refused query (bad regex or glob) shows its message
* under the fields.
* - **Results:** a listbox of matches; Up/Down, Page Up/Down, Home and End
* move the selection, Down in a field moves into the list. Enter or a
* click opens the match through the command `editor.reveal`.
* - State lives in the Find store (`stores/find.ts`), so the results survive
* closing the panel.
*/
import { CaseSensitive, CircleStop, Regex, Search, WholeWord } from "@lucide/vue";
import { computed, nextTick, onMounted, ref, watch } from "vue";
import { useCommandsStore } from "../../commands/store";
import { t } from "../../i18n";
import { baseName } from "../../stores/editor";
import { useFindStore, type FindMatch, type FindRow } from "../../stores/find";
const find = useFindStore();
const commands = useCommandsStore();
/** The query field. */
const queryInput = ref<HTMLInputElement | null>(null);
/** The result list. */
const list = ref<HTMLElement | null>(null);
/** Rows moved by Page Up and Page Down. */
const PAGE = 10;
/** The status line under the fields. */
const status = computed(() => {
const counts = { matches: String(find.matchCount), files: String(find.files.length) };
if (find.running) {
return t("find.status.running", counts);
}
const done = find.summary;
if (!done) {
return find.error === null ? t("find.status.idle") : "";
}
const totals = { matches: String(done.matches), files: String(done.files), ms: String(done.elapsedMs) };
if (done.cancelled) {
return t("find.status.cancelled", totals);
}
return done.matches === 0 ? t("find.status.none") : t("find.status.done", totals);
});
/**
* The DOM id of a row's option element.
*
* @param index - the row's index in the flat list.
*/
function optionId(index: number): string {
return `find-row-${String(index)}`;
}
/** A file with its rows and their indexes in the flat list. */
interface FindGroup {
/** Project-relative path. */
path: string;
/** The file's rows with their flat index. */
rows: { row: FindRow; index: number }[];
}
/** The rows grouped by file, in display order. */
const groups = computed<FindGroup[]>(() => {
const out: FindGroup[] = [];
find.rows.forEach((row, index) => {
const last = out[out.length - 1];
if (last?.path === row.path) {
last.rows.push({ row, index });
} else {
out.push({ path: row.path, rows: [{ row, index }] });
}
});
return out;
});
/**
* The preview split around the match, without leading indentation.
*
* @param match - the match.
* @returns the text before, the match and the text after.
*/
function parts(match: FindMatch): { before: string; hit: string; after: string } {
const text = match.preview;
const lead = Math.min(text.length - text.trimStart().length, match.previewColumn);
const end = Math.min(text.length, match.previewColumn + match.length);
return {
before: text.slice(lead, match.previewColumn),
hit: text.slice(match.previewColumn, end),
after: text.slice(end),
};
}
/**
* The directory part of a path, empty at the root.
*
* @param path - project-relative path.
*/
function dirName(path: string): string {
const slash = path.lastIndexOf("/");
return slash < 0 ? "" : path.slice(0, slash);
}
/**
* Opens a match in the editor.
*
* @param row - the row.
*/
function openRow(row: FindRow): void {
find.select(row.key);
void commands.execute("editor.reveal", { path: row.path, line: row.match.line, column: row.match.column });
}
/** Starts a search for the fields' current values. */
function submit(): void {
void find.search();
}
/**
* Toggles an option and repeats the last search, if there was one.
*
* @param option - which option.
*/
function toggle(option: "caseSensitive" | "wholeWord" | "regex"): void {
find[option] = !find[option];
if (find.query !== "" && (find.running || find.summary !== null || find.error !== null)) {
void find.search();
}
}
/**
* Moves from a field into the result list.
*
* @param event - the key event.
*/
function onFieldKey(event: KeyboardEvent): void {
if (event.key === "ArrowDown" && find.rows.length > 0) {
event.preventDefault();
if (find.selectedIndex < 0) {
find.move(1);
}
list.value?.focus();
}
}
/**
* Keyboard navigation in the result list.
*
* @param event - the key event.
*/
function onListKey(event: KeyboardEvent): void {
const moves: Record<string, number> = {
ArrowDown: 1,
ArrowUp: -1,
PageDown: PAGE,
PageUp: -PAGE,
Home: -Infinity,
End: Infinity,
};
const delta = moves[event.key];
if (delta !== undefined) {
event.preventDefault();
find.move(Number.isFinite(delta) ? delta : delta > 0 ? find.rows.length : -find.rows.length);
} else if (event.key === "Enter") {
const row = find.rows[find.selectedIndex];
if (row) {
event.preventDefault();
openRow(row);
}
}
}
/** Focuses and selects the query field. */
async function focusQuery(): Promise<void> {
await nextTick();
queryInput.value?.focus();
queryInput.value?.select();
}
watch(() => find.focusRequest, focusQuery);
watch(
() => find.selectedIndex,
async (index) => {
await nextTick();
const element = index < 0 ? null : document.getElementById(optionId(index));
if (element && typeof element.scrollIntoView === "function") {
element.scrollIntoView({ block: "nearest" });
}
},
);
onMounted(() => {
void focusQuery();
});
</script>
<template>
<div
class="find"
data-test="find"
>
<form
class="find__form"
@submit.prevent="submit"
>
<div class="find__line">
<span class="find__field find__field--query">
<Search
:size="14"
class="find__icon"
/>
<input
ref="queryInput"
v-model="find.query"
class="find__input"
type="text"
spellcheck="false"
:aria-label="t('find.query.label')"
:placeholder="t('find.query.placeholder')"
:aria-invalid="find.error !== null"
data-test="find-query"
@keydown="onFieldKey"
>
<button
type="button"
class="find__toggle"
:aria-pressed="find.caseSensitive"
:title="t('find.option.caseSensitive')"
:aria-label="t('find.option.caseSensitive')"
data-test="find-case"
@click="toggle('caseSensitive')"
>
<CaseSensitive :size="16" />
</button>
<button
type="button"
class="find__toggle"
:aria-pressed="find.wholeWord"
:title="t('find.option.wholeWord')"
:aria-label="t('find.option.wholeWord')"
data-test="find-word"
@click="toggle('wholeWord')"
>
<WholeWord :size="16" />
</button>
<button
type="button"
class="find__toggle"
:aria-pressed="find.regex"
:title="t('find.option.regex')"
:aria-label="t('find.option.regex')"
data-test="find-regex"
@click="toggle('regex')"
>
<Regex :size="16" />
</button>
</span>
<button
v-if="find.running"
type="button"
class="find__action"
data-test="find-cancel"
@click="find.cancel()"
>
<CircleStop :size="14" />
{{ t("common.cancel") }}
</button>
<button
v-else
type="submit"
class="find__action"
data-test="find-submit"
>
{{ t("find.action.search") }}
</button>
</div>
<div class="find__line">
<span class="find__field">
<input
v-model="find.include"
class="find__input"
type="text"
spellcheck="false"
:aria-label="t('find.include.label')"
:placeholder="t('find.include.placeholder')"
data-test="find-include"
@keydown="onFieldKey"
>
</span>
<span class="find__field">
<input
v-model="find.exclude"
class="find__input"
type="text"
spellcheck="false"
:aria-label="t('find.exclude.label')"
:placeholder="t('find.exclude.placeholder')"
data-test="find-exclude"
@keydown="onFieldKey"
>
</span>
</div>
</form>
<div
class="find__status"
role="status"
data-test="find-status"
>
<span>{{ status }}</span>
<span
v-if="find.summary?.truncated"
class="find__truncated"
data-test="find-truncated"
>{{ t("find.status.truncated", { matches: String(find.summary.matches) }) }}</span>
</div>
<div
v-if="find.error"
class="find__error"
role="alert"
data-test="find-error"
>
{{ find.error }}
</div>
<div
ref="list"
class="find__results"
role="listbox"
tabindex="0"
:aria-label="t('find.results.label')"
:aria-activedescendant="find.selectedIndex >= 0 ? optionId(find.selectedIndex) : undefined"
data-test="find-results"
@keydown="onListKey"
>
<div
v-for="group in groups"
:key="group.path"
role="group"
:aria-label="group.path"
class="find__file"
>
<div
class="find__file-header"
data-test="find-file"
>
<span class="find__file-name">{{ baseName(group.path) }}</span>
<span class="find__file-dir">{{ dirName(group.path) }}</span>
<span class="find__file-count">{{ group.rows.length }}</span>
</div>
<div
v-for="{ row, index } in group.rows"
:id="optionId(index)"
:key="row.key"
role="option"
class="find__row"
:class="{ 'find__row--selected': find.selectedKey === row.key }"
:aria-selected="find.selectedKey === row.key"
data-test="find-row"
@click="openRow(row)"
>
<span class="find__line-number">{{ row.match.line + 1 }}</span>
<span class="find__preview">{{ parts(row.match).before }}<mark
class="find__hit"
data-test="find-hit"
>{{ parts(row.match).hit }}</mark>{{ parts(row.match).after }}</span>
</div>
</div>
</div>
</div>
</template>
<style scoped>
.find {
display: flex;
flex-direction: column;
flex: 1;
min-height: 0;
}
.find__form {
display: flex;
flex-direction: column;
gap: var(--lt-space-s, 4px);
padding: var(--lt-space-s, 4px) var(--lt-space-m, 8px);
}
.find__line {
display: flex;
gap: var(--lt-space-s, 4px);
}
.find__field {
display: flex;
align-items: center;
flex: 1;
min-width: 0;
gap: var(--lt-space-xs, 2px);
padding: 0 var(--lt-space-xs, 2px) 0 var(--lt-space-s, 4px);
background: var(--lt-editor-bg);
border: 1px solid var(--lt-border);
border-radius: var(--lt-radius, 4px);
}
.find__field:focus-within {
border-color: var(--lt-accent);
}
.find__icon {
flex: none;
color: var(--lt-fg-muted);
}
.find__input {
flex: 1;
min-width: 0;
padding: var(--lt-space-xs, 2px);
font: inherit;
color: var(--lt-fg);
background: transparent;
border: none;
outline: none;
}
.find__input::placeholder {
color: var(--lt-fg-muted);
}
.find__toggle {
display: inline-flex;
align-items: center;
justify-content: center;
padding: var(--lt-space-xs, 2px);
color: var(--lt-fg-muted);
background: transparent;
border: 1px solid transparent;
border-radius: var(--lt-radius, 4px);
cursor: pointer;
}
.find__toggle:hover {
color: var(--lt-fg);
}
.find__toggle[aria-pressed="true"] {
color: var(--lt-fg);
background: var(--lt-editor-match-bg);
border-color: var(--lt-accent);
}
.find__toggle:focus-visible,
.find__action:focus-visible {
outline: 2px solid var(--lt-accent);
}
.find__action {
display: inline-flex;
align-items: center;
gap: var(--lt-space-xs, 2px);
padding: 0 var(--lt-space-m, 8px);
font: inherit;
color: var(--lt-fg);
background: transparent;
border: 1px solid var(--lt-border);
border-radius: var(--lt-radius, 4px);
cursor: pointer;
}
.find__status {
display: flex;
gap: var(--lt-space-m, 8px);
padding: 0 var(--lt-space-m, 8px) var(--lt-space-s, 4px);
color: var(--lt-fg-muted);
}
.find__truncated {
color: var(--lt-fg);
}
.find__error {
padding: var(--lt-space-xs, 2px) var(--lt-space-m, 8px);
color: var(--lt-fg);
background: color-mix(in srgb, var(--lt-error) 15%, var(--lt-bg));
}
.find__results {
flex: 1;
min-height: 0;
overflow: auto;
border-top: 1px solid var(--lt-border);
outline: none;
}
.find__results:focus-visible {
box-shadow: inset 0 0 0 1px var(--lt-accent);
}
.find__file-header {
display: flex;
align-items: baseline;
gap: var(--lt-space-m, 8px);
padding: var(--lt-space-xs, 2px) var(--lt-space-m, 8px);
white-space: nowrap;
}
.find__file-name {
font-weight: 600;
}
.find__file-dir {
overflow: hidden;
text-overflow: ellipsis;
color: var(--lt-fg-muted);
}
.find__file-count {
margin-left: auto;
color: var(--lt-fg-muted);
}
.find__row {
display: flex;
gap: var(--lt-space-m, 8px);
padding: 0 var(--lt-space-m, 8px) 0 var(--lt-space-l, 24px);
font-family: var(--lt-font-mono);
white-space: pre;
cursor: pointer;
}
.find__row:hover {
background: color-mix(in srgb, var(--lt-fg) 6%, transparent);
}
.find__row--selected,
.find__row--selected:hover {
background: var(--lt-editor-selection-bg);
}
.find__line-number {
flex: none;
min-width: 4ch;
text-align: right;
color: var(--lt-fg-muted);
}
.find__row--selected .find__line-number {
color: var(--lt-fg);
}
.find__preview {
overflow: hidden;
text-overflow: ellipsis;
}
.find__hit {
color: var(--lt-fg);
background: var(--lt-editor-match-bg);
border-radius: 2px;
}
</style>

View file

@ -0,0 +1,239 @@
<script setup lang="ts">
/**
* The bottom panel of the main window: a tool window docked under the
* editor (Find since M2.4; later Problems, Terminal and others). A header
* with the title, a collapse/expand button and a close button, the content
* slot, and a splitter on the top edge to resize it.
*
* The splitter is dragged with the pointer or moved with Up/Down (Shift for
* larger steps) when focused. Collapsed, only the header shows. Height and
* expansion are view state, emitted through `v-model:height` and
* `v-model:open`; the close button emits `close`, and the owner decides
* what closing means.
*/
import { ChevronDown, ChevronUp, X } from "@lucide/vue";
import { computed } from "vue";
import { t } from "../../i18n";
/** Props of the bottom panel. */
const props = withDefaults(
defineProps<{
/** Title shown in the header and as the accessible name. */
title: string;
/** Height of the content in CSS pixels, header excluded. */
height?: number;
/** Smallest height the splitter allows. */
minHeight?: number;
/** Largest height the splitter allows. */
maxHeight?: number;
/** Whether the panel is expanded (true) or collapsed to its header. */
open?: boolean;
}>(),
{ height: 240, minHeight: 80, maxHeight: 900, open: true },
);
/** Events of the bottom panel. */
const emit = defineEmits<{
/** New height after a resize. */
"update:height": [height: number];
/** New expansion after collapse or expand. */
"update:open": [open: boolean];
/** The close button was pressed. */
close: [];
}>();
/** Inline style carrying the current height. */
const bodyStyle = computed(() => ({ height: `${String(props.height)}px` }));
/**
* Emits a height clamped to the allowed range.
*
* @param height - the wanted height.
*/
function setHeight(height: number): void {
emit("update:height", Math.round(Math.min(props.maxHeight, Math.max(props.minHeight, height))));
}
/**
* Starts a pointer drag on the splitter; dragging up makes the panel taller.
*
* @param event - the pointer-down event.
*/
function onSplitterDown(event: PointerEvent): void {
const target = event.currentTarget;
if (!(target instanceof HTMLElement)) {
return;
}
const startY = event.clientY;
const startHeight = props.height;
target.setPointerCapture(event.pointerId);
const move = (e: PointerEvent): void => {
setHeight(startHeight - (e.clientY - startY));
};
const up = (e: PointerEvent): void => {
target.releasePointerCapture(e.pointerId);
target.removeEventListener("pointermove", move);
target.removeEventListener("pointerup", up);
};
target.addEventListener("pointermove", move);
target.addEventListener("pointerup", up);
}
/**
* Resizes with the keyboard when the splitter has focus.
*
* @param event - the key event.
*/
function onSplitterKey(event: KeyboardEvent): void {
const step = event.shiftKey ? 48 : 12;
if (event.key === "ArrowUp") {
setHeight(props.height + step);
} else if (event.key === "ArrowDown") {
setHeight(props.height - step);
} else {
return;
}
event.preventDefault();
}
</script>
<template>
<section
class="bottom-panel"
:aria-label="title"
data-test="bottom-panel"
>
<div
v-if="open"
class="bottom-panel__splitter"
role="separator"
aria-orientation="horizontal"
tabindex="0"
:aria-valuenow="height"
:aria-valuemin="minHeight"
:aria-valuemax="maxHeight"
:aria-label="t('common.toolWindow.resize', { title })"
data-test="bottom-panel-splitter"
@pointerdown="onSplitterDown"
@keydown="onSplitterKey"
/>
<header class="bottom-panel__header">
<span class="bottom-panel__title">{{ title }}</span>
<span class="bottom-panel__actions">
<button
type="button"
class="bottom-panel__button"
:title="open ? t('common.toolWindow.collapse', { title }) : t('common.toolWindow.expand', { title })"
:aria-label="open ? t('common.toolWindow.collapse', { title }) : t('common.toolWindow.expand', { title })"
:aria-expanded="open"
data-test="bottom-panel-toggle"
@click="emit('update:open', !open)"
>
<ChevronDown
v-if="open"
:size="16"
/>
<ChevronUp
v-else
:size="16"
/>
</button>
<button
type="button"
class="bottom-panel__button"
:title="t('common.toolWindow.hide', { title })"
:aria-label="t('common.toolWindow.hide', { title })"
data-test="bottom-panel-close"
@click="emit('close')"
>
<X :size="16" />
</button>
</span>
</header>
<div
v-if="open"
class="bottom-panel__body"
:style="bodyStyle"
>
<slot />
</div>
</section>
</template>
<style scoped>
.bottom-panel {
position: relative;
display: flex;
flex-direction: column;
flex: none;
max-height: 75%;
background: var(--lt-bg);
border-top: 1px solid var(--lt-border);
}
.bottom-panel__header {
display: flex;
align-items: center;
justify-content: space-between;
flex: none;
height: var(--lt-header-height, 28px);
padding: 0 var(--lt-space-s, 4px) 0 var(--lt-space-m, 8px);
border-bottom: 1px solid var(--lt-border);
}
.bottom-panel__title {
font-weight: 600;
overflow: hidden;
text-overflow: ellipsis;
white-space: nowrap;
}
.bottom-panel__actions {
display: inline-flex;
gap: var(--lt-space-xs, 2px);
}
.bottom-panel__body {
display: flex;
flex-direction: column;
min-height: 0;
flex-shrink: 1;
}
.bottom-panel__button {
display: inline-flex;
align-items: center;
justify-content: center;
padding: var(--lt-space-xs, 2px);
color: var(--lt-fg-muted);
background: transparent;
border: none;
border-radius: var(--lt-radius, 4px);
cursor: pointer;
}
.bottom-panel__button:hover {
color: var(--lt-fg);
background: color-mix(in srgb, var(--lt-fg) 8%, transparent);
}
.bottom-panel__button:focus-visible {
outline: 2px solid var(--lt-accent);
}
.bottom-panel__splitter {
position: absolute;
top: -3px;
right: 0;
left: 0;
height: 6px;
cursor: row-resize;
z-index: 1;
}
.bottom-panel__splitter:hover,
.bottom-panel__splitter:focus-visible {
outline: none;
background: color-mix(in srgb, var(--lt-accent) 50%, transparent);
}
</style>

View file

@ -1,41 +1,60 @@
<script setup lang="ts">
/**
* Layout of the main window: the Project tool window on the left, the
* editor area in the middle and the status bar along the bottom.
* editor area in the middle, the bottom panel under both (M2.4) and the
* status bar along the bottom.
*
* The editor area is a slot so the editor (M1.6) can replace the
* placeholder without touching the layout. The layout supplies the UI
* command `view.toggleProjectTree` (`Mod+1`), which shows or hides the
* Project tool window.
*
* The bottom panel ({@link BottomPanel}) holds the Find tool window. It
* appears with the UI command `find.open` (`Mod+Alt+F`, supplied here so it
* works before the panel exists), collapses to its header and closes from
* its header; the Find store keeps the results while it is closed.
*/
import { onBeforeUnmount, onMounted, ref } from "vue";
import { useCommandsStore } from "../../commands/store";
import { t } from "../../i18n";
import { useFindStore } from "../../stores/find";
import FindToolWindow from "../find/FindToolWindow.vue";
import ProjectToolWindow from "../project/ProjectToolWindow.vue";
import StatusBar from "../StatusBar.vue";
import BottomPanel from "./BottomPanel.vue";
import ToolWindow from "./ToolWindow.vue";
/** Width of the left tool window in CSS pixels. */
const leftWidth = ref(260);
/** Whether the left tool window is shown. */
const leftOpen = ref(true);
/** Height of the bottom panel's content in CSS pixels. */
const bottomHeight = ref(240);
const commands = useCommandsStore();
const find = useFindStore();
/** Withdraws the command handler; set while mounted. */
let withdraw: (() => void) | null = null;
/** Withdraws the command handlers; filled while mounted. */
let withdraw: (() => void)[] = [];
onMounted(() => {
withdraw = commands.provide("view.toggleProjectTree", {
run: () => {
leftOpen.value = !leftOpen.value;
},
});
find.start();
withdraw = [
commands.provide("view.toggleProjectTree", {
run: () => {
leftOpen.value = !leftOpen.value;
},
}),
commands.provide("find.open", { run: (params) => find.open(params) }),
];
});
onBeforeUnmount(() => {
withdraw?.();
withdraw = null;
for (const fn of withdraw) {
fn();
}
withdraw = [];
find.stop();
});
</script>
@ -56,6 +75,15 @@ onBeforeUnmount(() => {
<slot />
</main>
</div>
<BottomPanel
v-if="find.visible"
v-model:height="bottomHeight"
v-model:open="find.expanded"
:title="t('find.toolWindow.title')"
@close="find.hide()"
>
<FindToolWindow />
</BottomPanel>
<StatusBar />
</div>
</template>

View file

@ -1,6 +1,7 @@
{
"app.statusBar.version": "{name} {version}",
"command.editor.reveal": "Reveal Cursor in Editor",
"command.find.open": "Find in Files…",
"command.key.alt": "Alt",
"command.key.cmd": "Cmd",
"command.key.ctrl": "Ctrl",
@ -16,6 +17,8 @@
"common.dontSave": "Don't Save",
"common.error.unexpectedResult": "unexpected result of {command}",
"common.save": "Save",
"common.toolWindow.collapse": "Collapse {title}",
"common.toolWindow.expand": "Expand {title}",
"common.toolWindow.hide": "Hide {title}",
"common.toolWindow.resize": "Resize {title}",
"common.toolWindow.show": "Show {title}",
@ -28,6 +31,24 @@
"editor.tabs.close": "Close {name}",
"editor.tabs.label": "Editor tabs",
"editor.tabs.unsaved": "unsaved changes",
"find.action.search": "Search",
"find.exclude.label": "Exclude files",
"find.exclude.placeholder": "Exclude, e.g. *.min.js, var/**",
"find.include.label": "Include files",
"find.include.placeholder": "Include, e.g. *.php, src/**",
"find.option.caseSensitive": "Match case",
"find.option.regex": "Regular expression",
"find.option.wholeWord": "Whole words",
"find.query.label": "Text to find",
"find.query.placeholder": "Find in files",
"find.results.label": "Search results",
"find.status.cancelled": "Cancelled · {matches} matches in {files} files",
"find.status.done": "{matches} matches in {files} files · {ms} ms",
"find.status.idle": "Type a text and press Enter",
"find.status.none": "No matches",
"find.status.running": "Searching… {matches} matches in {files} files",
"find.status.truncated": "Stopped at {matches} matches; narrow the query or the files to see the rest",
"find.toolWindow.title": "Find",
"notification.close": "Close notification",
"notification.command.failed": "{command} failed: {message}",
"notification.project.notLocal": "The chosen folder is not on this computer: {reason}",

View file

@ -61,6 +61,30 @@ export type EngineEventPayload =
kind: "recoveryResolved";
/** Paths restored or discarded; unchecked, it comes from the engine. */
paths: unknown;
}
| {
kind: "searchResults";
/** The search, as `search.find` returned it; unchecked. */
searchId: unknown;
/** Project-relative path of the file; unchecked. */
path: unknown;
/** `[{line, column, length, preview, previewColumn}]`; unchecked. */
matches: unknown;
}
| {
kind: "searchDone";
/** The search; unchecked, it comes from the engine. */
searchId: unknown;
/** Files with reported matches; unchecked. */
files: unknown;
/** Matches reported; unchecked. */
matches: unknown;
/** Whether the match cap left matches out; unchecked. */
truncated: unknown;
/** Whether the search was cancelled; unchecked. */
cancelled: unknown;
/** Wall time in milliseconds; unchecked. */
elapsedMs: unknown;
};
/** Callback receiving engine events. */

469
ui/src/stores/find.ts Normal file
View file

@ -0,0 +1,469 @@
/**
* The Find tool window's state (M2.4): the query and its options, the
* running search and its results, grouped by file.
*
* - **Searching:** {@link useFindStore}'s `search` runs `search.find` and
* keeps the returned `searchId`. Results arrive as `searchResults` events
* (one per file, in no fixed order; the store keeps files sorted by path)
* and end with `searchDone`. Events of other searches are ignored. Events
* that arrive while `search.find` has not answered yet are held and
* replayed once the id is known, because events and command results
* travel on different channels.
* - **One search at a time:** a new search cancels the running one
* (`search.cancel`); the engine does not do that by itself.
* - **Errors:** a refused search (`invalid_params` for a bad regex or glob)
* shows its message in the window, not as a toast.
* - **Opening:** `open` shows the panel, takes the query from the params
* (an agent's `find.open {query}` searches at once) or from the editor
* (selection or word at the cursor) and asks the window to focus its field.
* - **Untrusted input:** event fields are checked; malformed matches are
* dropped.
*/
import type { EditorState } from "@codemirror/state";
import { defineStore } from "pinia";
import { computed, ref, shallowRef } from "vue";
import { t } from "../i18n";
import { onEngineEvent, run, type EngineEventPayload, type JsonValue } from "../ipc";
import { useEditorStore } from "./editor";
/** One match as the window shows it. */
export interface FindMatch {
/** 0-based line. */
line: number;
/** 0-based column in UTF-16 code units. */
column: number;
/** Length of the match in UTF-16 code units, at least 1. */
length: number;
/** The line, or a window of it around the match. */
preview: string;
/** Start of the match inside {@link FindMatch.preview}. */
previewColumn: number;
}
/** The matches of one file. */
export interface FindFile {
/** Project-relative path. */
path: string;
/** Matches in line order. */
matches: FindMatch[];
}
/** Totals of a finished search, from `searchDone`. */
export interface FindSummary {
/** Files with matches. */
files: number;
/** Matches. */
matches: number;
/** Whether the match cap left matches out. */
truncated: boolean;
/** Whether the search was cancelled. */
cancelled: boolean;
/** Wall time in milliseconds. */
elapsedMs: number;
}
/** A match in the flat result order, for keyboard navigation. */
export interface FindRow {
/** Stable key: path and match index. */
key: string;
/** Path of the file. */
path: string;
/** The match. */
match: FindMatch;
}
/** Longest query taken from the editor selection, in UTF-16 code units. */
export const MAX_PREFILL = 1000;
/** Most events held while `search.find` has not answered. */
const MAX_EARLY_EVENTS = 5000;
/**
* The query `find.open` takes from an editor: the main selection if it is
* not empty and has no line break, else the word at the cursor.
*
* @param state - the active editor state, if any.
* @returns the text, or null when there is nothing to take.
*/
export function prefillFrom(state: EditorState | undefined): string | null {
if (!state) {
return null;
}
const { from, to, head } = state.selection.main;
if (from !== to && to - from <= MAX_PREFILL) {
const text = state.sliceDoc(from, to);
if (!/[\r\n]/.test(text) && text.trim() !== "") {
return text;
}
}
const word = state.wordAt(head);
return word ? state.sliceDoc(word.from, word.to) : null;
}
/**
* Splits a comma-separated list of globs.
*
* @param text - what the user typed, for example `*.php, src/**`.
*/
export function splitGlobs(text: string): string[] {
return text
.split(",")
.map((glob) => glob.trim())
.filter((glob) => glob !== "");
}
/**
* Reads a non-negative integer field.
*
* @param value - an untrusted field.
*/
function count(value: unknown): number | null {
return typeof value === "number" && Number.isInteger(value) && value >= 0 ? value : null;
}
/**
* Reads the matches of a `searchResults` event, dropping malformed ones and
* clamping the highlight into the preview.
*
* @param raw - the untrusted `matches` field.
*/
export function toMatches(raw: unknown): FindMatch[] {
if (!Array.isArray(raw)) {
return [];
}
const out: FindMatch[] = [];
for (const item of raw as unknown[]) {
if (typeof item !== "object" || item === null) {
continue;
}
const m = item as Record<string, unknown>;
const line = count(m.line);
const column = count(m.column);
const length = count(m.length);
const previewColumn = count(m.previewColumn);
if (line === null || column === null || length === null || previewColumn === null || typeof m.preview !== "string") {
continue;
}
const start = Math.min(previewColumn, m.preview.length);
out.push({ line, column, length: Math.max(1, length), preview: m.preview, previewColumn: start });
}
return out;
}
/**
* Index at which a path belongs in a list sorted by path.
*
* @param files - files sorted by path.
* @param path - the path to place.
*/
function insertionIndex(files: readonly FindFile[], path: string): number {
let low = 0;
let high = files.length;
while (low < high) {
const mid = (low + high) >> 1;
const other = files[mid]?.path ?? "";
if (other < path) {
low = mid + 1;
} else {
high = mid;
}
}
return low;
}
/** Store of the Find tool window. */
export const useFindStore = defineStore("find", () => {
const editor = useEditorStore();
/** Whether the panel exists in the layout (after the first `find.open`). */
const visible = ref(false);
/** Whether the panel is expanded (false: collapsed to its header). */
const expanded = ref(true);
/** The query text. */
const query = ref("");
/** Whether the query is a regular expression. */
const regex = ref(false);
/** Whether case matters. */
const caseSensitive = ref(false);
/** Whether only whole words match. */
const wholeWord = ref(false);
/** Include globs, comma-separated. */
const include = ref("");
/** Exclude globs, comma-separated. */
const exclude = ref("");
/** Id of the current search, null before the engine answered. */
const searchId = ref<number | null>(null);
/** Whether a search is running. */
const running = ref(false);
/** Files with matches, sorted by path; replaced on every change. */
const files = shallowRef<FindFile[]>([]);
/** Totals once the search ended. */
const summary = ref<FindSummary | null>(null);
/** Message of a refused search or cancel, shown in the window. */
const error = ref<string | null>(null);
/** Key of the selected row, see {@link FindRow}. */
const selectedKey = ref<string | null>(null);
/** Bumped when the window should focus and select its query field. */
const focusRequest = ref(0);
/** Counter of searches started, so a late answer of an older one is dropped. */
let generation = 0;
/** Whether `search.find` was sent and has not answered. */
let awaitingId = false;
/** Search events that arrived while {@link awaitingId}. */
let early: EngineEventPayload[] = [];
/** Ends the event subscription; set while started. */
let unsubscribe: (() => void) | null = null;
/** Every match in display order. */
const rows = computed<FindRow[]>(() =>
files.value.flatMap((file) =>
file.matches.map((match, i) => ({ key: `${file.path}\u0000${String(i)}`, path: file.path, match })),
),
);
/** Matches received so far. */
const matchCount = computed(() => rows.value.length);
/** Index of the selected row in {@link rows}, -1 if none. */
const selectedIndex = computed(() => rows.value.findIndex((row) => row.key === selectedKey.value));
/** Drops the results of the previous search. */
function clearResults(): void {
files.value = [];
summary.value = null;
selectedKey.value = null;
error.value = null;
}
/**
* Adds one file's matches.
*
* @param path - project-relative path.
* @param matches - its matches.
*/
function addFile(path: string, matches: FindMatch[]): void {
if (matches.length === 0) {
return;
}
const next = [...files.value];
const at = insertionIndex(next, path);
const same = next[at];
if (same?.path === path) {
next[at] = { path, matches: [...same.matches, ...matches] };
} else {
next.splice(at, 0, { path, matches });
}
files.value = next;
}
/**
* Applies a search event of the current search.
*
* @param event - a `searchResults` or `searchDone` event.
*/
function apply(event: EngineEventPayload): void {
if (event.kind === "searchResults") {
if (typeof event.path === "string" && event.path !== "") {
addFile(event.path, toMatches(event.matches));
}
} else if (event.kind === "searchDone") {
running.value = false;
summary.value = {
files: count(event.files) ?? files.value.length,
matches: count(event.matches) ?? matchCount.value,
truncated: event.truncated === true,
cancelled: event.cancelled === true,
elapsedMs: count(event.elapsedMs) ?? 0,
};
}
}
/**
* Handles an engine event.
*
* @param event - the engine event.
*/
function onEvent(event: EngineEventPayload): void {
if (event.kind === "searchResults" || event.kind === "searchDone") {
if (searchId.value !== null && event.searchId === searchId.value) {
apply(event);
} else if (awaitingId && early.length < MAX_EARLY_EVENTS) {
early.push(event);
}
} else if (event.kind === "projectClosed" || event.kind === "projectOpened") {
generation += 1;
awaitingId = false;
early = [];
searchId.value = null;
running.value = false;
clearResults();
}
}
/** Asks the engine to stop the running search; its `searchDone` follows. */
async function cancel(): Promise<void> {
const id = searchId.value;
if (!running.value || id === null) {
return;
}
const result = await run("search.cancel", { searchId: id });
if (!result.ok) {
error.value = result.error.message;
}
}
/**
* Starts a search for the current query and options, cancelling the
* running one. An empty query only clears the results.
*/
async function search(): Promise<void> {
void cancel();
generation += 1;
const mine = generation;
clearResults();
searchId.value = null;
running.value = false;
early = [];
if (query.value === "") {
awaitingId = false;
return;
}
running.value = true;
awaitingId = true;
const params: JsonValue = {
query: query.value,
regex: regex.value,
caseSensitive: caseSensitive.value,
wholeWord: wholeWord.value,
include: splitGlobs(include.value),
exclude: splitGlobs(exclude.value),
};
const result = await run<unknown>("search.find", params);
const answer = result.ok && typeof result.value === "object" && result.value !== null ? (result.value as Record<string, unknown>) : null;
const id = answer ? count(answer.searchId) : null;
if (mine !== generation) {
if (id !== null) {
void run("search.cancel", { searchId: id });
}
return;
}
awaitingId = false;
const held = early;
early = [];
if (!result.ok) {
running.value = false;
error.value = result.error.message;
return;
}
if (id === null) {
running.value = false;
error.value = t("common.error.unexpectedResult", { command: "search.find" });
return;
}
searchId.value = id;
for (const event of held) {
if ("searchId" in event && event.searchId === id) {
apply(event);
}
}
}
/**
* Shows the panel and focuses its query field: the UI command
* `find.open`. With a string `query` param (agents) it takes that query
* and searches at once; otherwise it takes the editor's selection or the
* word at the cursor, if any, and waits for Enter.
*
* @param params - the command params; untrusted.
*/
async function open(params: unknown = {}): Promise<void> {
const p = typeof params === "object" && params !== null && !Array.isArray(params) ? (params as Record<string, unknown>) : {};
visible.value = true;
expanded.value = true;
focusRequest.value += 1;
if (typeof p.query === "string") {
query.value = p.query;
if (typeof p.regex === "boolean") regex.value = p.regex;
if (typeof p.caseSensitive === "boolean") caseSensitive.value = p.caseSensitive;
if (typeof p.wholeWord === "boolean") wholeWord.value = p.wholeWord;
if (typeof p.include === "string") include.value = p.include;
if (typeof p.exclude === "string") exclude.value = p.exclude;
await search();
return;
}
const id = editor.activeId;
const prefill = prefillFrom(id === null ? undefined : editor.syncOf(id)?.state);
if (prefill !== null && prefill !== query.value) {
query.value = prefill;
error.value = null;
}
}
/** Hides the panel; the results stay for the next `find.open`. */
function hide(): void {
visible.value = false;
}
/**
* Moves the selection through the rows.
*
* @param delta - rows to move; clamped at both ends.
*/
function move(delta: number): void {
const list = rows.value;
if (list.length === 0) {
return;
}
const from = selectedIndex.value;
const to = from < 0 ? (delta > 0 ? 0 : list.length - 1) : Math.min(list.length - 1, Math.max(0, from + delta));
selectedKey.value = list[to]?.key ?? null;
}
/**
* Selects a row.
*
* @param key - its key, see {@link FindRow}.
*/
function select(key: string): void {
selectedKey.value = key;
}
/** Starts listening to search events. Starting twice is a no-op. */
function start(): void {
unsubscribe ??= onEngineEvent(onEvent);
}
/** Stops listening. */
function stop(): void {
unsubscribe?.();
unsubscribe = null;
}
return {
visible,
expanded,
query,
regex,
caseSensitive,
wholeWord,
include,
exclude,
searchId,
running,
files,
summary,
error,
selectedKey,
focusRequest,
rows,
matchCount,
selectedIndex,
search,
cancel,
open,
hide,
move,
select,
start,
stop,
};
});

View file

@ -0,0 +1,530 @@
/**
* Tests of the Find tool window (M2.4): the Find store (search params,
* results sorted by file, events of other searches ignored, events before
* the `searchId` answer replayed, a new search cancelling the old one,
* refused queries, malformed matches, project close), the prefill from the
* editor, the window (status and counts, truncated hint, highlight, toggles
* repeating the search, cancel, keyboard navigation and opening a match
* through `editor.reveal`), the bottom panel, and `find.open` through the
* main layout and `uiCommand`. The engine is a fake behind the mocked Tauri
* `invoke` and `listen`.
*/
import { EditorSelection, EditorState } from "@codemirror/state";
import { flushPromises, mount, type VueWrapper } from "@vue/test-utils";
import { createPinia, setActivePinia, type Pinia } from "pinia";
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
const invoke = vi.hoisted(() => vi.fn());
const listen = vi.hoisted(() => vi.fn());
vi.mock("@tauri-apps/api/core", () => ({ invoke }));
vi.mock("@tauri-apps/api/event", () => ({ listen }));
import { useCommandsStore } from "../../src/commands/store";
import FindToolWindow from "../../src/components/find/FindToolWindow.vue";
import BottomPanel from "../../src/components/layout/BottomPanel.vue";
import MainLayout from "../../src/components/layout/MainLayout.vue";
import { prefillFrom, splitGlobs, toMatches, useFindStore } from "../../src/stores/find";
/** Every `engine_execute` call, in order. */
let calls: { command: string; params: Record<string, unknown> }[];
/** Engine event callbacks of every subscription. */
let listeners: ((event: { payload: unknown }) => void)[];
/** Next `searchId` the fake returns. */
let nextSearchId: number;
/** Error the next `search.find` fails with, if any. */
let findError: { code: string; message: string } | null;
/** Events the fake emits before `search.find` answers. */
let beforeAnswer: unknown[];
/** Pinia of the current test. */
let pinia: Pinia;
/** Mounted components, unmounted after each test. */
let mounted: VueWrapper[];
/**
* Sends an engine event to every subscription.
*
* @param payload - the event.
*/
async function emit(payload: unknown): Promise<void> {
for (const listener of [...listeners]) {
listener({ payload });
}
await flushPromises();
}
/**
* A `searchResults` event.
*
* @param searchId - the search.
* @param path - the file.
* @param lines - one match per entry: line number and preview with the
* match marked by `[` and `]`.
*/
function results(searchId: number, path: string, lines: [number, string][]): unknown {
return {
kind: "searchResults",
searchId,
path,
matches: lines.map(([line, marked]) => {
const start = marked.indexOf("[");
const end = marked.indexOf("]") - 1;
const preview = marked.replace("[", "").replace("]", "");
return { line, column: start + 2, length: end - start, preview, previewColumn: start };
}),
};
}
/**
* A `searchDone` event.
*
* @param searchId - the search.
* @param extra - fields to override.
*/
function done(searchId: number, extra: Record<string, unknown> = {}): unknown {
return { kind: "searchDone", searchId, files: 2, matches: 3, truncated: false, cancelled: false, elapsedMs: 12, ...extra };
}
/** The params of every call of a command. */
function paramsOf(command: string): Record<string, unknown>[] {
return calls.filter((c) => c.command === command).map((c) => c.params);
}
/** Mounts the Find window with a started store and an `editor.reveal` spy. */
async function mountFind(): Promise<{ wrapper: VueWrapper; reveals: unknown[] }> {
const reveals: unknown[] = [];
useCommandsStore(pinia).provide("editor.reveal", { run: (params) => void reveals.push(params) });
useFindStore(pinia).start();
const wrapper = mount(FindToolWindow, { attachTo: document.body, global: { plugins: [pinia] } });
mounted.push(wrapper);
await flushPromises();
return { wrapper, reveals };
}
/**
* Types a query and presses Enter.
*
* @param wrapper - the Find window.
* @param text - the query.
*/
async function searchFor(wrapper: VueWrapper, text: string): Promise<void> {
await wrapper.get("[data-test=find-query]").setValue(text);
await wrapper.get("form").trigger("submit");
await flushPromises();
}
beforeEach(() => {
pinia = createPinia();
setActivePinia(pinia);
calls = [];
listeners = [];
nextSearchId = 7;
findError = null;
beforeAnswer = [];
mounted = [];
Element.prototype.scrollIntoView = () => undefined;
invoke.mockReset();
listen.mockReset();
listen.mockImplementation((_name: string, callback: (event: { payload: unknown }) => void) => {
listeners.push(callback);
return Promise.resolve(() => {
listeners = listeners.filter((l) => l !== callback);
});
});
invoke.mockImplementation((cmd: string, args?: { command: string; params: Record<string, unknown> }) => {
if (cmd === "engine_list_commands") {
return Promise.resolve([]);
}
if (cmd !== "engine_execute" || !args) {
return Promise.resolve(null);
}
calls.push({ command: args.command, params: args.params });
if (args.command === "search.find") {
if (findError) {
return Promise.reject(Object.assign(new Error(findError.code), findError));
}
const searchId = nextSearchId;
nextSearchId += 1;
for (const event of beforeAnswer) {
for (const listener of [...listeners]) {
listener({ payload: event });
}
}
return Promise.resolve({ searchId });
}
if (args.command === "search.cancel") {
return Promise.resolve({ cancelled: true });
}
return Promise.resolve(null);
});
});
afterEach(() => {
for (const wrapper of mounted) {
wrapper.unmount();
}
useFindStore(pinia).stop();
useCommandsStore(pinia).stop();
});
describe("find store", () => {
it("sends the query, options and split globs", async () => {
const find = useFindStore();
find.start();
await flushPromises();
find.query = "foo";
find.caseSensitive = true;
find.regex = true;
find.include = " *.php, src/** ,";
find.exclude = "vendor/**";
await find.search();
expect(paramsOf("search.find")).toEqual([
{ query: "foo", regex: true, caseSensitive: true, wholeWord: false, include: ["*.php", "src/**"], exclude: ["vendor/**"] },
]);
expect(find.searchId).toBe(7);
expect(find.running).toBe(true);
});
it("keeps files sorted, ignores other searches and ends with the summary", async () => {
const find = useFindStore();
find.start();
await flushPromises();
find.query = "foo";
await find.search();
await emit(results(7, "src/b.php", [[3, " $[foo] = 1;"]]));
await emit(results(99, "src/x.php", [[0, "[foo]"]]));
await emit(results(7, "a.php", [[0, "[foo]"], [4, "x [foo]"]]));
expect(find.files.map((f) => f.path)).toEqual(["a.php", "src/b.php"]);
expect(find.matchCount).toBe(3);
await emit(done(99));
expect(find.running).toBe(true);
await emit(done(7, { truncated: true }));
expect(find.running).toBe(false);
expect(find.summary).toEqual({ files: 2, matches: 3, truncated: true, cancelled: false, elapsedMs: 12 });
});
it("replays events that arrive before search.find answers", async () => {
const find = useFindStore();
find.start();
await flushPromises();
beforeAnswer = [results(7, "a.php", [[0, "[foo]"]]), results(3, "old.php", [[0, "[foo]"]]), done(7, { files: 1, matches: 1 })];
find.query = "foo";
await find.search();
expect(find.files.map((f) => f.path)).toEqual(["a.php"]);
expect(find.summary?.matches).toBe(1);
expect(find.running).toBe(false);
});
it("cancels the running search when a new one starts", async () => {
const find = useFindStore();
find.start();
await flushPromises();
find.query = "foo";
await find.search();
await emit(results(7, "a.php", [[0, "[foo]"]]));
find.query = "bar";
await find.search();
expect(paramsOf("search.cancel")).toEqual([{ searchId: 7 }]);
expect(find.searchId).toBe(8);
expect(find.files).toEqual([]);
await emit(results(7, "late.php", [[0, "[foo]"]]));
expect(find.files).toEqual([]);
});
it("drops the answer of a search overtaken by a newer one and cancels it", async () => {
const find = useFindStore();
find.start();
await flushPromises();
find.query = "foo";
const first = find.search();
find.query = "bar";
const second = find.search();
await Promise.all([first, second]);
expect(find.searchId).toBe(8);
expect(paramsOf("search.cancel")).toEqual([{ searchId: 7 }]);
});
it("shows a refused query in place", async () => {
const find = useFindStore();
find.start();
findError = { code: "invalid_params", message: "search.find: regex parse error" };
find.query = "(";
find.regex = true;
await find.search();
expect(find.error).toBe("search.find: regex parse error");
expect(find.running).toBe(false);
});
it("does not search for an empty query", async () => {
const find = useFindStore();
await find.search();
expect(paramsOf("search.find")).toEqual([]);
});
it("cancels through search.cancel", async () => {
const find = useFindStore();
find.start();
await flushPromises();
find.query = "foo";
await find.search();
await find.cancel();
expect(paramsOf("search.cancel")).toEqual([{ searchId: 7 }]);
await emit(done(7, { cancelled: true }));
expect(find.summary?.cancelled).toBe(true);
});
it("clears the results when the project closes", async () => {
const find = useFindStore();
find.start();
await flushPromises();
find.query = "foo";
await find.search();
await emit(results(7, "a.php", [[0, "[foo]"]]));
await emit({ kind: "projectClosed" });
expect(find.files).toEqual([]);
expect(find.running).toBe(false);
await emit(results(7, "b.php", [[0, "[foo]"]]));
expect(find.files).toEqual([]);
});
it("drops malformed matches and clamps the highlight", () => {
expect(
toMatches([
{ line: 1, column: 2, length: 3, preview: "abc", previewColumn: 9 },
{ line: -1, column: 0, length: 1, preview: "x", previewColumn: 0 },
{ line: 0, column: 0, length: 1, preview: 5, previewColumn: 0 },
null,
"x",
]),
).toEqual([{ line: 1, column: 2, length: 3, preview: "abc", previewColumn: 3 }]);
expect(toMatches("nope")).toEqual([]);
});
it("splits globs", () => {
expect(splitGlobs("")).toEqual([]);
expect(splitGlobs("*.php,, *.twig ")).toEqual(["*.php", "*.twig"]);
});
});
describe("prefill", () => {
/**
* An editor state with a selection.
*
* @param doc - the text.
* @param anchor - selection anchor.
* @param head - selection head.
*/
function stateOf(doc: string, anchor: number, head = anchor): EditorState {
return EditorState.create({ doc, selection: EditorSelection.single(anchor, head) });
}
it("takes the selection", () => {
expect(prefillFrom(stateOf("echo $foo->bar();", 5, 14))).toBe("$foo->bar");
});
it("takes the word at the cursor without a selection", () => {
expect(prefillFrom(stateOf("echo productName;", 8))).toBe("productName");
});
it("ignores a multi-line selection and falls back to the word", () => {
expect(prefillFrom(stateOf("alpha\nbeta", 0, 8))).toBe("beta");
});
it("gives nothing without an editor or a word", () => {
expect(prefillFrom(undefined)).toBeNull();
expect(prefillFrom(stateOf("a ; b", 3))).toBeNull();
});
});
describe("find.open prefill", () => {
it("replaces the query from the editor and drops a stale error", async () => {
const find = useFindStore();
const editor = (await import("../../src/stores/editor")).useEditorStore();
const state = EditorState.create({ doc: "echo productName;", selection: EditorSelection.single(8) });
editor.activeId = 1;
vi.spyOn(editor, "syncOf").mockReturnValue({ state } as unknown as ReturnType<typeof editor.syncOf>);
find.query = "(";
find.error = "bad regex";
await find.open({});
expect(find.query).toBe("productName");
expect(find.error).toBeNull();
expect(find.visible).toBe(true);
expect(paramsOf("search.find")).toEqual([]);
});
});
describe("Find tool window", () => {
it("searches on Enter and shows counts, files and highlighted matches", async () => {
const { wrapper } = await mountFind();
expect(wrapper.get("[data-test=find-status]").text()).toBe("Type a text and press Enter");
await searchFor(wrapper, "foo");
expect(paramsOf("search.find")[0]?.query).toBe("foo");
expect(wrapper.find("[data-test=find-cancel]").exists()).toBe(true);
await emit(results(7, "src/b.php", [[3, " $[foo] = 1;"]]));
await emit(results(7, "a.php", [[0, "[foo]"], [4, "x [foo] y"]]));
expect(wrapper.get("[data-test=find-status]").text()).toBe("Searching… 3 matches in 2 files");
const files = wrapper.findAll("[data-test=find-file]").map((f) => f.text());
expect(files).toEqual(["a.php2", "b.phpsrc1"]);
const rows = wrapper.findAll("[data-test=find-row]");
expect(rows.map((r) => r.text())).toEqual(["1foo", "5x foo y", "4$foo = 1;"]);
expect(wrapper.findAll("[data-test=find-hit]").map((h) => h.text())).toEqual(["foo", "foo", "foo"]);
await emit(done(7, { truncated: true, matches: 3, files: 2 }));
expect(wrapper.get("[data-test=find-status]").text()).toContain("3 matches in 2 files · 12 ms");
expect(wrapper.find("[data-test=find-truncated]").exists()).toBe(true);
expect(wrapper.find("[data-test=find-submit]").exists()).toBe(true);
});
it("says when nothing matched or the search was cancelled", async () => {
const { wrapper } = await mountFind();
await searchFor(wrapper, "zzz");
await emit(done(7, { files: 0, matches: 0 }));
expect(wrapper.get("[data-test=find-status]").text()).toBe("No matches");
await searchFor(wrapper, "foo");
await wrapper.get("[data-test=find-cancel]").trigger("click");
await flushPromises();
expect(paramsOf("search.cancel")).toEqual([{ searchId: 8 }]);
await emit(done(8, { cancelled: true, files: 0, matches: 0 }));
expect(wrapper.get("[data-test=find-status]").text()).toContain("Cancelled");
});
it("shows a refused regex as an alert", async () => {
const { wrapper } = await mountFind();
findError = { code: "invalid_params", message: "bad regex" };
await searchFor(wrapper, "(");
expect(wrapper.get("[data-test=find-error]").text()).toBe("bad regex");
expect(wrapper.get("[data-test=find-query]").attributes("aria-invalid")).toBe("true");
expect(wrapper.get("[data-test=find-status]").text()).toBe("");
});
it("repeats the search when an option is toggled", async () => {
const { wrapper } = await mountFind();
await wrapper.get("[data-test=find-word]").trigger("click");
expect(paramsOf("search.find")).toEqual([]);
await searchFor(wrapper, "foo");
await wrapper.get("[data-test=find-case]").trigger("click");
await flushPromises();
await wrapper.get("[data-test=find-regex]").trigger("click");
await flushPromises();
const sent = paramsOf("search.find");
expect(sent.map((p) => [p.wholeWord, p.caseSensitive, p.regex])).toEqual([
[true, false, false],
[true, true, false],
[true, true, true],
]);
expect(wrapper.get("[data-test=find-regex]").attributes("aria-pressed")).toBe("true");
});
it("walks the results with the keyboard and opens them through editor.reveal", async () => {
const { wrapper, reveals } = await mountFind();
await searchFor(wrapper, "foo");
await emit(results(7, "a.php", [[0, "[foo]"], [4, "x [foo]"]]));
await emit(results(7, "b.php", [[2, "[foo]"]]));
await wrapper.get("[data-test=find-query]").trigger("keydown", { key: "ArrowDown" });
const list = wrapper.get("[data-test=find-results]");
expect(document.activeElement).toBe(list.element);
expect(list.attributes("aria-activedescendant")).toBe("find-row-0");
await list.trigger("keydown", { key: "ArrowDown" });
await list.trigger("keydown", { key: "ArrowDown" });
await list.trigger("keydown", { key: "ArrowDown" });
expect(list.attributes("aria-activedescendant")).toBe("find-row-2");
await list.trigger("keydown", { key: "Home" });
expect(list.attributes("aria-activedescendant")).toBe("find-row-0");
await list.trigger("keydown", { key: "ArrowDown" });
await list.trigger("keydown", { key: "Enter" });
await flushPromises();
expect(reveals).toEqual([{ path: "a.php", line: 4, column: 4 }]);
await list.trigger("keydown", { key: "End" });
expect(wrapper.findAll("[data-test=find-row]")[2]?.attributes("aria-selected")).toBe("true");
await wrapper.findAll("[data-test=find-row]")[0]?.trigger("click");
await flushPromises();
expect(reveals).toEqual([
{ path: "a.php", line: 4, column: 4 },
{ path: "a.php", line: 0, column: 2 },
]);
});
it("focuses and selects the query field when find.open runs again", async () => {
const { wrapper } = await mountFind();
const input = wrapper.get("[data-test=find-query]").element as HTMLInputElement;
document.body.focus();
await useFindStore(pinia).open({});
await flushPromises();
expect(document.activeElement).toBe(input);
});
});
describe("bottom panel", () => {
it("collapses to its header, expands, closes and resizes with the keyboard", async () => {
const closes: number[] = [];
const wrapper = mount(BottomPanel, {
props: {
title: "Find",
open: true,
height: 200,
minHeight: 100,
maxHeight: 230,
"onUpdate:open": (open: boolean) => wrapper.setProps({ open }),
"onUpdate:height": (height: number) => wrapper.setProps({ height }),
onClose: () => closes.push(1),
},
slots: { default: "<p data-test='content'>results</p>" },
});
const splitter = wrapper.get("[data-test=bottom-panel-splitter]");
await splitter.trigger("keydown", { key: "ArrowUp" });
expect(wrapper.get(".bottom-panel__body").attributes("style")).toContain("height: 212px");
await splitter.trigger("keydown", { key: "ArrowUp", shiftKey: true });
expect(wrapper.get(".bottom-panel__body").attributes("style")).toContain("height: 230px");
await splitter.trigger("keydown", { key: "ArrowDown", shiftKey: true });
await splitter.trigger("keydown", { key: "ArrowDown", shiftKey: true });
await splitter.trigger("keydown", { key: "ArrowDown", shiftKey: true });
expect(wrapper.get(".bottom-panel__body").attributes("style")).toContain("height: 100px");
await wrapper.get("[data-test=bottom-panel-toggle]").trigger("click");
expect(wrapper.find("[data-test=content]").exists()).toBe(false);
expect(wrapper.find("[data-test=bottom-panel-splitter]").exists()).toBe(false);
await wrapper.get("[data-test=bottom-panel-toggle]").trigger("click");
expect(wrapper.find("[data-test=content]").exists()).toBe(true);
await wrapper.get("[data-test=bottom-panel-close]").trigger("click");
expect(closes).toEqual([1]);
});
});
describe("find.open", () => {
/** Mounts the main layout with the commands store started. */
async function mountLayout(): Promise<VueWrapper> {
const wrapper = mount(MainLayout, {
attachTo: document.body,
global: { plugins: [pinia], stubs: { ProjectToolWindow: true, StatusBar: true } },
});
mounted.push(wrapper);
await useCommandsStore(pinia).start();
await flushPromises();
return wrapper;
}
it("is registered with its own shortcut", async () => {
await mountLayout();
const registered = paramsOf("ui.registerCommands")[0]?.commands as { id: string; defaultShortcut?: string }[];
expect(registered.find((c) => c.id === "find.open")?.defaultShortcut).toBe("Mod+Alt+F");
});
it("opens the panel from the shortcut, then hides and keeps the results", async () => {
const wrapper = await mountLayout();
expect(wrapper.find("[data-test=bottom-panel]").exists()).toBe(false);
window.dispatchEvent(new KeyboardEvent("keydown", { key: "f", code: "KeyF", ctrlKey: true, altKey: true, bubbles: true }));
await flushPromises();
expect(wrapper.find("[data-test=bottom-panel]").exists()).toBe(true);
expect(document.activeElement).toBe(wrapper.get("[data-test=find-query]").element);
await wrapper.get("[data-test=bottom-panel-close]").trigger("click");
expect(wrapper.find("[data-test=bottom-panel]").exists()).toBe(false);
});
it("searches at once for an agent's uiCommand with a query", async () => {
const wrapper = await mountLayout();
await emit({ kind: "uiCommand", id: "find.open", params: { query: "needle", wholeWord: true, include: "*.php" } });
expect(paramsOf("search.find")).toEqual([
{ query: "needle", regex: false, caseSensitive: false, wholeWord: true, include: ["*.php"], exclude: [] },
]);
await emit(results(7, "a.php", [[0, "[needle]"]]));
expect(wrapper.findAll("[data-test=find-row]")).toHaveLength(1);
expect((wrapper.get("[data-test=find-query]").element as HTMLInputElement).value).toBe("needle");
});
});

View file

@ -122,7 +122,7 @@ describe("en.json", () => {
it("uses flat dotted keys of known areas with string values", () => {
for (const [key, value] of Object.entries(en)) {
expect(key).toMatch(
/^(app|command|project|editor|common|palette|theme|recovery|notification|settings)\.[A-Za-z0-9]+(\.[A-Za-z0-9]+)*$/,
/^(app|command|project|editor|common|palette|theme|recovery|notification|settings|find)\.[A-Za-z0-9]+(\.[A-Za-z0-9]+)*$/,
);
expect(typeof value).toBe("string");
expect(value.trim()).not.toBe("");

View file

@ -260,6 +260,7 @@ describe("CommandPalette", () => {
expect(rows(wrapper)).toEqual([
"project.close",
"palette.open",
"find.open",
"project.openDialog",
"app.quit",
"editor.reveal",
@ -281,7 +282,7 @@ describe("CommandPalette", () => {
const wrapper = await mountPalette();
await press(PALETTE_KEY);
await type(wrapper, "o");
expect(rows(wrapper).slice(0, 2)).toEqual(["project.openDialog", "palette.open"]);
expect(rows(wrapper).slice(0, 3)).toEqual(["project.openDialog", "find.open", "palette.open"]);
await type(wrapper, "open f");
expect(rows(wrapper)[0]).toBe("project.openDialog");
await press({ key: "ArrowDown" });