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

package/dist/symbol-picker-model.d.ts

@@ -0,0 +1,44 @@
+import type { DocumentSymbolResult, WorkspaceSymbolResult } from '@adecore/lsp';
+export type SymbolGroup = 'namespaces' | 'classes' | 'interfaces' | 'enums' | 'functions' | 'methods' | 'properties' | 'variables' | 'constants' | 'other';
+export declare const SYMBOL_GROUPS: readonly SymbolGroup[];
+export declare function groupOfKind(kind: number): SymbolGroup;
+export declare function letterOfKind(kind: number): string;
+export type SymbolTone = 'callable' | 'value' | 'type' | 'other';
+export declare function toneOfKind(kind: number): SymbolTone;
+export interface SymbolEntry {
+    readonly id: string;
+    readonly name: string;
+    readonly kind: number;
+    readonly container: string;
+    readonly detail: string;
+    readonly line: number;
+    readonly character: number;
+}
+export declare function entriesOf(result: DocumentSymbolResult): SymbolEntry[];
+export declare function scoreOf(name: string, query: string): number;
+export declare function filterEntries(entries: readonly SymbolEntry[], query: string): SymbolEntry[];
+export interface EntryGroup {
+    readonly group: SymbolGroup;
+    readonly entries: readonly SymbolEntry[];
+}
+export declare function groupEntries(entries: readonly SymbolEntry[]): EntryGroup[];
+export type PickerMode = {
+    readonly mode: 'symbol';
+    readonly text: string;
+} | {
+    readonly mode: 'workspace';
+    readonly text: string;
+} | {
+    readonly mode: 'line';
+    readonly line: number | null;
+};
+export declare function modeOf(input: string): PickerMode;
+export interface WorkspaceEntry {
+    readonly id: string;
+    readonly name: string;
+    readonly kind: number;
+    readonly container: string;
+    readonly uri: string;
+    readonly line: number;
+}
+export declare function workspaceEntriesOf(result: WorkspaceSymbolResult): WorkspaceEntry[];

package/dist/symbol-picker-model.js

