@adecore/editor-react 0.43.0 → 0.44.1

package/src/live-templates.ts

@@ -0,0 +1,315 @@
+import type { EditorPosition, EditorRange } from '@adecore/editor';
+import type { CompletionItem } from '@adecore/lsp';
+import type { LocalCompletionItem } from './completion.ts';
+import { identifierPrefix, isIdentifierCharacter } from './completion-model.ts';
+import { comparePositions } from './diagnostics-model.ts';
+import type { EditorLanguage } from './editor-language.ts';
+import { KEY_PRIORITY } from './key-priority.ts';
+import { textBeforeOf } from './line-text.ts';
+import { isShortcut } from './shortcut-keys.ts';
+import { PostfixFeature } from './postfix.ts';
+import { bodyWithIndentUnit, dedentLines, indentUnitOf, insertSnippet, type SnippetPlacement } from './snippet-insert.ts';
+import { escapeSnippetText } from './snippet.ts';
+import { SNIPPET_KIND, sortAfterServer, templateApplies, templateContextAt, type TemplateContext } from './template-context.ts';
+import type { LiveTemplate } from './templates.ts';
+
+const TOAST_ID = 'language-templates';
+const IDENTIFIER_START = /[\p{L}_$]/u;
+
+/* The live templates that apply at one caret, and where their key starts. */
+interface Match {
+    readonly start: EditorPosition;
+    readonly templates: readonly LiveTemplate[];
+}
+
+/* A key other than a live template's that Tab can expand; `expand` is null where another feature expands it on the same Tab. */
+interface CustomKey {
+    readonly start: EditorPosition;
+    readonly expand: (() => boolean) | null;
+}
+
+/* Sorts the rows of a list of templates by group, then key. */
+function grouped(template: LiveTemplate): string {
+    return `${template.group ?? template.languages[0]}\u0000${template.key}`;
+}
+
+/* A key that starts in the middle of a word is no key, unless it starts with a character no word has. */
+function startsInsideWord(before: string, index: number): boolean {
+    return index > 0 && IDENTIFIER_START.test(before[index]!) && isIdentifierCharacter(before[index - 1]!);
+}
+
+/* The longest start of `key` that the text before the caret ends with, as a number of characters; 0 when none. */
+function prefixLength(key: string, before: string): number {
+    for (let length = Math.min(key.length, before.length); length >= 1; length--) {
+        if (before.endsWith(key.slice(0, length)) && !startsInsideWord(before, before.length - length)) {
+            return length;
+        }
+    }
+
+    return 0;
+}
+
+/*
+ * Live templates: a key typed before the caret and Tab expands a snippet, Insert Live Template lists the ones that
+ * apply, and Save as Live Template hands a selection to the host. The templates come from the registry of the
+ * project. Tab comes after a running snippet and before Emmet, and a key that starts before an Emmet abbreviation
+ * wins over it, as in IntelliJ.
+ */
+export class TemplatesFeature {
+    private readonly language: EditorLanguage;
+    private readonly postfix: PostfixFeature;
+
+    constructor(language: EditorLanguage) {
+        this.language = language;
+        this.postfix = new PostfixFeature(language);
+
+        language.onDispose(
+            language.onKey((event) => {
+                if (event.key === 'Tab' && !event.shiftKey && !event.altKey && !event.ctrlKey && !event.metaKey && !event.isComposing) {
+                    return this.expand();
+                }
+
+                if (isShortcut(language.shortcuts.insertLiveTemplate, event)) {
+                    this.insert();
+
+                    return true;
+                }
+
+                if (isShortcut(language.shortcuts.saveAsLiveTemplate, event)) {
+                    this.saveSelection();
+
+                    return true;
+                }
+
+                return false;
+            }, KEY_PRIORITY.templates)
+        );
+
+        language.onDispose(language.completion.addSource({ items: (request) => [...this.rows(request.position), ...this.postfix.rows(request.position)] }));
+    }
+
+    /*
+     * Expands the template whose key ends at the caret, or lists them when several share the key. False where Tab has
+     * nothing to expand, and where the key is an Emmet abbreviation, which the markup feature expands on the same Tab.
+     */
+    expand(): boolean {
+        const { editor, completion } = this.language;
+        const selections = editor.getSelections();
+
+        if (editor.isReadOnly?.() === true || selections.some((selection) => comparePositions(selection.start, selection.end) !== 0)) {
+            return false;
+        }
+
+        const match = this.matchAtCarets(selections.map((selection) => selection.start));
+        const custom = selections.length === 1 ? this.customKey() : null;
+
+        if (custom !== null && (match === null || comparePositions(match.start, custom.start) >= 0)) {
+            return custom.expand?.() ?? false;
+        }
+
+        if (match === null) {
+            return false;
+        }
+
+        if (match.templates.length === 1) {
+            this.expandAtCarets(match.templates[0]!, match.start);
+
+            return true;
+        }
+
+        completion.showItems(
+            match.templates.map((template) =>
+                this.row(template, template.key, grouped(template), { start: match.start, end: editor.getCaret() }, () =>
+                    this.expandAtCarets(template, match.start)
+                )
+            ),
+            match.start
+        );
+
+        return true;
+    }
+
+    /* Lists the templates that apply, only the ones whose key or description fits the word before the caret when some do. */
+    insert(): void {
+        const { editor, completion, project } = this.language;
+
+        if (editor.isReadOnly?.() === true) {
+            return;
+        }
+
+        const selection = editor.getSelection();
+        const selected = comparePositions(selection.start, selection.end) !== 0;
+        const caret = editor.getCaret();
+        const before = textBeforeOf(editor, caret);
+        const word = selected ? '' : identifierPrefix(before);
+        const wordStart = { line: caret.line, character: caret.character - word.length };
+        const context = templateContextAt(this.language, selected ? selection.start : wordStart);
+        const applicable = project.templates.live.filter((template) => templateApplies(template, context));
+
+        if (applicable.length === 0) {
+            const title = project.i18n.t('editor:language.templates.none');
+
+            project.host.notify?.({ id: TOAST_ID, kind: 'error', title });
+            editor.announce(title);
+
+            return;
+        }
+
+        const keyed = (template: LiveTemplate): boolean => word !== '' && prefixLength(template.key, before) > 0;
+        const described = (template: LiveTemplate): boolean => word !== '' && (template.description?.toLowerCase().includes(word.toLowerCase()) ?? false);
+        const matching = applicable.filter((template) => keyed(template) || described(template));
+        const start = matching.length === 0 ? caret : wordStart;
+        const text = selected ? editor.textInRange(selection) : '';
+
+        const rows = (matching.length === 0 ? applicable : matching).map((template) =>
+            this.row(template, keyed(template) || matching.length === 0 ? template.key : word, grouped(template), { start, end: caret }, () => {
+                const range = selected ? selection : { start, end: editor.getCaret() };
+
+                void this.run(template, [{ range, selectedText: selected ? dedentLines(text) : undefined }]);
+            })
+        );
+
+        completion.showItems(rows, start);
+    }
+
+    /* Hands the selection to the host as a draft of a template; false without a selection or without a host that saves. */
+    saveSelection(): boolean {
+        const { editor, project } = this.language;
+        const selection = editor.getSelection();
+
+        if (comparePositions(selection.start, selection.end) === 0) {
+            editor.announce(project.i18n.t('editor:language.templates.selectToSave'));
+
+            return false;
+        }
+
+        if (project.host.saveAsLiveTemplate === undefined) {
+            return false;
+        }
+
+        const context = templateContextAt(this.language, selection.start);
+
+        project.host.saveAsLiveTemplate({
+            body: escapeSnippetText(dedentLines(editor.textInRange(selection))),
+            languages: [context.families[0]!],
+            places: [context.place]
+        });
+
+        return true;
+    }
+
+    /* The keys that compete with a live template for Tab: an Emmet abbreviation, then a postfix key. */
+    private customKey(): CustomKey | null {
+        const abbreviation = this.language.markup.abbreviationAt();
+
+        return abbreviation === null ? this.postfix.key() : { start: abbreviation, expand: null };
+    }
+
+    /* The templates every caret has the same key of, ending at the caret, in a context they apply in. */
+    private matchAtCarets(carets: readonly EditorPosition[]): Match | null {
+        const matches = carets.map((caret) => this.matchAt(caret));
+        const primary = matches.at(-1);
+
+        if (primary === null || primary === undefined) {
+            return null;
+        }
+
+        const templates = primary.templates.filter((template) => matches.every((match) => match?.templates.some((other) => other.id === template.id) === true));
+
+        return templates.length === 0 ? null : { start: primary.start, templates };
+    }
+
+    /*
+     * The templates whose key is the longest one that ends at the caret, as IntelliJ looks them up: when the longest
+     * key found applies nowhere, no shorter key is tried.
+     */
+    private matchAt(caret: EditorPosition): Match | null {
+        const { editor, project } = this.language;
+        const { live } = project.templates;
+        const before = textBeforeOf(editor, caret);
+        const longest = live.reduce((length, template) => Math.max(length, template.key.length), 0);
+
+        for (let length = Math.min(longest, before.length); length >= 1; length--) {
+            const index = before.length - length;
+            const key = before.slice(index);
+            const found = live.filter((template) => template.key === key);
+
+            if (found.length === 0 || startsInsideWord(before, index)) {
+                continue;
+            }
+
+            const start = { line: caret.line, character: index };
+            const context = templateContextAt(this.language, start);
+            const templates = found.filter((template) => templateApplies(template, context));
+
+            return templates.length === 0 ? null : { start, templates };
+        }
+
+        return null;
+    }
+
+    /* Replaces the text between `start` and the caret, as far as the primary caret is from it, at every caret. */
+    private expandAtCarets(template: LiveTemplate, start: EditorPosition): void {
+        const { editor } = this.language;
+        const length = Math.max(0, editor.getCaret().character - start.character);
+
+        void this.run(
+            template,
+            editor.getSelections().map((selection) => ({
+                range: { start: { line: selection.end.line, character: Math.max(0, selection.end.character - length) }, end: selection.end }
+            }))
+        );
+    }
+
+    private run(template: LiveTemplate, placements: readonly SnippetPlacement[]): Promise<boolean> {
+        return insertSnippet(this.language, bodyWithIndentUnit(template.body, indentUnitOf(this.language.editor)), placements);
+    }
+
+    /* The rows for the word before the caret, each a template whose key starts with it. */
+    private rows(position: EditorPosition): readonly LocalCompletionItem[] {
+        const { editor, project } = this.language;
+
+        if (!project.templates.settings.liveInCompletion) {
+            return [];
+        }
+
+        const before = textBeforeOf(editor, position);
+
+        if (identifierPrefix(before) === '') {
+            return [];
+        }
+
+        const contexts = new Map<number, TemplateContext>();
+
+        return project.templates.live.flatMap((template) => {
+            const length = prefixLength(template.key, before);
+
+            if (length === 0) {
+                return [];
+            }
+
+            const start = { line: position.line, character: position.character - length };
+            const context = contexts.get(length) ?? templateContextAt(this.language, start);
+
+            contexts.set(length, context);
+
+            return templateApplies(template, context)
+                ? [this.row(template, template.key, sortAfterServer(template.key), { start, end: position }, () => this.expandAtCarets(template, start))]
+                : [];
+        });
+    }
+
+    private row(template: LiveTemplate, filterText: string, sortText: string, range: EditorRange, accept: () => void): LocalCompletionItem {
+        const item: CompletionItem = {
+            label: template.key,
+            kind: SNIPPET_KIND,
+            detail: template.description,
+            documentation: { kind: 'markdown', value: `\`\`\`\n${template.body}\n\`\`\`` },
+            filterText,
+            sortText,
+            textEdit: { range, newText: template.key }
+        };
+
+        return { item, accept };
+    }
+}

