@adecore/editor-react 0.0.1 → 0.17.0-beta.2

package/dist/locales/en.json

@@ -0,0 +1,171 @@
+{
+    "language": {
+        "hover": {
+            "quickFix": "Quick fix…",
+            "quickFixNone": "This language server offers no quick fixes",
+            "definition": "Go to definition",
+            "references_one": "{{formatted}} reference",
+            "references_other": "{{formatted}} references",
+            "none": "No information for this position"
+        },
+        "edit": {
+            "staged_one": "{{count}} file changed and not saved yet",
+            "staged_other": "{{count}} files changed and not saved yet",
+            "stagedMore": "{{names}} and {{count}} more",
+            "saveAll": "Save all",
+            "notSaved": "{{name}} could not be saved"
+        },
+        "actions": {
+            "show": "Show code actions",
+            "none": "No code actions here",
+            "unavailable": "No language server offers code actions here",
+            "organized": "The imports are already organized",
+            "noFormatter": "No language server formats this file",
+            "readOnly": "This file is read only",
+            "failed": "Could not apply the action: {{message}}",
+            "refused": "The edit was refused",
+            "moreLines": "{{count}} more lines",
+            "otherFiles_one": "and {{count}} other file",
+            "otherFiles_other": "and {{count}} other files",
+            "moves_one": "moves {{count}} file",
+            "moves_other": "moves {{count}} files",
+            "groups": {
+                "quickfix": "Quick fix",
+                "rewrite": "Rewrite",
+                "extract": "Extract",
+                "inline": "Inline",
+                "move": "Move",
+                "refactor": "Refactor",
+                "source": "Source",
+                "other": "Other"
+            }
+        },
+        "rename": {
+            "unavailable": "No language server renames in this file",
+            "nothing": "There is nothing to rename here",
+            "refused": "The language server refused the new name",
+            "stale": "The text changed while the rename was being asked for",
+            "failed": "Could not rename: {{message}}",
+            "occurrences_one": "{{formatted}} occurrence",
+            "occurrences_other": "{{formatted}} occurrences",
+            "occurrencesFiles_one": "{{formatted}} occurrence in {{files}} files",
+            "occurrencesFiles_other": "{{formatted}} occurrences in {{files}} files",
+            "rename": "Rename",
+            "preview": "Preview",
+            "cancel": "Cancel",
+            "apply": "Rename",
+            "suggestions": "Suggested names",
+            "useSuggestion": "Use suggestion"
+        },
+        "navigation": {
+            "unavailable": "No language server answers that here",
+            "none": "Nothing found",
+            "failed": "Could not look it up: {{message}}",
+            "titles": {
+                "definition": "Definitions",
+                "declaration": "Declarations",
+                "typeDefinition": "Type definitions",
+                "implementation": "Implementations",
+                "symbol": "Matches"
+            }
+        },
+        "peek": {
+            "unavailable": "No language server finds references in this file",
+            "none": "No references found",
+            "failed": "Could not look up the references: {{message}}",
+            "references_one": "{{formatted}} reference",
+            "references_other": "{{formatted}} references",
+            "close": "Close",
+            "collapse": "Collapse",
+            "expand": "Expand",
+            "definitions_one": "{{formatted}} definition",
+            "definitions_other": "{{formatted}} definitions",
+            "noDefinition": "No definition found",
+            "unavailableDefinition": "No language server finds definitions in this file"
+        },
+        "codeVision": {
+            "usagesNone": "No usages",
+            "usages_one": "{{formatted}} usage",
+            "usages_other": "{{formatted}} usages",
+            "newCode": "new *",
+            "lines_one": "{{formatted}} line",
+            "lines_other": "{{formatted}} lines",
+            "uncommitted": "Not committed yet",
+            "latest": "Latest change",
+            "showCommit": "Show commit"
+        },
+        "symbols": {
+            "unavailable": "No language server knows the symbols of this file",
+            "failed": "Could not read the symbols: {{message}}",
+            "placeholder": "Go to symbol in {{file}}",
+            "navigate": "Navigate",
+            "open": "Open",
+            "workspace": "Workspace symbols",
+            "line": "Go to line",
+            "none": "No matching symbols",
+            "workspaceHint": "Type the name of a symbol in the project",
+            "lineHint": "Type a line number",
+            "goToLine": "Go to line {{line}}",
+            "groups": {
+                "namespaces": "Namespaces",
+                "classes": "Classes",
+                "interfaces": "Interfaces",
+                "enums": "Enums",
+                "functions": "Functions",
+                "methods": "Methods",
+                "properties": "Properties",
+                "variables": "Variables",
+                "constants": "Constants",
+                "other": "Other"
+            }
+        },
+        "context": {
+            "refactor": "Refactor",
+            "cut": "Cut",
+            "copy": "Copy",
+            "paste": "Paste"
+        },
+        "completion": {
+            "insert": "Insert",
+            "replace": "Replace",
+            "details": "Details",
+            "none": "No suggestions"
+        },
+        "history": {
+            "recent": "Recent locations"
+        }
+    },
+    "commands": {
+        "goToDefinition": "Go to definition",
+        "goToTypeDefinition": "Go to type definition",
+        "goToImplementation": "Go to implementation",
+        "peekReferences": "Peek references",
+        "renameSymbol": "Rename symbol",
+        "codeActions": "Code actions",
+        "formatDocument": "Format document"
+    },
+    "find": {
+        "label": "Find",
+        "count": "{{current}} / {{total}}",
+        "none": "No results",
+        "invalid": "Invalid regular expression",
+        "caseSensitive": "Match case",
+        "wholeWord": "Match whole word",
+        "regex": "Use regular expression",
+        "inSelection": "In selection",
+        "noSelection": "No selection",
+        "selectAll": "Select all matches",
+        "previous": "Previous match",
+        "next": "Next match",
+        "close": "Close",
+        "replace": {
+            "label": "Replace with",
+            "one": "Replace",
+            "all": "All",
+            "allLabel": "Replace all",
+            "preserveCase": "Preserve case",
+            "toggle": "Show replace",
+            "hide": "Hide replace"
+        }
+    }
+}