@@ -0,0 +1,146 @@
+/* The order the groups are listed in: what a file declares, then what those declare. */
+export const SYMBOL_GROUPS = [
+    'namespaces',
+    'classes',
+    'interfaces',
+    'enums',
+    'functions',
+    'methods',
+    'properties',
+    'variables',
+    'constants',
+    'other'
+];
+const GROUP_OF_KIND = {
+    2: 'namespaces',
+    3: 'namespaces',
+    4: 'namespaces',
+    5: 'classes',
+    23: 'classes',
+    11: 'interfaces',
+    10: 'enums',
+    22: 'enums',
+    12: 'functions',
+    6: 'methods',
+    9: 'methods',
+    7: 'properties',
+    8: 'properties',
+    13: 'variables',
+    14: 'constants',
+    26: 'other'
+};
+export function groupOfKind(kind) {
+    return GROUP_OF_KIND[kind] ?? 'other';
+}
+const LETTERS = {
+    namespaces: 'N',
+    classes: 'C',
+    interfaces: 'I',
+    enums: 'E',
+    functions: 'f',
+    methods: 'm',
+    properties: 'p',
+    variables: 'v',
+    constants: 'c',
+    other: '·'
+};
+/* The letter in the badge in front of a symbol. */
+export function letterOfKind(kind) {
+    return kind === 22 ? 'e' : LETTERS[groupOfKind(kind)];
+}
+export function toneOfKind(kind) {
+    const group = groupOfKind(kind);
+    return group === 'functions' || group === 'methods'
+        ? 'callable'
+        : group === 'classes' || group === 'interfaces' || group === 'enums'
+            ? 'type'
+            : group === 'properties' || group === 'variables' || group === 'constants'
+                ? 'value'
+                : 'other';
+}
+function isHierarchical(symbols) {
+    return symbols.length > 0 && 'selectionRange' in symbols[0];
+}
+/* The symbols of a file, parents before their children, in the order of the file. */
+export function entriesOf(result) {
+    const entries = [];
+    const add = (name, kind, container, detail, at) => {
+        entries.push({ id: String(entries.length), name, kind, container, detail, line: at.line, character: at.character });
+    };
+    const walk = (symbols, container) => {
+        for (const symbol of symbols) {
+            add(symbol.name, symbol.kind, container, symbol.detail ?? '', symbol.selectionRange.start);
+            walk(symbol.children ?? [], container === '' ? symbol.name : `${container}.${symbol.name}`);
+        }
+    };
+    if (result === null || result.length === 0) {
+        return entries;
+    }
+    if (isHierarchical(result)) {
+        walk(result, '');
+    }
+    else {
+        for (const symbol of result) {
+            add(symbol.name, symbol.kind, symbol.containerName ?? '', '', symbol.location.range.start);
+        }
+    }
+    return entries;
+}
+/* How well a query matches a name: 3 for a prefix, 2 for a part of it, 1 for its letters in order, 0 for no match. Case is ignored. */
+export function scoreOf(name, query) {
+    const haystack = name.toLowerCase();
+    const needle = query.toLowerCase();
+    if (needle === '') {
+        return 1;
+    }
+    if (haystack.startsWith(needle)) {
+        return 3;
+    }
+    if (haystack.includes(needle)) {
+        return 2;
+    }
+    let from = 0;
+    for (const character of needle) {
+        from = haystack.indexOf(character, from) + 1;
+        if (from === 0) {
+            return 0;
+        }
+    }
+    return 1;
+}
+/* The entries that match, best first within each group; without a query, in the order of the file. */
+export function filterEntries(entries, query) {
+    const trimmed = query.trim();
+    const scored = entries.map((entry, index) => ({ entry, index, score: scoreOf(entry.name, trimmed) })).filter((candidate) => candidate.score > 0);
+    return scored
+        .sort((left, right) => (trimmed === '' ? left.index - right.index : right.score - left.score || left.index - right.index))
+        .map((candidate) => candidate.entry);
+}
+/* The entries in their groups, in the order of the groups, and so in the order the list is walked with the arrows. */
+export function groupEntries(entries) {
+    return SYMBOL_GROUPS.flatMap((group) => {
+        const own = entries.filter((entry) => groupOfKind(entry.kind) === group);
+        return own.length === 0 ? [] : [{ group, entries: own }];
+    });
+}
+/* `#name` searches the whole project, `:12` goes to a line, anything else filters the symbols of the file. */
+export function modeOf(input) {
+    if (input.startsWith('#')) {
+        return { mode: 'workspace', text: input.slice(1).trim() };
+    }
+    if (input.startsWith(':')) {
+        const line = Number.parseInt(input.slice(1), 10);
+        return { mode: 'line', line: Number.isFinite(line) && line > 0 ? line : null };
+    }
+    return { mode: 'symbol', text: input };
+}
+export function workspaceEntriesOf(result) {
+    return (result ?? []).map((symbol, index) => ({
+        id: String(index),
+        name: symbol.name,
+        kind: symbol.kind,
+        container: symbol.containerName ?? '',
+        uri: symbol.location.uri,
+        line: 'range' in symbol.location ? symbol.location.range.start.line : 0
+    }));
+}

package/dist/symbol-picker.d.ts

@@ -0,0 +1,12 @@
+import type { EditorLanguage } from './editor-language.ts';
+import { type SymbolEntry, type WorkspaceEntry } from './symbol-picker-model.ts';
+export declare class SymbolPickerFeature {
+    private readonly language;
+    constructor(language: EditorLanguage);
+    open(): Promise<void>;
+    close(): void;
+    goTo(entry: SymbolEntry): void;
+    goToLine(line: number): void;
+    search(text: string, signal: AbortSignal): Promise<WorkspaceEntry[]>;
+    goToWorkspace(entry: WorkspaceEntry): void;
+}

package/dist/symbol-picker.js

