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

package/dist/code-authors.js

@@ -0,0 +1,79 @@
+import { diffLines, splitLines } from '@adecore/merge';
+import { formatNumber } from '@adecore/ui/format';
+/* What a line of the text in the editor is: the index of the commit that wrote it, or this for a line no commit holds yet. */
+export const UNCOMMITTED = -1;
+/*
+ * The commit of every line of the text in the editor. Blame was run for the text on disk, so a line
+ * the editor still has from there keeps its commit and a line that was typed since, replaced or
+ * pasted has none, which reads as uncommitted. Null when the blame is not of that text.
+ */
+export function mapBlame(blame, base, current) {
+    const baseLines = splitLines(base);
+    if (blame.lines.length !== baseLines.length) {
+        return null;
+    }
+    const mapped = new Int32Array(current.length).fill(UNCOMMITTED);
+    let basePosition = 0;
+    let position = 0;
+    const carry = (until) => {
+        for (; position < until; position++, basePosition++) {
+            mapped[position] = blame.lines[basePosition];
+        }
+    };
+    for (const change of diffLines(baseLines, current)) {
+        carry(change.otherStart);
+        position = change.otherEnd;
+        basePosition = change.baseEnd;
+    }
+    carry(current.length);
+    return mapped;
+}
+/* A person's name as git has it, with runs of space made one. */
+export function shortName(name) {
+    return name.replace(/\s+/g, ' ').trim();
+}
+/*
+ * Who wrote the lines `from` through `to`. Blank lines count for no one and a line that is not
+ * committed for no author, so a method that is only edited keeps its author and says it was edited.
+ */
+export function authorshipOf(commits, mapped, lines, from, to) {
+    const byName = new Map();
+    let uncommittedLines = 0;
+    let modified = false;
+    let latest = null;
+    for (let line = from; line <= to && line < mapped.length; line++) {
+        const index = mapped[line];
+        if (index === UNCOMMITTED) {
+            modified = true;
+        }
+        if (lines[line].trim() === '') {
+            continue;
+        }
+        if (index === UNCOMMITTED) {
+            uncommittedLines++;
+            continue;
+        }
+        const commit = commits[index];
+        const name = shortName(commit.author);
+        if (name === '') {
+            continue;
+        }
+        const author = byName.get(name) ?? { name, email: commit.email, lines: 0 };
+        author.lines++;
+        byName.set(name, author);
+        if (latest === null || commit.at > latest.at) {
+            latest = commit;
+        }
+    }
+    const authors = [...byName.values()].sort((left, right) => right.lines - left.lines || (left.name < right.name ? -1 : left.name > right.name ? 1 : 0));
+    return { authors, uncommittedLines, modified, latest };
+}
+/* The row's words: the author with most lines, how many others wrote some, and a star when the range is edited since the commit. */
+export function authorsText(authorship, i18n) {
+    const main = authorship.authors[0];
+    if (main === undefined) {
+        return i18n.t('editor:language.codeVision.newCode');
+    }
+    const others = authorship.authors.length - 1;
+    return `${main.name}${others > 0 ? ` +${formatNumber(others)}` : ''}${authorship.modified ? ' *' : ''}`;
+}

package/dist/code-vision-model.d.ts

@@ -0,0 +1,21 @@
+import type { DocumentSymbolResult, Position } from '@adecore/lsp';
+import type { i18n } from 'i18next';
+export declare const MAX_DECLARATIONS = 3000;
+export interface CodeVisionDeclaration {
+    readonly id: string;
+    readonly name: string;
+    readonly position: Position;
+    readonly line: number;
+    readonly usages: boolean;
+    readonly authors: boolean;
+    readonly authorFrom: number;
+    readonly authorTo: number;
+}
+export interface DeclarationSource {
+    readonly lineCount: number;
+    lineAt(line: number): string;
+    readonly languageId: string;
+}
+export declare function startAfterComments(source: DeclarationSource, from: Position, to: Position): Position | null;
+export declare function declarationsOf(result: DocumentSymbolResult, source: DeclarationSource): CodeVisionDeclaration[];
+export declare function usagesText(count: number, i18n: i18n): string;

package/dist/code-vision-model.js