package/dist/locales/nl.json

@@ -0,0 +1,171 @@
+{
+    "language": {
+        "hover": {
+            "quickFix": "Quick fix…",
+            "quickFixNone": "Deze language server biedt geen quick fixes",
+            "definition": "Ga naar definitie",
+            "references_one": "{{formatted}} referentie",
+            "references_other": "{{formatted}} referenties",
+            "none": "Geen informatie voor deze plek"
+        },
+        "edit": {
+            "staged_one": "{{count}} bestand gewijzigd en nog niet opgeslagen",
+            "staged_other": "{{count}} bestanden gewijzigd en nog niet opgeslagen",
+            "stagedMore": "{{names}} en nog {{count}}",
+            "saveAll": "Alles opslaan",
+            "notSaved": "{{name}} kon niet worden opgeslagen"
+        },
+        "actions": {
+            "show": "Toon code actions",
+            "none": "Geen code actions hier",
+            "unavailable": "Geen language server biedt hier code actions",
+            "organized": "De imports zijn al georganiseerd",
+            "noFormatter": "Geen language server formatteert dit bestand",
+            "readOnly": "Dit bestand is alleen-lezen",
+            "failed": "De actie kon niet worden toegepast: {{message}}",
+            "refused": "De wijziging is geweigerd",
+            "moreLines": "nog {{count}} regels",
+            "otherFiles_one": "en nog {{count}} bestand",
+            "otherFiles_other": "en nog {{count}} bestanden",
+            "moves_one": "verplaatst {{count}} bestand",
+            "moves_other": "verplaatst {{count}} bestanden",
+            "groups": {
+                "quickfix": "Quick fix",
+                "rewrite": "Herschrijven",
+                "extract": "Extraheren",
+                "inline": "Inline",
+                "move": "Verplaatsen",
+                "refactor": "Refactor",
+                "source": "Source",
+                "other": "Overig"
+            }
+        },
+        "rename": {
+            "unavailable": "Geen language server hernoemt in dit bestand",
+            "nothing": "Hier is niets om te hernoemen",
+            "refused": "De language server weigerde de nieuwe naam",
+            "stale": "De tekst veranderde terwijl de hernoeming werd opgevraagd",
+            "failed": "Hernoemen mislukt: {{message}}",
+            "occurrences_one": "{{formatted}} voorkomen",
+            "occurrences_other": "{{formatted}} voorkomens",
+            "occurrencesFiles_one": "{{formatted}} voorkomen in {{files}} bestanden",
+            "occurrencesFiles_other": "{{formatted}} voorkomens in {{files}} bestanden",
+            "rename": "Hernoem",
+            "preview": "Voorbeeld",
+            "cancel": "Annuleer",
+            "apply": "Hernoem",
+            "suggestions": "Voorgestelde namen",
+            "useSuggestion": "Suggestie gebruiken"
+        },
+        "navigation": {
+            "unavailable": "Geen language server die dat hier beantwoordt",
+            "none": "Niets gevonden",
+            "failed": "Opzoeken mislukt: {{message}}",
+            "titles": {
+                "definition": "Definities",
+                "declaration": "Declaraties",
+                "typeDefinition": "Typedefinities",
+                "implementation": "Implementaties",
+                "symbol": "Overeenkomsten"
+            }
+        },
+        "peek": {
+            "unavailable": "Geen language server vindt referenties in dit bestand",
+            "none": "Geen referenties gevonden",
+            "failed": "Referenties opzoeken mislukt: {{message}}",
+            "references_one": "{{formatted}} referentie",
+            "references_other": "{{formatted}} referenties",
+            "close": "Sluit",
+            "collapse": "Inklappen",
+            "expand": "Uitklappen",
+            "definitions_one": "{{formatted}} definitie",
+            "definitions_other": "{{formatted}} definities",
+            "noDefinition": "Geen definitie gevonden",
+            "unavailableDefinition": "Geen language server vindt definities in dit bestand"
+        },
+        "codeVision": {
+            "usagesNone": "Niet gebruikt",
+            "usages_one": "{{formatted}} keer gebruikt",
+            "usages_other": "{{formatted}} keer gebruikt",
+            "newCode": "nieuw *",
+            "lines_one": "{{formatted}} regel",
+            "lines_other": "{{formatted}} regels",
+            "uncommitted": "Nog niet gecommit",
+            "latest": "Laatste wijziging",
+            "showCommit": "Commit tonen"
+        },
+        "symbols": {
+            "unavailable": "Geen language server kent de symbolen van dit bestand",
+            "failed": "De symbolen konden niet worden gelezen: {{message}}",
+            "placeholder": "Ga naar symbool in {{file}}",
+            "navigate": "Navigeer",
+            "open": "Open",
+            "workspace": "Symbolen in het project",
+            "line": "Ga naar regel",
+            "none": "Geen symbolen gevonden",
+            "workspaceHint": "Typ de naam van een symbool in het project",
+            "lineHint": "Typ een regelnummer",
+            "goToLine": "Ga naar regel {{line}}",
+            "groups": {
+                "namespaces": "Namespaces",
+                "classes": "Classes",
+                "interfaces": "Interfaces",
+                "enums": "Enums",
+                "functions": "Functies",
+                "methods": "Methoden",
+                "properties": "Properties",
+                "variables": "Variabelen",
+                "constants": "Constanten",
+                "other": "Overig"
+            }
+        },
+        "context": {
+            "refactor": "Refactor",
+            "cut": "Knip",
+            "copy": "Kopieer",
+            "paste": "Plak"
+        },
+        "completion": {
+            "insert": "Invoegen",
+            "replace": "Vervangen",
+            "details": "Details",
+            "none": "Geen suggesties"
+        },
+        "history": {
+            "recent": "Recente plekken"
+        }
+    },
+    "commands": {
+        "goToDefinition": "Ga naar definitie",
+        "goToTypeDefinition": "Ga naar typedefinitie",
+        "goToImplementation": "Ga naar implementatie",
+        "peekReferences": "Bekijk referenties",
+        "renameSymbol": "Symbool hernoemen",
+        "codeActions": "Codeacties",
+        "formatDocument": "Document formatteren"
+    },
+    "find": {
+        "label": "Zoeken",
+        "count": "{{current}} / {{total}}",
+        "none": "Geen resultaten",
+        "invalid": "Ongeldige reguliere expressie",
+        "caseSensitive": "Hoofdlettergevoelig",
+        "wholeWord": "Heel woord",
+        "regex": "Reguliere expressie gebruiken",
+        "inSelection": "In selectie",
+        "noSelection": "Geen selectie",
+        "selectAll": "Alle treffers selecteren",
+        "previous": "Vorige treffer",
+        "next": "Volgende treffer",
+        "close": "Sluiten",
+        "replace": {
+            "label": "Vervangen door",
+            "one": "Vervang",
+            "all": "Alles",
+            "allLabel": "Alles vervangen",
+            "preserveCase": "Hoofdletters behouden",
+            "toggle": "Vervangen tonen",
+            "hide": "Vervangen verbergen"
+        }
+    }
+}