@@ -0,0 +1,76 @@
+import { StaleResultError } from '@adecore/lsp';
+import { basenameOf } from './paths.js';
+import { entriesOf, workspaceEntriesOf } from './symbol-picker-model.js';
+import { isShortcut } from './shortcut-keys.js';
+const TOAST_ID = 'language-symbols';
+/*
+ * Go to symbol: a picker over the symbols the language servers know in the file, filtered as it is typed.
+ * A `#` in front searches the whole project and a `:` in front goes to a line. The picker answers to
+ * its own input, so the editor only has to open it.
+ */
+export class SymbolPickerFeature {
+    language;
+    constructor(language) {
+        this.language = language;
+        const off = language.editor.onKeyDown((event) => {
+            if (!isShortcut(this.language.shortcuts.goToSymbol, event)) {
+                return false;
+            }
+            void this.open();
+            return true;
+        });
+        language.onDispose(() => {
+            off();
+            this.close();
+        });
+    }
+    async open() {
+        const { project, uri, popups } = this.language;
+        if (!project.service.supports('textDocument/documentSymbol', uri)) {
+            this.language.project.host.notify?.({ id: TOAST_ID, kind: 'error', title: this.language.project.i18n.t('editor:language.symbols.unavailable') });
+            return;
+        }
+        try {
+            const entries = entriesOf(await project.service.documentSymbols(uri));
+            popups.setState({ symbols: { file: basenameOf(this.language.uri), entries } });
+        }
+        catch (error) {
+            if (!(error instanceof StaleResultError)) {
+                this.language.project.host.notify?.({
+                    id: TOAST_ID,
+                    kind: 'error',
+                    title: this.language.project.i18n.t('editor:language.symbols.failed', { message: error instanceof Error ? error.message : String(error) })
+                });
+            }
+        }
+    }
+    close() {
+        if (this.language.popups.getState().symbols !== null) {
+            this.language.popups.setState({ symbols: null });
+            this.language.editor.focus();
+        }
+    }
+    /* Puts the caret on a symbol of the file. */
+    goTo(entry) {
+        this.close();
+        this.language.jump({ line: entry.line, character: entry.character });
+    }
+    /* Puts the caret on a one-based line. */
+    goToLine(line) {
+        this.close();
+        this.language.jump({ line: line - 1, character: 0 });
+    }
+    /* The symbols of the project that answer to a name, which is a request to the server and so waits for a pause in the typing. */
+    async search(text, signal) {
+        const { project, uri } = this.language;
+        if (text === '' || !project.service.supports('workspace/symbol', uri)) {
+            return [];
+        }
+        return workspaceEntriesOf(await project.service.workspaceSymbols(uri, text, { signal }));
+    }
+    goToWorkspace(entry) {
+        this.close();
+        const location = { uri: entry.uri, range: { start: { line: entry.line, character: 0 }, end: { line: entry.line, character: 0 } } };
+        this.language.goTo(location);
+    }
+}

package/dist/symbols.d.ts

@@ -0,0 +1,11 @@
+import type { EditorBlock } from '@adecore/editor';
+import type { DocumentSymbolResult } from '@adecore/lsp';
+import type { EditorLanguage } from './editor-language.ts';
+import { type Timers } from './timers.ts';
+export declare function blocksOf(result: DocumentSymbolResult): EditorBlock[];
+export declare class SymbolsFeature {
+    private readonly refresher;
+    private readonly listeners;
+    constructor(language: EditorLanguage, timers?: Timers);
+    onResult(listener: (result: DocumentSymbolResult) => void): () => void;
+}

package/dist/symbols.js