@@ -0,0 +1,183 @@
+import { formatNumber } from '@adecore/ui/format';
+/* More declarations than this in one file and the rows are left out, which is the file that is too big for them to be quiet. */
+export const MAX_DECLARATIONS = 3000;
+/* LSP's SymbolKind: the kinds a row is drawn for and the ones whose children can be declarations too. */
+const CLASS = 5;
+const METHOD = 6;
+const PROPERTY = 7;
+const FIELD = 8;
+const CONSTRUCTOR = 9;
+const ENUM = 10;
+const INTERFACE = 11;
+const FUNCTION = 12;
+const CONSTANT = 14;
+const STRUCT = 23;
+const CONTAINERS = new Set([1, 2, 3, 4, CLASS, ENUM, INTERFACE, STRUCT]);
+const TYPES = new Set([CLASS, ENUM, INTERFACE, STRUCT]);
+const CALLABLES = new Set([METHOD, FUNCTION]);
+/* Languages whose `#` starts a comment, so a docblock written with it is passed like any other. */
+const HASH_COMMENTS = new Set(['php', 'python', 'shellscript', 'ruby', 'yaml', 'dockerfile']);
+function isLocalName(name) {
+    return name === '' || name.startsWith('<') || name === 'default';
+}
+function isUsageKind(kind, parentKind) {
+    if (TYPES.has(kind) || CALLABLES.has(kind)) {
+        return true;
+    }
+    return (kind === PROPERTY || kind === FIELD || kind === CONSTANT) && (parentKind === CLASS || parentKind === STRUCT);
+}
+function isAuthorKind(kind) {
+    return TYPES.has(kind) || CALLABLES.has(kind) || kind === CONSTRUCTOR;
+}
+function walk(symbols, path, parentKind, out) {
+    for (const symbol of symbols) {
+        out.push({
+            name: symbol.name,
+            kind: symbol.kind,
+            start: symbol.range.start,
+            end: symbol.range.end,
+            namePosition: symbol.selectionRange.start,
+            path,
+            parentKind
+        });
+        // What a function or a method holds is local to it, and a row for a callback is noise.
+        if (CONTAINERS.has(symbol.kind)) {
+            walk(symbol.children ?? [], [...path, symbol.name], symbol.kind, out);
+        }
+    }
+}
+function candidatesOf(result) {
+    const out = [];
+    if (result === null || result.length === 0) {
+        return out;
+    }
+    if ('range' in result[0]) {
+        walk(result, [], null, out);
+        return out;
+    }
+    const flat = result;
+    const containers = new Map(flat.filter((symbol) => CONTAINERS.has(symbol.kind)).map((symbol) => [symbol.name, symbol.kind]));
+    for (const symbol of flat) {
+        const container = symbol.containerName ?? '';
+        if (container !== '' && !containers.has(container)) {
+            continue;
+        }
+        out.push({
+            name: symbol.name,
+            kind: symbol.kind,
+            start: symbol.location.range.start,
+            end: symbol.location.range.end,
+            namePosition: null,
+            path: container === '' ? [] : [container],
+            parentKind: container === '' ? null : (containers.get(container) ?? null)
+        });
+    }
+    return out;
+}
+/*
+ * Where a declaration really starts: past the comments and the blank lines a server counts into its
+ * range. Null when its range is nothing but comments.
+ */
+export function startAfterComments(source, from, to) {
+    const hash = HASH_COMMENTS.has(source.languageId);
+    let line = from.line;
+    let character = from.character;
+    while (line <= to.line && line < source.lineCount) {
+        const text = source.lineAt(line);
+        let at = character;
+        while (at < text.length && (text[at] === ' ' || text[at] === '\t')) {
+            at++;
+        }
+        if (at >= text.length) {
+            line++;
+            character = 0;
+            continue;
+        }
+        if (text.startsWith('/*', at)) {
+            let end = text.indexOf('*/', at + 2);
+            let scan = line;
+            while (end === -1 && scan + 1 <= to.line && scan + 1 < source.lineCount) {
+                scan++;
+                end = source.lineAt(scan).indexOf('*/');
+            }
+            if (end === -1) {
+                return null;
+            }
+            line = scan;
+            character = end + 2;
+            continue;
+        }
+        if (text.startsWith('//', at) || (hash && text[at] === '#' && text[at + 1] !== '[')) {
+            line++;
+            character = 0;
+            continue;
+        }
+        return line > to.line ? null : { line, character: at };
+    }
+    return null;
+}
+const CLOSERS = /^\s*[})\]]*[;,]?\s*$/;
+/* The last line of a declaration that holds more than the brackets that close it or nothing, which is what its authors are read from. */
+function lastLineWithCode(source, from, to) {
+    for (let line = Math.min(to, source.lineCount - 1); line > from; line--) {
+        if (!CLOSERS.test(source.lineAt(line))) {
+            return line;
+        }
+    }
+    return from;
+}
+/* Where the name starts when a server gave only a range: its first occurrence on the line the declaration starts on. */
+function nameIn(source, name, start) {
+    const at = source.lineAt(start.line).indexOf(name, start.character);
+    return at === -1 ? null : { line: start.line, character: at };
+}
+/*
+ * The declarations of a file a row is drawn above: classes, interfaces, enums, structs, functions and
+ * methods, and the properties and constants of a class, wherever they stand outside the body of a
+ * function. Only one that starts its line gets a row, since a row sits above the line.
+ */
+export function declarationsOf(result, source) {
+    const declarations = [];
+    const seen = new Map();
+    for (const candidate of candidatesOf(result)) {
+        if (isLocalName(candidate.name)) {
+            continue;
+        }
+        const usages = isUsageKind(candidate.kind, candidate.parentKind) && !candidate.name.startsWith('__');
+        const authors = isAuthorKind(candidate.kind);
+        if (!usages && !authors) {
+            continue;
+        }
+        const start = startAfterComments(source, candidate.start, candidate.end);
+        if (start === null || source.lineAt(start.line).slice(0, start.character).trim() !== '') {
+            continue;
+        }
+        const position = candidate.namePosition ?? nameIn(source, candidate.name, start);
+        if (position === null) {
+            continue;
+        }
+        const key = `${candidate.path.join('>')}>${candidate.name}#${candidate.kind}`;
+        const index = seen.get(key) ?? 0;
+        seen.set(key, index + 1);
+        declarations.push({
+            id: `${key}#${index}`,
+            name: candidate.name,
+            position,
+            line: start.line,
+            usages,
+            authors,
+            authorFrom: position.line,
+            authorTo: lastLineWithCode(source, position.line, candidate.end.line)
+        });
+        if (declarations.length > MAX_DECLARATIONS) {
+            return [];
+        }
+    }
+    return declarations;
+}
+/* "No usages", "1 usage" and "N usages". */
+export function usagesText(count, i18n) {
+    return count === 0
+        ? i18n.t('editor:language.codeVision.usagesNone')
+        : i18n.t('editor:language.codeVision.usages', { count, formatted: formatNumber(count) });
+}