package/dist/models.d.ts

@@ -0,0 +1,20 @@
+export { isIdentifierCharacter, identifierPrefix, type MatchDetail, matchDetail, matchScore, editRangeOf, itemsOf, prefixFor, type Ranked, rankCompletions, matchedCharacters, qualifierOf, qualifiersOf, snippetToText, METHOD_KIND, FUNCTION_KIND, CONSTRUCTOR_KIND, CLASS_KIND, SNIPPET_FORMAT, type Insertion, insertionOf, mirroredInsertions, documentationText, completionDocsOf, type KindTone, kindLetterOf, kindToneOf, type RowWindow, rowWindow } from './completion-model.ts';
+export { PARAMETER_HINTS_COMMAND, type CallPlan, type CallSite, isCallItem, hasParameters, planCall, withParentheses } from './completion-call.ts';
+export { type Problem, severityOf, markerOf, comparePositions, shiftPosition, shiftRange, rangeHolds, problemsAt, neighborProblem, codeLabelOf } from './diagnostics-model.ts';
+export { type SignatureBlock, type HoverText, splitSignatures, hoverTextOf, isEmptyHover, locationsOf, sameRange, type DocTag, splitDocTags, type HoverSection, type BaselineLevel, type Baseline, docblockMarkdown, type MarkdownPart, markdownParts, hoverSectionsOf } from './hover-content.ts';
+export { type SignatureViewModel, parameterSpan, signatureViewOf } from './signature-model.ts';
+export { wordRangeAt, type RenameTarget, renameTargetOf, type Occurrences, occurrencesOf, type RenameRow, type RenameFile, renameRowsOf, renamePreviewOf } from './rename-model.ts';
+export { type NameRange, type PeekPlace, type PeekFile, PEEK_READ_FILES, peekFilesOf, type PeekSnippet, snippetOf, definitionSnippetOf, distinguishingFolders, visualColumnOf } from './peek-model.ts';
+export { type SymbolGroup, SYMBOL_GROUPS, groupOfKind, letterOfKind, type SymbolTone, toneOfKind, type SymbolEntry, entriesOf, scoreOf, filterEntries, type EntryGroup, groupEntries, type PickerMode, modeOf, type WorkspaceEntry, workspaceEntriesOf } from './symbol-picker-model.ts';
+export { SYMBOL_LINK_CLASS, isTypeName, linkTypeNames, declaredNameOf, placesOfName } from './symbol-links.ts';
+export { scopesOf, decodeSemanticTokens } from './semantic-model.ts';
+export { type ActionGroup, ACTION_GROUPS, REFACTOR_GROUPS, type ActionEntry, groupOf, actionsOf, mergeEntries, isHint, fixableOnLine, diagnosticsAt, type EditPreview, previewOf } from './code-actions-model.ts';
+export { MAX_DECLARATIONS, type CodeVisionDeclaration, type DeclarationSource, startAfterComments, declarationsOf, usagesText } from './code-vision-model.ts';
+export { UNCOMMITTED, mapBlame, type CodeAuthor, type CodeAuthorship, shortName, authorshipOf, authorsText } from './code-authors.ts';
+export { type SnippetStop, type ParsedSnippet, parseSnippet, tabOrder } from './snippet.ts';
+export { type LineSpan, lineSpanOf, isEmptyRange, inlineRangeOf, type InlineProblem, problemsOnLines, type InlineAnswer, parseAnswer, fitReplacement, endOfInsertion, type DiffSegment, diffSegments, emphasisOf, offsetOf, textInRange, replaceRange, locateSelection } from './proposal-model.ts';
+export { type LineReplacement, replaceLines, replaceAllLines } from './line-edits.ts';
+export { replacedWords } from './word-diff.ts';
+export { type FindOptions, type FindQuery, EMPTY_FIND_QUERY, type TextMatch, type CompiledFind, MATCH_LIMIT, compileFind, matchesIn, stepIndex } from './find-query.ts';
+export { type PopupSize, type PopupPlacement, type PlaceOptions, placePopup, placeBeside } from './popup-placement.ts';
+export { planConflict, type ConflictStretch, type ConflictPlan } from './conflict-model.ts';