@@ -0,0 +1,95 @@
+import { Refresher } from './refresher.js';
+import { realTimers } from './timers.js';
+const METHOD = 'textDocument/documentSymbol';
+const PAUSE_MS = 500;
+/* The names a breadcrumb and a sticky header know a symbol kind by; a kind left out is not a block worth pinning. */
+const KINDS = {
+    2: 'module',
+    3: 'namespace',
+    4: 'package',
+    5: 'class',
+    6: 'method',
+    9: 'constructor',
+    10: 'enum',
+    11: 'interface',
+    12: 'function',
+    13: 'variable',
+    14: 'constant',
+    23: 'struct'
+};
+function isHierarchical(symbols) {
+    return symbols.length > 0 && 'range' in symbols[0];
+}
+function blockOf(name, kind, startLine, endLine) {
+    const label = KINDS[kind];
+    // A one-line symbol has no body to pin, and a property or an enum member is part of the block around it.
+    return label === undefined || endLine <= startLine ? null : { startLine: startLine + 1, endLine: endLine + 1, name, kind: label };
+}
+function walk(symbols, blocks) {
+    for (const symbol of symbols) {
+        const block = blockOf(symbol.name, symbol.kind, symbol.range.start.line, symbol.range.end.line);
+        if (block !== null) {
+            blocks.push(block);
+        }
+        walk(symbol.children ?? [], blocks);
+    }
+}
+/* The multi-line symbols of a file as blocks, outermost first, in one-based lines. */
+export function blocksOf(result) {
+    const blocks = [];
+    if (result === null || result.length === 0) {
+        return blocks;
+    }
+    if (isHierarchical(result)) {
+        walk(result, blocks);
+    }
+    else {
+        for (const symbol of result) {
+            const block = blockOf(symbol.name, symbol.kind, symbol.location.range.start.line, symbol.location.range.end.line);
+            if (block !== null) {
+                blocks.push(block);
+            }
+        }
+    }
+    return blocks.sort((left, right) => left.startLine - right.startLine || right.endLine - left.endLine);
+}
+/*
+ * The symbols of the file as the blocks sticky scroll and the breadcrumb go by, with their real names. Until
+ * the first answer, and wherever no server has symbols, the editor reads blocks off the text itself.
+ */
+export class SymbolsFeature {
+    refresher;
+    listeners = new Set();
+    constructor(language, timers = realTimers) {
+        const { editor, project, uri } = language;
+        this.refresher = new Refresher(async (signal) => {
+            if (!project.service.supports(METHOD, uri)) {
+                return;
+            }
+            const result = await project.service.documentSymbols(uri, { signal });
+            if (!signal.aborted) {
+                editor.setBlocks(result === null ? null : blocksOf(result));
+                for (const listener of [...this.listeners]) {
+                    listener(result);
+                }
+            }
+        }, PAUSE_MS, timers);
+        const edits = editor.onTextChange(() => this.refresher.later());
+        const providers = language.onProvidersChanged(() => {
+            this.refresher.now();
+        });
+        language.onDispose(() => {
+            edits();
+            providers();
+            this.refresher.dispose();
+            editor.setBlocks(null);
+        });
+    }
+    /* Called with every answer that was not replaced before it came. */
+    onResult(listener) {
+        this.listeners.add(listener);
+        return () => {
+            this.listeners.delete(listener);
+        };
+    }
+}

package/dist/testing.d.ts