package/dist/code-vision.d.ts

@@ -0,0 +1,48 @@
+import type { GitBlameResult } from './host-types.ts';
+import type { DocumentSymbolResult } from '@adecore/lsp';
+import type { EditorLanguage } from './editor-language.ts';
+import { type Timers } from './timers.ts';
+export declare const MAX_LINES = 20000;
+export interface CodeVisionSettings {
+    readonly usages: boolean;
+    readonly authors: boolean;
+}
+export type BlameSource = {
+    readonly kind: 'pending';
+} | {
+    readonly kind: 'ready';
+    readonly blame: GitBlameResult;
+    readonly base: string;
+    openCommit?(hash: string): void;
+};
+export declare class CodeVisionFeature {
+    private readonly language;
+    private readonly timers;
+    private settings;
+    private declarations;
+    private epoch;
+    private edited;
+    private readonly counts;
+    private queue;
+    private readonly running;
+    private failed;
+    private blame;
+    private lines;
+    private mapped;
+    private readonly authorships;
+    private scrollTimer;
+    private publishing;
+    private disposed;
+    constructor(language: EditorLanguage, onSymbols: (listener: (result: DocumentSymbolResult) => void) => () => void, timers?: Timers);
+    configure(settings: CodeVisionSettings): void;
+    setBlame(blame: BlameSource | null): void;
+    private read;
+    private get canCount();
+    private plan;
+    private count;
+    private publish;
+    private rows;
+    private mapOfBlame;
+    private showAuthors;
+    closeAuthors(restoreFocus?: boolean): void;
+}

package/dist/code-vision.js

