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

package/dist/symbols.js

@@ -0,0 +1,97 @@
+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 = project.service.onProvidersChanged((changed) => {
+            if (changed === uri) {
+                this.refresher.now();
+            }
+        });
+        language.onDispose(() => {
+            edits();
+            providers.dispose();
+            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;

package/dist/use-problem-counts.js

@@ -0,0 +1,20 @@
+import { useMemo, useSyncExternalStore } from 'react';
+const NONE = { error: 0, warning: 0, info: 0 };
+function countsStore(language) {
+    let current = language?.diagnostics.counts() ?? NONE;
+    return {
+        get: () => {
+            const next = language?.diagnostics.counts() ?? NONE;
+            if (next.error !== current.error || next.warning !== current.warning || next.info !== current.info) {
+                current = next;
+            }
+            return current;
+        },
+        subscribe: (listener) => language?.diagnostics.onChange(listener) ?? (() => undefined)
+    };
+}
+/* How many errors, warnings and infos the file has, said again when the servers report. */
+export function useProblemCounts(language) {
+    const store = useMemo(() => countsStore(language), [language]);
+    return useSyncExternalStore(store.subscribe, store.get);
+}

package/dist/view-state.d.ts

@@ -0,0 +1,21 @@
+import type { EditorFolds, FoldRole } from '@adecore/editor';
+export interface RevealLineRequest {
+    readonly line: number;
+}
+export interface ViewState {
+    readonly scrollTop: number;
+    readonly line: number;
+    readonly column: number;
+    readonly folds: EditorFolds;
+}
+export declare const viewStates: Map<string, ViewState>;
+export declare function openingPlace(reveal: RevealLineRequest | null, last: ViewState | undefined, placeholderScroll: number, foldDefaults: readonly FoldRole[]): {
+    line?: number;
+    column?: number;
+    scrollTop?: number;
+    folds?: EditorFolds;
+    foldDefaults?: readonly FoldRole[];
+};
+export declare function followViewStates(endpointId: string, from: string, to: string): void;
+export declare function viewStateKey(key: string): string;
+export declare function forgetMovesFrom(key: string): void;

package/dist/view-state.js

@@ -0,0 +1,63 @@
+function endpointKey(namespace, path) {
+    return `${namespace}:${path}`;
+}
+/* Where each file's editor was when it went, so switching tabs or a node scrolling back into view opens it there again. Per window, never stored. */
+export const viewStates = new Map();
+/*
+ * A line asked for wins; otherwise where this file's editor last was, and for a file opened the first time, where the
+ * viewer before it was scrolled and with the kinds of fold the settings choose folded. What was folded comes back
+ * whichever way it opens.
+ */
+export function openingPlace(reveal, last, placeholderScroll, foldDefaults) {
+    const folds = last === undefined ? { foldDefaults } : { folds: last.folds };
+    if (reveal !== null) {
+        return { line: reveal.line, ...folds };
+    }
+    if (last !== undefined) {
+        return { line: last.line, column: last.column, scrollTop: last.scrollTop, ...folds };
+    }
+    return { scrollTop: placeholderScroll, ...folds };
+}
+/* Where a place the editors know by the key it had goes now: a file, or the files of a folder that moved. */
+const moves = [];
+function movedKey(key, from, to) {
+    if (key === from) {
+        return to;
+    }
+    return key.startsWith(`${from}/`) ? `${to}${key.slice(from.length)}` : null;
+}
+/*
+ * A file or folder moved, so where its editors were follows it. An editor that is still open writes its place once
+ * more under the key it mounted with as it closes, which `viewStateKey` sends to the new one; a new editor on the
+ * old path forgets the move.
+ */
+export function followViewStates(endpointId, from, to) {
+    const oldKey = endpointKey(endpointId, from);
+    const newKey = endpointKey(endpointId, to);
+    for (const [key, state] of [...viewStates]) {
+        const target = movedKey(key, oldKey, newKey);
+        if (target !== null) {
+            viewStates.delete(key);
+            viewStates.set(target, state);
+        }
+    }
+    moves.push({ from: oldKey, to: newKey });
+}
+/* The key an editor that mounted under `key` leaves its place under. */
+export function viewStateKey(key) {
+    for (const { from, to } of moves) {
+        const target = movedKey(key, from, to);
+        if (target !== null) {
+            return target;
+        }
+    }
+    return key;
+}
+/* An editor mounts under `key`, which is a file of its own again whatever moved away from there. */
+export function forgetMovesFrom(key) {
+    for (let i = moves.length - 1; i >= 0; i--) {
+        if (movedKey(key, moves[i].from, moves[i].to) !== null) {
+            moves.splice(i, 1);
+        }
+    }
+}

package/dist/word-diff.d.ts

@@ -0,0 +1 @@
+export declare function replacedWords(removed: readonly string[], added: readonly string[]): Array<Array<[number, number]>>;

package/dist/word-diff.js

@@ -0,0 +1,32 @@
+import { diffLines } from '@adecore/merge';
+/* A word, a run of spaces or one other character, so a change inside a line is found by word and not by letter. */
+const TOKEN = /\w+|\s+|[^\w\s]/g;
+/*
+ * The character ranges of each removed line that the added lines changed, `[start, end)` per line, for
+ * the stronger tint on the words a change replaced. Lines are only compared when as many were added as
+ * removed, since then each removed line has the line it became; any other change has no such pairing
+ * and draws no words.
+ */
+export function replacedWords(removed, added) {
+    return removed.map((line, index) => (removed.length === added.length ? replacedRanges(line, added[index]) : []));
+}
+function replacedRanges(removed, added) {
+    const before = removed.match(TOKEN) ?? [];
+    const after = added.match(TOKEN) ?? [];
+    const starts = [];
+    let offset = 0;
+    for (const token of before) {
+        starts.push(offset);
+        offset += token.length;
+    }
+    starts.push(offset);
+    const ranges = [];
+    for (const change of diffLines(before, after)) {
+        const text = removed.slice(starts[change.baseStart], starts[change.baseEnd]);
+        if (text.trim() !== '') {
+            const start = starts[change.baseStart] + (text.length - text.trimStart().length);
+            ranges.push([start, start + text.trim().length]);
+        }
+    }
+    return ranges;
+}

package/dist/workspace-edit.d.ts

@@ -0,0 +1,21 @@
+import type { Editor } from '@adecore/editor';
+import { type ApplyWorkspaceEditResult, type RenameFile, type TextEdit, type WorkspaceEdit } from '@adecore/lsp';
+import type { DiskText } from './host-types.ts';
+export interface StagedFile {
+    readonly path: string;
+    readonly disk: DiskText;
+    readonly text: string;
+}
+export interface ProjectFiles {
+    read(path: string): Promise<DiskText | null>;
+    stage(files: readonly StagedFile[]): void;
+    save(files: readonly StagedFile[]): Promise<string | null>;
+    rename(from: string, to: string): Promise<string | null>;
+}
+export interface WorkspaceEditHost {
+    editorOf(uri: string): Editor | undefined;
+    readonly files: ProjectFiles | null;
+}
+export declare function entriesOf(edit: WorkspaceEdit): Map<string, TextEdit[][]> | null;
+export declare function renamesOf(edit: WorkspaceEdit): RenameFile[];
+export declare function applyWorkspaceEdit(edit: WorkspaceEdit, host: WorkspaceEditHost): Promise<ApplyWorkspaceEditResult>;