@@ -0,0 +1,57 @@
+import { type LanguageService, type LanguageDocument, type LanguageRequestOptions, type DiagnosticsReport, type ContentChange, type Disposable, type ProviderOptions, type CodeAction, type CodeActionContext, type CodeLens, type Command, type CompletionContext, type CompletionItem, type CompletionResult, type DocumentHighlight, type DocumentSymbolResult, type FoldingRange, type FormattingOptions, type Hover, type InlayHint, type Location, type NavigationResult, type Position, type PrepareRenameResult, type Range, type SelectionRange, type SemanticTokens, type SemanticTokensDelta, type SignatureHelp, type SignatureHelpContext, type TextEdit, type WorkspaceEdit, type WorkspaceSymbolResult } from '@adecore/lsp';
+export { ManualTimers } from './timers.ts';
+export interface LanguageCall {
+    method: string;
+    uri: string;
+    params: unknown;
+    options: LanguageRequestOptions;
+}
+export declare class FakeLanguageService implements LanguageService {
+    readonly documents: Map<string, LanguageDocument & {
+        version: number;
+    }>;
+    readonly calls: LanguageCall[];
+    readonly providers: Map<string, ProviderOptions>;
+    private readonly answers;
+    private readonly diagnostics;
+    private readonly changes;
+    respond(method: string, answer: (call: LanguageCall) => unknown, provider?: ProviderOptions): void;
+    openDocument(document: LanguageDocument): Promise<void>;
+    changeDocument(uri: string, changes: readonly ContentChange[]): Promise<void>;
+    closeDocument(uri: string): Promise<void>;
+    supports(method: string, _uri: string): boolean;
+    providerOptions(method: string, _uri: string): ProviderOptions | undefined;
+    onProvidersChanged(listener: (uri: string) => void): Disposable;
+    onDiagnostics(listener: (report: DiagnosticsReport) => void): Disposable;
+    report(report: DiagnosticsReport): void;
+    refresh(uri: string): void;
+    private request;
+    completion(uri: string, position: Position, context?: CompletionContext, options?: LanguageRequestOptions): Promise<CompletionResult>;
+    resolveCompletion(uri: string, item: CompletionItem, options?: LanguageRequestOptions): Promise<CompletionItem>;
+    hover(uri: string, position: Position, options?: LanguageRequestOptions): Promise<Hover | null>;
+    signatureHelp(uri: string, position: Position, context?: SignatureHelpContext, options?: LanguageRequestOptions): Promise<SignatureHelp | null>;
+    definition(uri: string, position: Position, options?: LanguageRequestOptions): Promise<NavigationResult>;
+    declaration(uri: string, position: Position, options?: LanguageRequestOptions): Promise<NavigationResult>;
+    typeDefinition(uri: string, position: Position, options?: LanguageRequestOptions): Promise<NavigationResult>;
+    implementation(uri: string, position: Position, options?: LanguageRequestOptions): Promise<NavigationResult>;
+    references(uri: string, position: Position, includeDeclaration?: boolean, options?: LanguageRequestOptions): Promise<Location[] | null>;
+    documentHighlights(uri: string, position: Position, options?: LanguageRequestOptions): Promise<DocumentHighlight[] | null>;
+    documentSymbols(uri: string, options?: LanguageRequestOptions): Promise<DocumentSymbolResult>;
+    prepareRename(uri: string, position: Position, options?: LanguageRequestOptions): Promise<PrepareRenameResult>;
+    rename(uri: string, position: Position, newName: string, options?: LanguageRequestOptions): Promise<WorkspaceEdit | null>;
+    codeActions(uri: string, range: Range, context?: CodeActionContext, options?: LanguageRequestOptions): Promise<(CodeAction | Command)[] | null>;
+    resolveCodeAction(uri: string, action: CodeAction, options?: LanguageRequestOptions): Promise<CodeAction>;
+    executeCommand(uri: string, command: Command, options?: LanguageRequestOptions): Promise<unknown>;
+    formatting(uri: string, formatting: FormattingOptions, options?: LanguageRequestOptions): Promise<TextEdit[] | null>;
+    rangeFormatting(uri: string, range: Range, formatting: FormattingOptions, options?: LanguageRequestOptions): Promise<TextEdit[] | null>;
+    semanticTokens(uri: string, options?: LanguageRequestOptions): Promise<SemanticTokens | null>;
+    semanticTokensDelta(uri: string, previousResultId: string, options?: LanguageRequestOptions): Promise<SemanticTokens | SemanticTokensDelta | null>;
+    semanticTokensRange(uri: string, range: Range, options?: LanguageRequestOptions): Promise<SemanticTokens | null>;
+    inlayHints(uri: string, range: Range, options?: LanguageRequestOptions): Promise<InlayHint[] | null>;
+    resolveInlayHint(uri: string, hint: InlayHint, options?: LanguageRequestOptions): Promise<InlayHint>;
+    workspaceSymbols(uri: string, query: string, options?: LanguageRequestOptions): Promise<WorkspaceSymbolResult>;
+    foldingRanges(uri: string, options?: LanguageRequestOptions): Promise<FoldingRange[] | null>;
+    selectionRanges(uri: string, positions: readonly Position[], options?: LanguageRequestOptions): Promise<SelectionRange[] | null>;
+    codeLenses(uri: string, options?: LanguageRequestOptions): Promise<CodeLens[] | null>;
+    resolveCodeLens(uri: string, lens: CodeLens, options?: LanguageRequestOptions): Promise<CodeLens>;
+}

package/dist/testing.js