package/dist/models.js

@@ -0,0 +1,20 @@
+export { isIdentifierCharacter, identifierPrefix, matchDetail, matchScore, editRangeOf, itemsOf, prefixFor, rankCompletions, matchedCharacters, qualifierOf, qualifiersOf, snippetToText, METHOD_KIND, FUNCTION_KIND, CONSTRUCTOR_KIND, CLASS_KIND, SNIPPET_FORMAT, insertionOf, mirroredInsertions, documentationText, completionDocsOf, kindLetterOf, kindToneOf, rowWindow } from './completion-model.js';
+export { PARAMETER_HINTS_COMMAND, isCallItem, hasParameters, planCall, withParentheses } from './completion-call.js';
+export { severityOf, markerOf, comparePositions, shiftPosition, shiftRange, rangeHolds, problemsAt, neighborProblem, codeLabelOf } from './diagnostics-model.js';
+export { splitSignatures, hoverTextOf, isEmptyHover, locationsOf, sameRange, splitDocTags, docblockMarkdown, markdownParts, hoverSectionsOf } from './hover-content.js';
+export { parameterSpan, signatureViewOf } from './signature-model.js';
+export { wordRangeAt, renameTargetOf, occurrencesOf, renameRowsOf, renamePreviewOf } from './rename-model.js';
+export { PEEK_READ_FILES, peekFilesOf, snippetOf, definitionSnippetOf, distinguishingFolders, visualColumnOf } from './peek-model.js';
+export { SYMBOL_GROUPS, groupOfKind, letterOfKind, toneOfKind, entriesOf, scoreOf, filterEntries, groupEntries, modeOf, workspaceEntriesOf } from './symbol-picker-model.js';
+export { SYMBOL_LINK_CLASS, isTypeName, linkTypeNames, declaredNameOf, placesOfName } from './symbol-links.js';
+export { scopesOf, decodeSemanticTokens } from './semantic-model.js';
+export { ACTION_GROUPS, REFACTOR_GROUPS, groupOf, actionsOf, mergeEntries, isHint, fixableOnLine, diagnosticsAt, previewOf } from './code-actions-model.js';
+export { MAX_DECLARATIONS, startAfterComments, declarationsOf, usagesText } from './code-vision-model.js';
+export { UNCOMMITTED, mapBlame, shortName, authorshipOf, authorsText } from './code-authors.js';
+export { parseSnippet, tabOrder } from './snippet.js';
+export { lineSpanOf, isEmptyRange, inlineRangeOf, problemsOnLines, parseAnswer, fitReplacement, endOfInsertion, diffSegments, emphasisOf, offsetOf, textInRange, replaceRange, locateSelection } from './proposal-model.js';
+export { replaceLines, replaceAllLines } from './line-edits.js';
+export { replacedWords } from './word-diff.js';
+export { EMPTY_FIND_QUERY, MATCH_LIMIT, compileFind, matchesIn, stepIndex } from './find-query.js';
+export { placePopup, placeBeside } from './popup-placement.js';
+export { planConflict } from './conflict-model.js';