@@ -0,0 +1,236 @@
+import { splitLines } from '@adecore/merge';
+import { authorsText, authorshipOf, mapBlame } from './code-authors.js';
+import { declarationsOf, usagesText } from './code-vision-model.js';
+import { realTimers } from './timers.js';
+const REFERENCES = 'textDocument/references';
+/* Lines asked about above and below what is in view, so a little scrolling stays inside what is counted. */
+const MARGIN_LINES = 40;
+/* References are the slowest question a server is asked here, so only this many are in flight at once. */
+const MAX_PARALLEL = 3;
+const SCROLL_PAUSE_MS = 150;
+/* Past this many lines a file gets no rows at all, which is also what keeps blame and the walk of symbols cheap. */
+export const MAX_LINES = 20_000;
+/*
+ * The rows above declarations: how often each is used and, once git has been asked, who wrote it. The
+ * declarations come from the symbols the servers know, and a row holds its height from the first
+ * answer on, empty until its entries are in, so the text never moves when they arrive. Counts are asked
+ * lazily, for the declarations in view and a margin around them, a few at a time, and only after the
+ * text has settled; an old count stays on its row until the new one is in.
+ */
+export class CodeVisionFeature {
+    language;
+    timers;
+    settings = { usages: false, authors: false };
+    declarations = [];
+    /* What the declarations were read from, so a count never outlives the text it was asked for. */
+    epoch = 0;
+    edited = false;
+    counts = new Map();
+    queue = [];
+    /* Scrolling changes the pending queue but keeps requests already in flight. */
+    running = new Map();
+    /* Declarations a server could not count for this text, which are not asked again until it says it can. */
+    failed = new Set();
+    blame = null;
+    /* The text the declarations were read from, which the lines of their authors are counted in. */
+    lines = [];
+    mapped = null;
+    authorships = new Map();
+    scrollTimer;
+    publishing = false;
+    disposed = false;
+    constructor(language, onSymbols, timers = realTimers) {
+        this.language = language;
+        this.timers = timers;
+        const { editor } = language;
+        const offs = [
+            onSymbols((result) => this.read(result)),
+            editor.onTextChange(() => {
+                this.edited = true;
+                this.closeAuthors();
+            }),
+            editor.onViewChange(() => {
+                this.timers.clear(this.scrollTimer);
+                this.scrollTimer = this.timers.set(() => this.plan(), SCROLL_PAUSE_MS);
+            })
+        ];
+        const providers = language.onProvidersChanged(() => {
+            this.failed.clear();
+            this.publish();
+            this.plan();
+        });
+        language.onDispose(() => {
+            this.disposed = true;
+            for (const off of offs) {
+                off();
+            }
+            providers();
+            this.timers.clear(this.scrollTimer);
+            for (const controller of this.running.values()) {
+                controller.abort();
+            }
+            this.closeAuthors();
+            editor.setCodeVision([]);
+        });
+    }
+    /* Which rows to draw, from the settings of the client. */
+    configure(settings) {
+        if (settings.usages === this.settings.usages && settings.authors === this.settings.authors) {
+            return;
+        }
+        this.settings = settings;
+        this.publish();
+        this.plan();
+    }
+    /* What git says about the file, from the client that asked it. */
+    setBlame(blame) {
+        this.blame = blame;
+        this.mapped = null;
+        this.authorships.clear();
+        this.publish();
+    }
+    read(result) {
+        const { editor, languageId } = this.language;
+        const lines = splitLines(editor.getText());
+        this.lines = lines;
+        this.mapped = null;
+        this.authorships.clear();
+        this.edited = false;
+        this.declarations =
+            lines.length > MAX_LINES ? [] : declarationsOf(result, { lineCount: lines.length, lineAt: (line) => lines[line] ?? '', languageId });
+        this.epoch++;
+        this.failed.clear();
+        this.publish();
+        this.plan();
+    }
+    get canCount() {
+        return this.settings.usages && this.language.project.service.supports(REFERENCES, this.language.uri);
+    }
+    /* Queues the declarations in view whose count is not from the current text, nearest the top of the view first. */
+    plan() {
+        if (this.disposed || this.edited || !this.canCount) {
+            return;
+        }
+        const view = this.language.editor.getVisibleRange();
+        const first = view.start.line - MARGIN_LINES;
+        const last = view.end.line + MARGIN_LINES;
+        this.queue = this.declarations
+            .filter((declaration) => declaration.usages &&
+            declaration.line >= first &&
+            declaration.line <= last &&
+            this.counts.get(declaration.id)?.epoch !== this.epoch &&
+            !this.running.has(declaration.id) &&
+            !this.failed.has(declaration.id))
+            .sort((left, right) => Math.abs(left.line - view.start.line) - Math.abs(right.line - view.start.line));
+        while (this.running.size < MAX_PARALLEL && this.queue.length > 0) {
+            void this.count(this.queue.shift());
+        }
+    }
+    async count(declaration) {
+        const { project, uri } = this.language;
+        const controller = new AbortController();
+        this.running.set(declaration.id, controller);
+        const epoch = this.epoch;
+        try {
+            const locations = await project.service.references(uri, declaration.position, false, { signal: controller.signal, parallel: true });
+            if (!this.disposed && epoch === this.epoch) {
+                this.counts.set(declaration.id, { count: distinctPlaces(locations ?? []), epoch });
+                this.publish();
+            }
+        }
+        catch {
+            // A text that moved on is counted again from its own symbols; for a server that is not up the declaration waits for it to say so.
+            if (epoch === this.epoch) {
+                this.failed.add(declaration.id);
+            }
+        }
+        finally {
+            this.running.delete(declaration.id);
+            this.plan();
+        }
+    }
+    /* Said once for every change that lands in the same turn, since each is a pass over the rows of the layout. */
+    publish() {
+        if (this.publishing) {
+            return;
+        }
+        this.publishing = true;
+        queueMicrotask(() => {
+            this.publishing = false;
+            if (!this.disposed) {
+                this.language.editor.setCodeVision(this.rows());
+            }
+        });
+    }
+    rows() {
+        const rows = [];
+        const taken = new Set();
+        const counted = this.canCount;
+        const withAuthors = this.settings.authors && this.blame !== null;
+        const commits = this.blame?.kind === 'ready' ? this.blame.blame.commits : [];
+        const mapped = this.blame?.kind === 'ready' && this.settings.authors ? this.mapOfBlame(this.blame) : null;
+        for (const declaration of this.declarations) {
+            const reserved = (counted && declaration.usages) || (withAuthors && declaration.authors);
+            if (!reserved || taken.has(declaration.line)) {
+                continue;
+            }
+            taken.add(declaration.line);
+            const entries = [];
+            const known = this.counts.get(declaration.id);
+            if (counted && declaration.usages && known !== undefined) {
+                entries.push({
+                    id: 'usages',
+                    text: usagesText(known.count, this.language.project.i18n),
+                    activate: () => void this.language.peek.open(declaration.position)
+                });
+            }
+            if (mapped !== null && declaration.authors) {
+                let authorship = this.authorships.get(declaration.id);
+                if (authorship === undefined) {
+                    authorship = authorshipOf(commits, mapped, this.lines, declaration.authorFrom, declaration.authorTo);
+                    this.authorships.set(declaration.id, authorship);
+                }
+                const shown = authorship;
+                entries.push({
+                    id: 'authors',
+                    text: authorsText(shown, this.language.project.i18n),
+                    ...(shown.authors.length > 0 ? { icon: shown.authors.length > 1 ? 'users' : 'user' } : {}),
+                    activate: (anchor) => this.showAuthors(declaration, shown, anchor)
+                });
+            }
+            rows.push({ id: declaration.id, line: declaration.line, entries });
+        }
+        return rows;
+    }
+    mapOfBlame(source) {
+        if (this.mapped?.blame !== source.blame) {
+            this.mapped = { blame: source.blame, lines: mapBlame(source.blame, source.base, this.lines) };
+        }
+        return this.mapped.lines;
+    }
+    showAuthors(declaration, authorship, anchor) {
+        const source = this.blame;
+        const openCommit = source?.kind === 'ready' ? source.openCommit : undefined;
+        this.language.popups.setState({
+            authors: {
+                anchor,
+                name: declaration.name,
+                authorship,
+                openCommit: openCommit === undefined || authorship.latest === null ? null : () => openCommit(authorship.latest.hash)
+            }
+        });
+    }
+    /* Closes the card of the authors; `restoreFocus` is for a close that came from the keyboard, which gives the editor its keys back. */
+    closeAuthors(restoreFocus = false) {
+        if (this.language.popups.getState().authors !== null) {
+            this.language.popups.setState({ authors: null });
+            if (restoreFocus) {
+                this.language.editor.focus();
+            }
+        }
+    }
+}
+/* The places a server named, each counted once however many ways it was reached. */
+function distinctPlaces(locations) {
+    return new Set(locations.map((location) => `${location.uri}\0${location.range.start.line}\0${location.range.start.character}`)).size;
+}

package/dist/completion-call.d.ts

@@ -0,0 +1,24 @@
+import type { CompletionItem } from '@adecore/lsp';
+import { type Insertion } from './completion-model.ts';
+export declare const PARAMETER_HINTS_COMMAND = "editor.action.triggerParameterHints";
+export type CallPlan = {
+    readonly action: 'none';
+} | {
+    readonly action: 'add';
+    readonly inside: boolean;
+} | {
+    readonly action: 'enter';
+    readonly shift: number;
+};
+export interface CallSite {
+    readonly item: CompletionItem;
+    readonly languageId: string;
+    readonly insertion: Insertion;
+    readonly before: string;
+    readonly rest: string;
+    readonly replace: boolean;
+}
+export declare function isCallItem(item: CompletionItem, lineBefore: string): boolean;
+export declare function hasParameters(item: CompletionItem): boolean | null;
+export declare function planCall(site: CallSite): CallPlan;
+export declare function withParentheses(insertion: Insertion, inside: boolean): Insertion;