@@ -0,0 +1,156 @@
+import { applyContentChanges, LspError, StaleResultError } from '@adecore/lsp';
+export { ManualTimers } from './timers.js';
+export class FakeLanguageService {
+    documents = new Map();
+    calls = [];
+    providers = new Map();
+    answers = new Map();
+    diagnostics = new Set();
+    changes = new Set();
+    respond(method, answer, provider = {}) {
+        this.answers.set(method, answer);
+        this.providers.set(method, provider);
+    }
+    async openDocument(document) {
+        const held = this.documents.get(document.uri);
+        this.documents.set(document.uri, { ...document, version: held === undefined ? 1 : held.version + (held.text === document.text ? 0 : 1) });
+        this.calls.push({ method: 'open', uri: document.uri, params: document, options: {} });
+        await this.answers.get('open')?.(this.calls.at(-1));
+    }
+    async changeDocument(uri, changes) {
+        const held = this.documents.get(uri);
+        if (held === undefined) {
+            throw new LspError('Document is not open', -32002);
+        }
+        held.text = applyContentChanges(held.text, changes);
+        held.version++;
+        this.calls.push({ method: 'change', uri, params: changes, options: {} });
+    }
+    async closeDocument(uri) {
+        this.documents.delete(uri);
+        this.calls.push({ method: 'close', uri, params: null, options: {} });
+    }
+    supports(method, _uri) {
+        return this.providers.has(method);
+    }
+    providerOptions(method, _uri) {
+        return this.providers.get(method);
+    }
+    onProvidersChanged(listener) {
+        this.changes.add(listener);
+        return { dispose: () => this.changes.delete(listener) };
+    }
+    onDiagnostics(listener) {
+        this.diagnostics.add(listener);
+        return { dispose: () => this.diagnostics.delete(listener) };
+    }
+    report(report) {
+        for (const listener of this.diagnostics) {
+            listener(report);
+        }
+    }
+    refresh(uri) {
+        for (const listener of this.changes) {
+            listener(uri);
+        }
+    }
+    async request(method, uri, params, options = {}) {
+        if (!this.supports(method, uri)) {
+            throw new LspError(`${method} is unavailable`, -32601);
+        }
+        options.signal?.throwIfAborted();
+        const version = this.documents.get(uri)?.version;
+        const call = { method, uri, params, options };
+        this.calls.push(call);
+        const result = await this.answers.get(method)?.(call);
+        options.signal?.throwIfAborted();
+        if (this.documents.get(uri)?.version !== version) {
+            throw new StaleResultError(uri);
+        }
+        return result;
+    }
+    completion(uri, position, context, options = {}) {
+        return this.request('textDocument/completion', uri, { position, context }, options);
+    }
+    resolveCompletion(uri, item, options = {}) {
+        return this.request('completionItem/resolve', uri, item, options);
+    }
+    hover(uri, position, options = {}) {
+        return this.request('textDocument/hover', uri, { position }, options);
+    }
+    signatureHelp(uri, position, context, options = {}) {
+        return this.request('textDocument/signatureHelp', uri, { position, context }, options);
+    }
+    definition(uri, position, options = {}) {
+        return this.request('textDocument/definition', uri, { position }, options);
+    }
+    declaration(uri, position, options = {}) {
+        return this.request('textDocument/declaration', uri, { position }, options);
+    }
+    typeDefinition(uri, position, options = {}) {
+        return this.request('textDocument/typeDefinition', uri, { position }, options);
+    }
+    implementation(uri, position, options = {}) {
+        return this.request('textDocument/implementation', uri, { position }, options);
+    }
+    references(uri, position, includeDeclaration, options = {}) {
+        return this.request('textDocument/references', uri, { position, context: { includeDeclaration } }, options);
+    }
+    documentHighlights(uri, position, options = {}) {
+        return this.request('textDocument/documentHighlight', uri, { position }, options);
+    }
+    documentSymbols(uri, options = {}) {
+        return this.request('textDocument/documentSymbol', uri, {}, options);
+    }
+    prepareRename(uri, position, options = {}) {
+        return this.request('textDocument/prepareRename', uri, { position }, options);
+    }
+    rename(uri, position, newName, options = {}) {
+        return this.request('textDocument/rename', uri, { position, newName }, options);
+    }
+    codeActions(uri, range, context, options = {}) {
+        return this.request('textDocument/codeAction', uri, { range, context }, options);
+    }
+    resolveCodeAction(uri, action, options = {}) {
+        return this.request('codeAction/resolve', uri, action, options);
+    }
+    executeCommand(uri, command, options = {}) {
+        return this.request('workspace/executeCommand', uri, command, options);
+    }
+    formatting(uri, formatting, options = {}) {
+        return this.request('textDocument/formatting', uri, { options: formatting }, options);
+    }
+    rangeFormatting(uri, range, formatting, options = {}) {
+        return this.request('textDocument/rangeFormatting', uri, { range, options: formatting }, options);
+    }
+    semanticTokens(uri, options = {}) {
+        return this.request('textDocument/semanticTokens/full', uri, {}, options);
+    }
+    semanticTokensDelta(uri, previousResultId, options = {}) {
+        return this.request('textDocument/semanticTokens/full/delta', uri, { previousResultId }, options);
+    }
+    semanticTokensRange(uri, range, options = {}) {
+        return this.request('textDocument/semanticTokens/range', uri, { range }, options);
+    }
+    inlayHints(uri, range, options = {}) {
+        return this.request('textDocument/inlayHint', uri, { range }, options);
+    }
+    resolveInlayHint(uri, hint, options = {}) {
+        return this.request('inlayHint/resolve', uri, hint, options);
+    }
+    workspaceSymbols(uri, query, options = {}) {
+        return this.request('workspace/symbol', uri, { query }, options);
+    }
+    foldingRanges(uri, options = {}) {
+        return this.request('textDocument/foldingRange', uri, {}, options);
+    }
+    selectionRanges(uri, positions, options = {}) {
+        return this.request('textDocument/selectionRange', uri, { positions }, options);
+    }
+    codeLenses(uri, options = {}) {
+        return this.request('textDocument/codeLens', uri, {}, options);
+    }
+    resolveCodeLens(uri, lens, options = {}) {
+        return this.request('codeLens/resolve', uri, lens, options);
+    }
+}