package/dist/navigation-history.d.ts

@@ -0,0 +1,16 @@
+import type { EditorPosition } from '@adecore/editor';
+export interface Place {
+    readonly uri: string;
+    readonly position: EditorPosition;
+}
+export declare class NavigationHistory {
+    private backs;
+    private forwards;
+    record(from: Place): void;
+    back(current: Place): Place | null;
+    forward(current: Place): Place | null;
+    canGoBack(current: Place): boolean;
+    canGoForward(current: Place): boolean;
+    recent(current: Place): Place[];
+    private walk;
+}

package/dist/navigation-history.js

@@ -0,0 +1,53 @@
+const LIMIT = 100;
+/* Two places on one line of one file are one place: a jump lands wherever, and walking back should not stop twice on the same line. */
+function samePlace(left, right) {
+    return left.uri === right.uri && left.position.line === right.position.line;
+}
+/*
+ * Where the caret was before each jump, for Back and Forward. A jump records the place it left and
+ * forgets what Forward knew; walking back moves the place it left onto Forward, and the other way round.
+ * One history serves every editor of a project, so it walks across files.
+ */
+export class NavigationHistory {
+    backs = [];
+    forwards = [];
+    record(from) {
+        if (this.backs.length > 0 && samePlace(this.backs[this.backs.length - 1], from)) {
+            this.backs[this.backs.length - 1] = from;
+        }
+        else {
+            this.backs.push(from);
+            if (this.backs.length > LIMIT) {
+                this.backs.shift();
+            }
+        }
+        this.forwards = [];
+    }
+    /* The place before `current`, which Forward then returns to; null when there is none. */
+    back(current) {
+        return this.walk(this.backs, this.forwards, current);
+    }
+    forward(current) {
+        return this.walk(this.forwards, this.backs, current);
+    }
+    canGoBack(current) {
+        return this.backs.some((place) => !samePlace(place, current));
+    }
+    canGoForward(current) {
+        return this.forwards.some((place) => !samePlace(place, current));
+    }
+    /* Every place in the history but the one the caret is on, the latest first: where Back would go, then where Forward would. */
+    recent(current) {
+        return [...this.backs.toReversed(), ...this.forwards.toReversed()].filter((place) => !samePlace(place, current));
+    }
+    walk(from, to, current) {
+        while (from.length > 0) {
+            const place = from.pop();
+            if (!samePlace(place, current)) {
+                to.push(current);
+                return place;
+            }
+        }
+        return null;
+    }
+}