package/src/locales/en.json

@@ -219,6 +219,36 @@
             "title": "Choose Content to Paste",
             "empty": "Nothing was copied yet"
         },
+        "templates": {
+            "none": "No templates defined in this context",
+            "selectToSave": "Select the text to save as a live template"
+        },
+        "postfix": {
+            "expressions": "Expressions"
+        },
+        "surround": {
+            "title": "Surround With",
+            "selectTemplate": "Select Template",
+            "liveTemplates": "Live templates",
+            "configure": "Configure live templates…",
+            "comments": "{{construct}} Comments",
+            "none": "Couldn't find Surround With variants applicable to the current context",
+            "noTemplates": "No surround templates defined in this context",
+            "unwrap": {
+                "title": "Choose the statement to unwrap/remove",
+                "if": "Unwrap 'if...'",
+                "else": "Unwrap 'else...'",
+                "removeElse": "Remove 'else...'",
+                "for": "Unwrap 'for...'",
+                "while": "Unwrap 'while...'",
+                "do": "Unwrap 'do...'",
+                "try": "Unwrap 'try...'",
+                "removeCatch": "Remove 'catch...'",
+                "removeFinally": "Remove 'finally...'",
+                "braces": "Unwrap braces",
+                "tag": "Remove enclosing tag: {{name}}"
+            }
+        },
         "announce": {
             "problem": "{{severity}}: {{message}}",
             "severity": {

package/src/locales/nl.json

@@ -219,6 +219,36 @@
             "title": "Kies wat je plakt",
             "empty": "Er is nog niets gekopieerd"
         },
+        "templates": {
+            "none": "Geen sjablonen gedefinieerd in deze context",
+            "selectToSave": "Selecteer de tekst die je als live sjabloon wilt opslaan"
+        },
+        "postfix": {
+            "expressions": "Expressies"
+        },
+        "surround": {
+            "title": "Omring met",
+            "selectTemplate": "Kies een sjabloon",
+            "liveTemplates": "Live sjablonen",
+            "configure": "Live sjablonen instellen…",
+            "comments": "{{construct}}-commentaar",
+            "none": "Geen Omring met-varianten gevonden voor de huidige context",
+            "noTemplates": "Geen omringende sjablonen gedefinieerd in deze context",
+            "unwrap": {
+                "title": "Kies het statement om uit te pakken of te verwijderen",
+                "if": "'if...' uitpakken",
+                "else": "'else...' uitpakken",
+                "removeElse": "'else...' verwijderen",
+                "for": "'for...' uitpakken",
+                "while": "'while...' uitpakken",
+                "do": "'do...' uitpakken",
+                "try": "'try...' uitpakken",
+                "removeCatch": "'catch...' verwijderen",
+                "removeFinally": "'finally...' verwijderen",
+                "braces": "Accolades uitpakken",
+                "tag": "Omringende tag verwijderen: {{name}}"
+            }
+        },
         "announce": {
             "problem": "{{severity}}: {{message}}",
             "severity": {

package/src/markup-context.ts

@@ -29,6 +29,19 @@ export interface TagPair {
     readonly close: { readonly from: number; readonly to: number };
 }
 
+/* A whole tag, from its `<` up to and after its `>`. */
+export interface TagSpan {
+    readonly from: number;
+    readonly to: number;
+}
+
+/* An element as its tags: `close` is null for one that was never closed. */
+export interface EnclosingElement {
+    readonly name: string;
+    readonly open: TagSpan;
+    readonly close: TagSpan | null;
+}
+
 /* Above this a document is not read on a keystroke; the features then do nothing in it. */
 export const MAX_MARKUP_SCAN = 1_000_000;
 
@@ -74,10 +87,11 @@ class Stop {
  */
 class MarkupScanner {
     readonly pairs: TagPair[] = [];
+    readonly elements: EnclosingElement[] = [];
     private readonly text: string;
     private readonly syntax: MarkupSyntax;
     private readonly until: number;
-    private readonly open: (OpenElement & { readonly nameTo: number })[] = [];
+    private readonly open: (OpenElement & { readonly nameTo: number; readonly tag: TagSpan })[] = [];
 
     constructor(text: string, syntax: MarkupSyntax, until: number) {
         this.text = text;
@@ -160,7 +174,7 @@ class MarkupScanner {
         const name = text.slice(nameFrom, nameTo);
         const end = this.tagEnd(at, closing, name, nameFrom, nameTo);
         if (closing) {
-            this.close(name, nameFrom, nameTo);
+            this.close(name, nameFrom, nameTo, { from: at, to: end });
             return end;
         }
         const selfClosing = text[end - 2] === '/' && text[end - 1] === '>';
@@ -168,9 +182,9 @@ class MarkupScanner {
             return end;
         }
         if (this.syntax !== 'xml' && RAW_ELEMENTS.has(name.toLowerCase())) {
-            return this.rawContent(end, name, nameFrom, nameTo);
+            return this.rawContent({ from: at, to: end }, name, nameFrom, nameTo);
         }
-        this.open.push({ name, nameFrom, nameTo });
+        this.open.push({ name, nameFrom, nameTo, tag: { from: at, to: end } });
         return end;
     }
 
@@ -212,7 +226,8 @@ class MarkupScanner {
     }
 
     /* The content of `script`, `style` and the like is not markup, up to the end tag of the element. */
-    private rawContent(from: number, name: string, nameFrom: number, nameTo: number): number {
+    private rawContent(tag: TagSpan, name: string, nameFrom: number, nameTo: number): number {
+        const from = tag.to;
         const pattern = new RegExp(`</${name}(?=[\\s/>]|$)`, 'gi');
         pattern.lastIndex = from;
         const match = pattern.exec(this.text);
@@ -225,21 +240,131 @@ class MarkupScanner {
         const closeTo = closeFrom + name.length;
         const after = this.tagEnd(end, true, this.text.slice(closeFrom, closeTo), closeFrom, closeTo);
         this.pairs.push({ open: { from: nameFrom, to: nameTo }, close: { from: closeFrom, to: closeTo } });
+        this.elements.push({ name, open: tag, close: { from: end, to: after } });
         return after;
     }
 
     /* An end tag closes the nearest open element of its name and every element left open inside it. */
-    private close(name: string, nameFrom: number, nameTo: number): void {
+    private close(name: string, nameFrom: number, nameTo: number, tag: TagSpan): void {
         const caseless = this.syntax !== 'xml';
         for (let index = this.open.length - 1; index >= 0; index--) {
             const element = this.open[index]!;
             if (element.name === name || (caseless && element.name.toLowerCase() === name.toLowerCase())) {
                 this.pairs.push({ open: { from: element.nameFrom, to: element.nameTo }, close: { from: nameFrom, to: nameTo } });
+                this.elements.push({ name: element.name, open: element.tag, close: tag });
                 this.open.length = index;
                 return;
             }
         }
     }
+
+    /* The elements still open at the end of the text. */
+    unclosed(): EnclosingElement[] {
+        return this.open.map((element) => ({ name: element.name, open: element.tag, close: null }));
+    }
+}
+
+/*
+ * The elements whose tags hold `offset`, innermost first: each with its start tag and its end tag, which an element left
+ * open does not have. Empty for a document too large to read on a keystroke.
+ */
+export function enclosingElements(text: string, offset: number, syntax: MarkupSyntax): EnclosingElement[] {
+    if (text.length > MAX_MARKUP_SCAN) {
+        return [];
+    }
+    const scanner = new MarkupScanner(text, syntax, Infinity);
+    scanner.run();
+    return [...scanner.elements, ...scanner.unclosed()]
+        .filter((element) => element.open.from <= offset && offset <= (element.close?.to ?? text.length))
+        .sort((left, right) => right.open.from - left.open.from);
+}
+
+/* A replacement of the text from one offset up to another. */
+export interface TextReplacement {
+    readonly from: number;
+    readonly to: number;
+    readonly text: string;
+}
+
+export function lineStartOf(text: string, offset: number): number {
+    let at = offset;
+
+    while (at > 0 && text[at - 1] !== '\n' && text[at - 1] !== '\r') {
+        at--;
+    }
+
+    return at;
+}
+
+export function lineEndOf(text: string, offset: number): number {
+    let at = offset;
+
+    while (at < text.length && text[at] !== '\n' && text[at] !== '\r') {
+        at++;
+    }
+
+    return at;
+}
+
+function breakLengthAt(text: string, offset: number): number {
+    if (text.startsWith('\r\n', offset)) {
+        return 2;
+    }
+
+    return text[offset] === '\n' || text[offset] === '\r' ? 1 : 0;
+}
+
+/* The tag alone on its line takes the line with it, and the break before it where no break follows. */
+function tagReplacement(text: string, tag: TagSpan): TextReplacement {
+    const start = lineStartOf(text, tag.from);
+    const end = lineEndOf(text, tag.to);
+
+    if (text.slice(start, tag.from).trim() !== '' || text.slice(tag.to, end).trim() !== '') {
+        return { from: tag.from, to: tag.to, text: '' };
+    }
+
+    const after = breakLengthAt(text, end);
+    const before = start > 0 && after === 0 ? (text.startsWith('\r\n', start - 2) ? 2 : 1) : 0;
+
+    return { from: start - before, to: end + after, text: '' };
+}
+
+/*
+ * The edits that take an element's tags away and keep what is between them: each tag that stands alone on its line
+ * goes with its line, and when the start tag does, the lines it enclosed lose one indentation unit. The offsets are
+ * those of `text`, ascending and apart.
+ */
+export function removeTagEdits(text: string, element: EnclosingElement, unit: string): TextReplacement[] {
+    const open = tagReplacement(text, element.open);
+    const edits: TextReplacement[] = [open];
+
+    if (element.close === null) {
+        return edits;
+    }
+
+    const close = tagReplacement(text, element.close);
+    const openAlone = open.from !== element.open.from || open.to !== element.open.to;
+    const closeAlone = close.from !== element.close.from || close.to !== element.close.to;
+    const indent = unit === '\t' ? /^\t/ : new RegExp(`^ {1,${unit.length}}`);
+    const lastLine = lineStartOf(text, element.close.from);
+    let line = lineEndOf(text, element.open.to);
+
+    line += breakLengthAt(text, line);
+
+    while (openAlone && line <= lastLine && line < text.length && !(closeAlone && line === lastLine)) {
+        const found = indent.exec(text.slice(line, lineEndOf(text, line)));
+
+        if (found !== null) {
+            edits.push({ from: line, to: line + found[0].length, text: '' });
+        }
+
+        line = lineEndOf(text, line);
+        line += breakLengthAt(text, line);
+    }
+
+    edits.push(close);
+
+    return edits;
 }
 
 /* What `offset` is in; null for a document too large to read on a keystroke. */

package/src/markup.ts

@@ -1,4 +1,4 @@
-import type { EditorApplyEditsOptions, EditorContentChange, EditorRange, EditorTextChange, EditorTrackedRange } from '@adecore/editor';
+import type { EditorApplyEditsOptions, EditorContentChange, EditorPosition, EditorRange, EditorTextChange, EditorTrackedRange } from '@adecore/editor';
 import { abbreviationBefore, expandAbbreviation } from './emmet.ts';
 import type { EditorLanguage } from './editor-language.ts';
 import { KEY_PRIORITY } from './key-priority.ts';
@@ -87,23 +87,33 @@ export class MarkupFeature {
 
     /* Expands the abbreviation before the caret, its places to fill as a snippet; false when there is none, which leaves Tab its own meaning. */
     expand(): boolean {
+        const found = this.abbreviation();
+        return found !== null && this.insert(found.range, found.expanded, found.line);
+    }
+
+    /* Where the abbreviation that `expand` would take starts, without expanding it; null under the conditions where `expand` does nothing. */
+    abbreviationAt(): EditorPosition | null {
+        return this.abbreviation()?.range.start ?? null;
+    }
+
+    private abbreviation(): { range: EditorRange; expanded: string; line: string } | null {
         const { syntax } = this;
         const { editor } = this.language;
         if (syntax === null || !this.settings.emmet || !this.editable()) {
-            return false;
+            return null;
         }
         const caret = editor.getCaret();
         const line = lineTextOf(editor, caret.line);
         const found = abbreviationBefore(line, caret.character);
         if (found === null) {
-            return false;
+            return null;
         }
         const range = { start: { line: caret.line, character: found.start }, end: { line: caret.line, character: found.end } };
         if (markupPlaceAt(editor.getText(), editor.offsetAt(range.start), syntax)?.kind !== 'text') {
-            return false;
+            return null;
         }
         const expanded = expandAbbreviation(found.abbreviation, { syntax, indent: this.indent() });
-        return expanded !== null && this.insert(range, expanded, line);
+        return expanded === null ? null : { range, expanded, line };
     }
 
     /* Opens the field for an abbreviation to wrap the selection in, or the text of the caret's line without one. */

package/src/pick.ts

@@ -373,10 +373,26 @@ export class PickFeature {
                     return true;
                 }
 
-                return false;
+                return spec.filter !== true && event.key.length === 1 && this.takeMnemonic(event.key);
         }
     }
 
+    /* Takes the visible row whose mnemonic is the typed character, whatever the case. */
+    private takeMnemonic(character: string): boolean {
+        const wanted = character.toLowerCase();
+        const row = this.visibleGroups()
+            .flatMap((group) => group.rows)
+            .find((candidate) => candidate.mnemonic?.toLowerCase() === wanted);
+
+        if (row === undefined) {
+            return false;
+        }
+
+        this.choose(row.id);
+
+        return true;
+    }
+
     private schedulePreview(): void {
         const spec = this.spec;
         this.timers.clear(this.previewTimer);

package/src/popups.ts

@@ -84,6 +84,8 @@ export interface PickRow {
     readonly path?: boolean;
     /* What a typed query is matched against, when a list filters; the label without it. */
     readonly search?: string;
+    /* One character that takes the row when typed in a list that does not filter, such as `1` or `A`. */
+    readonly mnemonic?: string;
 }
 
 export interface PickGroup {