package/dist/timers.d.ts

@@ -0,0 +1,14 @@
+export interface Timers {
+    set(callback: () => void, delay: number): unknown;
+    clear(handle: unknown): void;
+}
+export declare const realTimers: Timers;
+export declare class ManualTimers implements Timers {
+    private now;
+    private next;
+    private readonly pending;
+    set(callback: () => void, delay: number): unknown;
+    clear(handle: unknown): void;
+    advance(milliseconds: number): void;
+    get size(): number;
+}

package/dist/timers.js

@@ -0,0 +1,34 @@
+export const realTimers = {
+    set: (callback, delay) => setTimeout(callback, delay),
+    clear: (handle) => clearTimeout(handle)
+};
+/* Runs what was scheduled when a test says how much time has passed. */
+export class ManualTimers {
+    now = 0;
+    next = 1;
+    pending = new Map();
+    set(callback, delay) {
+        const id = this.next++;
+        this.pending.set(id, { at: this.now + delay, callback });
+        return id;
+    }
+    clear(handle) {
+        this.pending.delete(handle);
+    }
+    advance(milliseconds) {
+        const until = this.now + milliseconds;
+        for (;;) {
+            const due = [...this.pending].filter(([, entry]) => entry.at <= until).sort((left, right) => left[1].at - right[1].at)[0];
+            if (due === undefined) {
+                break;
+            }
+            this.now = due[1].at;
+            this.pending.delete(due[0]);
+            due[1].callback();
+        }
+        this.now = until;
+    }
+    get size() {
+        return this.pending.size;
+    }
+}

package/dist/use-problem-counts.d.ts

@@ -0,0 +1,3 @@
+import type { EditorLanguage } from './editor-language.ts';
+import type { ProblemCounts } from './diagnostics.ts';
+export declare function useProblemCounts(language: EditorLanguage | null): ProblemCounts;