package/dist/navigation.d.ts

@@ -0,0 +1,23 @@
+import { type Location, type NavigationResult, type Range } from '@adecore/lsp';
+import type { EditorPosition } from '@adecore/editor';
+import type { EditorLanguage } from './editor-language.ts';
+export type NavigationKind = 'definition' | 'declaration' | 'typeDefinition' | 'implementation';
+export declare function uniquePlaces(result: NavigationResult): {
+    location: Location;
+    target: Range | null;
+}[];
+export declare function uniqueLocations(result: NavigationResult): Location[];
+export declare class NavigationFeature {
+    private readonly language;
+    constructor(language: EditorLanguage);
+    supports(kind: NavigationKind): boolean;
+    go(kind: NavigationKind, position?: EditorPosition): Promise<void>;
+    goToName(name: string, anchor: EditorPosition, own: Location | null): Promise<void>;
+    private tell;
+    private say;
+}
+export declare function locationRow(location: Location, stored: string | null): {
+    label: string;
+    detail: string;
+    path: true;
+};

package/dist/navigation.js

@@ -0,0 +1,155 @@
+import { StaleResultError, fileUriToPath } from '@adecore/lsp';
+import { basenameOf } from './paths.js';
+import { rangeHolds } from './diagnostics-model.js';
+import { placesOfName } from './symbol-links.js';
+import { isShortcut } from './shortcut-keys.js';
+const METHODS = {
+    definition: 'textDocument/definition',
+    declaration: 'textDocument/declaration',
+    typeDefinition: 'textDocument/typeDefinition',
+    implementation: 'textDocument/implementation'
+};
+const SHORTCUT_KINDS = [
+    ['definition', 'goToDefinition'],
+    ['typeDefinition', 'goToTypeDefinition'],
+    ['implementation', 'goToImplementation']
+];
+const TOAST_ID = 'language-navigation';
+/* The places of a result, each once: the two servers of a Vue file may both know the same one. `target` is the whole declaration when the server gave it. */
+export function uniquePlaces(result) {
+    const seen = new Set();
+    const list = result === null ? [] : Array.isArray(result) ? result : [result];
+    return list
+        .map((entry) => 'targetUri' in entry
+        ? { location: { uri: entry.targetUri, range: entry.targetSelectionRange }, target: entry.targetRange }
+        : { location: entry, target: null })
+        .filter(({ location }) => {
+        const { start } = location.range;
+        const key = `${location.uri}\0${start.line}\0${start.character}`;
+        if (seen.has(key)) {
+            return false;
+        }
+        seen.add(key);
+        return true;
+    });
+}
+/* The places of a result, each once. */
+export function uniqueLocations(result) {
+    return uniquePlaces(result).map(({ location }) => location);
+}
+/*
+ * Going to where a name is defined, declared, typed or implemented: Mod+click on the name or a shortcut
+ * for the caret. One place opens at once, in this file or in the one it lives in, the way a file opens in
+ * the host; several are listed under the name to choose from.
+ */
+export class NavigationFeature {
+    language;
+    constructor(language) {
+        this.language = language;
+        const { editor } = language;
+        const offs = [
+            editor.onClick((click) => {
+                if (!click.mod || click.alt || click.shift || !this.supports('definition')) {
+                    return false;
+                }
+                void this.go('definition', click.position);
+                return true;
+            }),
+            editor.onKeyDown((event) => {
+                const found = SHORTCUT_KINDS.find(([, name]) => isShortcut(this.language.shortcuts[name], event));
+                if (found === undefined) {
+                    return false;
+                }
+                void this.go(found[0]);
+                return true;
+            })
+        ];
+        language.onDispose(() => {
+            for (const off of offs) {
+                off();
+            }
+        });
+    }
+    supports(kind) {
+        return this.language.project.service.supports(METHODS[kind], this.language.uri);
+    }
+    async go(kind, position = this.language.editor.getCaret()) {
+        const { project, uri, editor } = this.language;
+        if (!this.supports(kind)) {
+            this.tell(this.say('unavailable'));
+            return;
+        }
+        let result;
+        try {
+            const { service } = project;
+            result = await (kind === 'definition'
+                ? service.definition(uri, position)
+                : kind === 'declaration'
+                    ? service.declaration(uri, position)
+                    : kind === 'typeDefinition'
+                        ? service.typeDefinition(uri, position)
+                        : service.implementation(uri, position));
+        }
+        catch (error) {
+            if (!(error instanceof StaleResultError)) {
+                this.tell(this.say('failed', { message: error instanceof Error ? error.message : String(error) }));
+            }
+            return;
+        }
+        const places = uniqueLocations(result);
+        if (places.length === 0) {
+            this.tell(this.say('none'));
+        }
+        else if (kind === 'definition' && places.length === 1 && places[0].uri === uri && rangeHolds(places[0].range, position)) {
+            // The name is its own definition, so what a person wants to see is where it is used.
+            void this.language.peek.open(position);
+        }
+        else if (places.length === 1) {
+            this.language.goTo(places[0]);
+        }
+        else {
+            this.language.locations(places, position, this.say(`titles.${kind}`));
+        }
+        editor.focus();
+    }
+    /*
+     * A name in the signature of a hover, which is a snippet and no document a server can be asked about by position.
+     * The symbol the signature declares goes to the definition the hover already knows; any other name is looked
+     * up by name among the symbols of the project. One match goes there at once, several are listed, and none says nothing.
+     */
+    async goToName(name, anchor, own) {
+        const { project, uri, editor } = this.language;
+        if (own !== null) {
+            this.language.goTo(own);
+            return;
+        }
+        if (!project.service.supports('workspace/symbol', uri)) {
+            return;
+        }
+        try {
+            const places = placesOfName(await project.service.workspaceSymbols(uri, name), name, editor.getText());
+            if (places.length === 1) {
+                this.language.goTo(places[0]);
+            }
+            else if (places.length > 1) {
+                this.language.locations(places, anchor, this.say('titles.symbol'));
+            }
+        }
+        catch {
+            // A name that cannot be found is a link that does nothing, not an error.
+        }
+    }
+    tell(title) {
+        this.language.project.host.notify?.({ id: TOAST_ID, kind: 'error', title });
+    }
+    say(key, options) {
+        return this.language.project.i18n.t(`editor:language.navigation.${key}`, options);
+    }
+}
+/* How a place reads in a list: the file and the line, with the folder it is in. */
+export function locationRow(location, stored) {
+    const path = stored ?? fileUriToPath(location.uri) ?? location.uri;
+    const name = basenameOf(path);
+    const folder = path.slice(0, Math.max(0, path.length - name.length)).replace(/\/$/, '');
+    return { label: `${name}:${location.range.start.line + 1}`, detail: folder, path: true };
+}

package/dist/paths.d.ts

@@ -0,0 +1 @@
+export declare function basenameOf(path: string): string;

package/dist/paths.js

@@ -0,0 +1,3 @@
+export function basenameOf(path) {
+    return path.replaceAll('\\', '/').split('/').at(-1) ?? path;
+}