@adecore/editor-react 0.39.0 → 0.40.1

package/src/code-vision.ts

@@ -1,18 +1,23 @@
 import { splitLines } from '@adecore/merge';
 import type { GitBlameCommit, GitBlameResult } from './host-types.ts';
 import type { EditorCodeVision, EditorCodeVisionEntry, EditorRect } from '@adecore/editor';
-import type { DocumentSymbolResult } from '@adecore/lsp';
+import type { DocumentSymbolResult, Location } from '@adecore/lsp';
 import type { EditorLanguage } from './editor-language.ts';
 import { type CodeAuthorship, authorsText, authorshipOf, mapBlame } from './code-authors.ts';
 import { type CodeVisionDeclaration, declarationsOf, usagesText } from './code-vision-model.ts';
 import { realTimers, type Timers } from './timers.ts';
+import { placeKey } from './unique.ts';
 
 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;
 
@@ -40,18 +45,25 @@ export class CodeVisionFeature {
     private readonly timers: Timers;
     private settings: CodeVisionSettings = { usages: false, authors: false };
     private declarations: CodeVisionDeclaration[] = [];
+
     /* What the declarations were read from, so a count never outlives the text it was asked for. */
     private epoch = 0;
+
     private edited = false;
     private readonly counts = new Map<string, { count: number; epoch: number }>();
     private queue: CodeVisionDeclaration[] = [];
+
     /* Scrolling changes the pending queue but keeps requests already in flight. */
     private readonly running = new Map<string, AbortController>();
+
     /* Declarations a server could not count for this text, which are not asked again until it says it can. */
     private failed = new Set<string>();
+
     private blame: BlameSource | null = null;
+
     /* The text the declarations were read from, which the lines of their authors are counted in. */
     private lines: readonly string[] = [];
+
     private mapped: { blame: GitBlameResult; lines: Int32Array | null } | null = null;
     private readonly authorships = new Map<string, CodeAuthorship>();
     private scrollTimer: unknown;
@@ -62,6 +74,7 @@ export class CodeVisionFeature {
         this.language = language;
         this.timers = timers;
         const { editor } = language;
+
         const offs = [
             onSymbols((result) => this.read(result)),
             editor.onTextChange(() => {
@@ -73,21 +86,27 @@ export class CodeVisionFeature {
                 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([]);
         });
@@ -98,6 +117,7 @@ export class CodeVisionFeature {
         if (settings.usages === this.settings.usages && settings.authors === this.settings.authors) {
             return;
         }
+
         this.settings = settings;
         this.publish();
         this.plan();
@@ -118,8 +138,10 @@ export class CodeVisionFeature {
         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();
@@ -135,9 +157,11 @@ export class CodeVisionFeature {
         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) =>
@@ -149,6 +173,7 @@ export class CodeVisionFeature {
                     !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()!);
         }
@@ -159,8 +184,10 @@ export class CodeVisionFeature {
         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();
@@ -181,9 +208,12 @@ export class CodeVisionFeature {
         if (this.publishing) {
             return;
         }
+
         this.publishing = true;
+
         queueMicrotask(() => {
             this.publishing = false;
+
             if (!this.disposed) {
                 this.language.editor.setCodeVision(this.rows());
             }
@@ -197,14 +227,18 @@ export class CodeVisionFeature {
         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: EditorCodeVisionEntry[] = [];
             const known = this.counts.get(declaration.id);
+
             if (counted && declaration.usages && known !== undefined) {
                 entries.push({
                     id: 'usages',
@@ -212,8 +246,10 @@ export class CodeVisionFeature {
                     activate: () => void this.language.peek.open(declaration.position)
                 });
             }
+
             if (mapped !== null && declaration.authors) {
                 const authorship = this.authorshipOf(declaration, commits, mapped);
+
                 entries.push({
                     id: 'authors',
                     text: authorsText(authorship, this.language.project.i18n),
@@ -221,18 +257,23 @@ export class CodeVisionFeature {
                     activate: (anchor) => this.showAuthors(declaration, authorship, anchor)
                 });
             }
+
             rows.push({ id: declaration.id, line: declaration.line, entries });
         }
+
         return rows;
     }
 
     private authorshipOf(declaration: CodeVisionDeclaration, commits: readonly GitBlameCommit[], mapped: Int32Array): CodeAuthorship {
         const known = this.authorships.get(declaration.id);
+
         if (known !== undefined) {
             return known;
         }
+
         const authorship = authorshipOf(commits, mapped, this.lines, declaration.authorFrom, declaration.authorTo);
         this.authorships.set(declaration.id, authorship);
+
         return authorship;
     }
 
@@ -240,12 +281,14 @@ export class CodeVisionFeature {
         if (this.mapped?.blame !== source.blame) {
             this.mapped = { blame: source.blame, lines: mapBlame(source.blame, source.base, this.lines) };
         }
+
         return this.mapped.lines;
     }
 
     private showAuthors(declaration: CodeVisionDeclaration, authorship: CodeAuthorship, anchor: EditorRect): void {
         const source = this.blame;
         const openCommit = source?.kind === 'ready' ? source.openCommit : undefined;
+
         this.language.popups.setState({
             authors: {
                 anchor,
@@ -260,6 +303,7 @@ export class CodeVisionFeature {
     closeAuthors(restoreFocus = false): void {
         if (this.language.popups.getState().authors !== null) {
             this.language.popups.setState({ authors: null });
+
             if (restoreFocus) {
                 this.language.editor.focus();
             }
@@ -268,6 +312,6 @@ export class CodeVisionFeature {
 }
 
 /* The places a server named, each counted once however many ways it was reached. */
-function distinctPlaces(locations: readonly { uri: string; range: { start: { line: number; character: number } } }[]): number {
-    return new Set(locations.map((location) => `${location.uri}\0${location.range.start.line}\0${location.range.start.character}`)).size;
+function distinctPlaces(locations: readonly Location[]): number {
+    return new Set(locations.map(placeKey)).size;
 }

package/src/completion-call.ts

@@ -43,10 +43,13 @@ export function isCallItem(item: CompletionItem, lineBefore: string): boolean {
 function listedParameters(signature: string): boolean | null {
     const text = signature.replace(SIGNATURE_KIND_PREFIX, '');
     const open = text.indexOf('(');
+
     if (open < 0) {
         return null;
     }
+
     let depth = 0;
+
     for (let i = open; i < text.length; i++) {
         if (text[i] === '(') {
             depth++;
@@ -54,24 +57,29 @@ function listedParameters(signature: string): boolean | null {
             return text.slice(open + 1, i).trim() !== '';
         }
     }
+
     return null;
 }
 
 /* From what the server says of the item: `(method) Box.open(flag: boolean): void` has parameters and `(): void` has none. Null when it says nothing about them. */
 export function hasParameters(item: CompletionItem): boolean | null {
     const lines = (item.detail ?? '').split('\n').filter((line) => !SOURCE_LINE.test(line.trim()));
+
     for (const signature of [item.labelDetails?.detail ?? '', ...lines]) {
         const listed = listedParameters(signature);
+
         if (listed !== null) {
             return listed;
         }
     }
+
     return null;
 }
 
 /* The text before the innermost brace that is still open, which says whether the caret is in an import or export list. */
 function beforeOpenBrace(before: string): string | null {
     let depth = 0;
+
     for (let i = before.length - 1; i >= 0; i--) {
         if (before[i] === '}') {
             depth++;
@@ -79,6 +87,7 @@ function beforeOpenBrace(before: string): string | null {
             return before.slice(0, i);
         }
     }
+
     return null;
 }
 
@@ -86,12 +95,15 @@ function beforeOpenBrace(before: string): string | null {
 function isNameOnly(languageId: string, before: string): boolean {
     const lineBefore = before.slice(before.lastIndexOf('\n') + 1);
     const brace = beforeOpenBrace(before);
+
     if (brace !== null && (IMPORT_BRACE.test(brace) || (languageId === 'php' && PHP_USE_BRACE.test(brace)))) {
         return true;
     }
+
     if (TYPE_OPERATOR.test(lineBefore) || /^\s*export\s+default\s+[\w$]*$/.test(lineBefore)) {
         return true;
     }
+
     switch (languageId) {
         case 'php':
             return /^\s*use\s/.test(lineBefore) || /#\[[^\]]*$/.test(lineBefore);
@@ -111,19 +123,25 @@ function isNameOnly(languageId: string, before: string): boolean {
 export function planCall(site: CallSite): CallPlan {
     const { item, languageId, insertion, before, rest, replace } = site;
     const lineBefore = before.slice(before.lastIndexOf('\n') + 1);
+
     if (!CALL_LANGUAGES.has(languageId) || !isCallItem(item, lineBefore) || item.insertTextFormat === SNIPPET_FORMAT || insertion.text.includes('(')) {
         return { action: 'none' };
     }
+
     if (isNameOnly(languageId, before)) {
         return { action: 'none' };
     }
+
     const existing = EXISTING_CALL.exec(rest);
+
     if (existing !== null) {
         return replace ? { action: 'enter', shift: existing[0].length } : { action: 'none' };
     }
+
     if (rest.startsWith('<')) {
         return { action: 'none' };
     }
+
     return { action: 'add', inside: hasParameters(item) !== false };
 }
 
@@ -131,5 +149,6 @@ export function planCall(site: CallSite): CallPlan {
 export function withParentheses(insertion: Insertion, inside: boolean): Insertion {
     const text = `${insertion.text}()`;
     const caret = inside ? text.length - 1 : text.length;
+
     return { range: insertion.range, text, stops: [{ index: 0, start: caret, end: caret }] };
 }

package/src/completion-model.ts

@@ -2,7 +2,7 @@ import { labelCollator } from '@adecore/ui/format';
 import type { SnippetTransformJob } from './snippet-transform-protocol.ts';
 import type { EditorContentChange, EditorPosition, EditorRange } from '@adecore/editor';
 import { applyCompletionDefaults, type CompletionItem, type CompletionResult, type MarkupContent } from '@adecore/lsp';
-import { comparePositions } from './diagnostics-model.ts';
+import { comparePositions, sameRange } from './diagnostics-model.ts';
 import { escapeMarkdown, isEmptyHover, splitSignatures, type HoverText } from './hover-content.ts';
 import type { CompletionDocs } from './popups.ts';
 import { compileSnippet, parseSnippet, tabOrder, type SnippetField, type SnippetStop, type SnippetTemplate, type SnippetVariableResolver } from './snippet.ts';
@@ -22,18 +22,23 @@ export function identifierPrefix(before: string): string {
     if (before === lastBefore) {
         return lastPrefix;
     }
+
     const characters = Array.from(before);
     let start = characters.length;
+
     while (start > 0 && IDENTIFIER_CHARACTER.test(characters[start - 1]!)) {
         start--;
     }
+
     lastBefore = before;
     lastPrefix = characters.slice(start).join('');
+
     return lastPrefix;
 }
 
 const OPENS_VALUE =
     /(?:[-=!<>&|?+*/%^:,]|(?:^|[^\p{L}\p{N}_$])(?:return|new|case|in|of|instanceof|typeof|keyof|await|yield|throw|extends|implements|as|is|not|and|or|echo|print|use|import|from|clone))$/u;
+
 const NOT_A_VALUE = /(?:\+\+|--|\/\/|\/\*\*?|^\s*[-+*])$/;
 
 /*
@@ -45,6 +50,7 @@ export function opensCompletion(before: string, text: string): boolean {
     if (text === '(' || text === '()' || text === '[' || text === '[]') {
         return true;
     }
+
     return text === ' ' && OPENS_VALUE.test(before) && !NOT_A_VALUE.test(before);
 }
 
@@ -73,10 +79,13 @@ const shapes = new Map<string, LabelShape>();
 /* What matching reads of a label, which is the same at every keystroke of a word and costs a regular expression pass to find. */
 function shapeOf(value: string): LabelShape {
     const known = shapes.get(value);
+
     if (known !== undefined) {
         return known;
     }
+
     const boundaries = [...value.matchAll(/(?:^|[_$\s-])([\p{L}\p{N}])|(\p{Lu})/gu)];
+
     const shape: LabelShape = {
         lower: value.toLocaleLowerCase(),
         offsets: boundaries.map((boundary) => boundary.index! + (boundary[1] ? boundary[0].length - boundary[1].length : 0)),
@@ -85,10 +94,13 @@ function shapeOf(value: string): LabelShape {
             .join('')
             .toLocaleLowerCase()
     };
+
     if (shapes.size >= SHAPE_LIMIT) {
         shapes.clear();
     }
+
     shapes.set(value, shape);
+
     return shape;
 }
 
@@ -102,35 +114,46 @@ export function matchDetail(value: string, prefix: string): MatchDetail | undefi
     if (prefix === '') {
         return { score: 0, positions: [] };
     }
+
     if (value.startsWith(prefix)) {
         return { score: 0, positions: run(0, prefix.length) };
     }
+
     const { lower, offsets, initials } = shapeOf(value);
     const query = prefix.toLocaleLowerCase();
+
     if (lower.startsWith(query)) {
         return { score: 1, positions: run(0, query.length) };
     }
+
     for (const offset of offsets) {
         if (lower.slice(offset).startsWith(query)) {
             return { score: 2 + offset / 1000, positions: run(offset, query.length) };
         }
     }
+
     if (initials.startsWith(query)) {
         return { score: 3, positions: offsets.slice(0, query.length) };
     }
+
     if (query.length < 2 || lower[0] !== query[0]) {
         return undefined;
     }
+
     let cursor = 0;
     const positions: number[] = [];
+
     for (const character of query) {
         const next = lower.indexOf(character, cursor);
+
         if (next < 0) {
             return undefined;
         }
+
         positions.push(next);
         cursor = next + character.length;
     }
+
     return { score: 4 + cursor / 1000, positions };
 }
 
@@ -141,12 +164,15 @@ export function matchScore(value: string, prefix: string): number | undefined {
 /* The range an item replaces when it is accepted; for an insert-or-replace edit, the one `replace` asks for. */
 export function editRangeOf(item: CompletionItem, replace: boolean): EditorRange | null {
     const edit = item.textEdit;
+
     if (edit === undefined) {
         return null;
     }
+
     if ('range' in edit) {
         return edit.range;
     }
+
     return replace ? edit.replace : edit.insert;
 }
 
@@ -154,18 +180,21 @@ export function editRangeOf(item: CompletionItem, replace: boolean): EditorRange
 export function itemsOf(result: CompletionResult): { items: CompletionItem[]; incomplete: boolean } {
     const list = result === null || Array.isArray(result) ? undefined : result;
     const items = result === null ? [] : Array.isArray(result) ? result : result.items;
+
     return {
         incomplete: list?.isIncomplete ?? false,
         items: items.flatMap((item) => {
             if (typeof item?.label !== 'string') {
                 return [];
             }
+
             try {
                 return [applyCompletionDefaults(item, list?.itemDefaults, { onInvalidRange: () => undefined })];
             } catch (error) {
                 if (error instanceof TypeError || error instanceof RangeError) {
                     return [];
                 }
+
                 throw error;
             }
         })
@@ -179,9 +208,11 @@ export function itemsOf(result: CompletionResult): { items: CompletionItem[]; in
  */
 export function prefixFor(item: CompletionItem, caret: EditorPosition, lineBefore: string, textBetween: (range: EditorRange) => string): string {
     const range = editRangeOf(item, false);
+
     if (range !== null && range.start.line === caret.line && comparePositions(range.start, caret) <= 0 && comparePositions(caret, range.end) <= 0) {
         return textBetween({ start: range.start, end: caret });
     }
+
     return identifierPrefix(lineBefore);
 }
 
@@ -203,9 +234,11 @@ export function rankCompletions(
     limit = 150
 ): Ranked[] {
     const { compare } = labelCollator();
+
     return items
         .map((item, index) => {
             const prefix = prefixOf(item);
+
             return { item, index, prefix, score: matchScore(item.filterText ?? item.label, prefix), recent: recency(item) };
         })
         .filter((entry): entry is typeof entry & { score: number } => entry.score !== undefined)
@@ -230,12 +263,14 @@ export function matchedCharacters(label: string, prefix: string): readonly numbe
 function sourceOf(item: CompletionItem): string {
     const detail = item.detail?.split('\n')[0]?.trim() ?? '';
     const imported = /^use\s+(.+)$/.exec(detail);
+
     return imported === null ? detail : imported[1]!.slice(0, Math.max(0, imported[1]!.lastIndexOf('\\')));
 }
 
 /* What stands right-aligned after a row: the module or namespace the item comes from, else what the server calls its type. */
 export function qualifierOf(item: CompletionItem): string {
     const description = item.labelDetails?.description?.trim() ?? '';
+
     return description !== '' ? description : sourceOf(item);
 }
 
@@ -247,16 +282,20 @@ export function qualifiersOf(items: readonly CompletionItem[]): string[] {
     const result = items.map(qualifierOf);
     const groups = new Map<string, number[]>();
     items.forEach((item, index) => groups.set(item.label, [...(groups.get(item.label) ?? []), index]));
+
     for (const indexes of groups.values()) {
         if (indexes.length < 2 || new Set(indexes.map((index) => result[index])).size === indexes.length) {
             continue;
         }
+
         const alternate = indexes.map((index) => sourceOf(items[index]!) || result[index]!);
         const distinct = new Set(alternate).size === indexes.length && !alternate.includes('');
+
         indexes.forEach((index, position) => {
             result[index] = distinct ? alternate[position]! : `${result[index] ?? ''} #${position + 1}`.trim();
         });
     }
+
     return result;
 }
 
@@ -278,6 +317,7 @@ export function isCallableKind(kind: number | undefined): boolean {
 /* A call snippet with the call cut off, for a name that already has its parentheses: `log(${1:value})$0` becomes `log`. */
 function withoutCall(snippet: string): string {
     const open = snippet.search(/(?<!\\)\(/);
+
     return open > 0 ? snippet.slice(0, open) : snippet;
 }
 
@@ -313,23 +353,28 @@ export function insertionOf(
 ): Insertion {
     const raw = item.textEdit?.newText ?? item.insertText ?? item.label;
     const edit = editRangeOf(item, replace);
+
     const range =
         edit === null
             ? { start: { line: caret.line, character: caret.character - identifierPrefix(lineBefore).length }, end: caret }
             : // The word grew since the answer came, so what was typed since belongs to what is replaced.
               { start: edit.start, end: comparePositions(edit.end, caret) < 0 && edit.end.line === caret.line ? caret : edit.end };
+
     if (item.insertTextFormat !== SNIPPET_FORMAT) {
         const adjusted =
             item.insertTextMode === 2
                 ? indentSnippet({ text: raw, stops: [] }, options.indentationBefore ?? lineBefore.slice(0, range.start.character))
                 : { text: raw, stops: [] };
+
         return { range, text: adjusted.text, stops: [], ...(adjusted.limited ? { limited: true } : {}) };
     }
+
     const followed = range.end.line === caret.line && lineAfter.slice(Math.max(0, range.end.character - caret.character)).startsWith('(');
     const source = followed && isCallableKind(item.kind) ? withoutCall(raw) : raw;
     const template = options.template?.source === source ? options.template : compileSnippet(source);
     const rendered = template.render(options.resolve, options.variableTransforms);
     const parsed = item.insertTextMode === 2 ? indentSnippet(rendered, options.indentationBefore ?? lineBefore.slice(0, range.start.character)) : rendered;
+
     return {
         range,
         text: parsed.text,
@@ -358,23 +403,30 @@ export function mirroredInsertions(
 ): EditorContentChange[] {
     const before = insertion.range.start.line === caret.line ? caret.character - insertion.range.start.character : -1;
     const after = insertion.range.end.line === caret.line ? insertion.range.end.character - caret.character : -1;
+
     if (before < 0 || after < 0) {
         return [];
     }
+
     const typed = text({ start: insertion.range.start, end: caret });
     const replaced = text({ start: caret, end: insertion.range.end });
+
     return carets.flatMap((other): EditorContentChange[] => {
         const at = includeSelections ? other.end : other.start;
-        if (comparePositions(other.start, primary.start) === 0 && comparePositions(other.end, primary.end) === 0) {
+
+        if (sameRange(other, primary)) {
             return [];
         }
+
         if ((!includeSelections && comparePositions(other.start, other.end) !== 0) || at.character < before) {
             return [];
         }
+
         const range = { start: { line: at.line, character: at.character - before }, end: { line: at.line, character: at.character + after } };
         const preceding = range.start.character > 0 ? text({ start: { line: at.line, character: range.start.character - 1 }, end: range.start }) : '';
         const startsWord = preceding === '' || !isIdentifierCharacter(preceding);
         const matches = startsWord && text({ start: range.start, end: at }) === typed && text({ start: at, end: range.end }) === replaced;
+
         return matches ? [{ range, text: insertion.text }] : [];
     });
 }
@@ -383,6 +435,7 @@ export function documentationText(documentation: string | MarkupContent | undefi
     if (documentation === undefined) {
         return '';
     }
+
     return typeof documentation === 'string' ? documentation : documentation.kind === 'plaintext' ? escapeMarkdown(documentation.value) : documentation.value;
 }
 
@@ -400,10 +453,12 @@ export function completionDocsOf(item: CompletionItem, highlightLanguage: string
     const source = hasSource ? lines[0]!.trim() : '';
     const code = (hasSource ? lines.slice(1) : lines).join('\n').trim();
     const parsed = splitSignatures(documentationText(item.documentation));
+
     const text: HoverText = {
         signatures: code === '' ? parsed.signatures : [{ language: highlightLanguage, code }, ...parsed.signatures],
         markdown: parsed.markdown
     };
+
     return source === '' && isEmptyHover(text) ? null : { source, text };
 }
 
@@ -475,6 +530,7 @@ export interface RowWindow {
  */
 export function rowWindow(scrollTop: number, active: number, total: number, rowHeight: number, visible: number, margin: number, padding: number): RowWindow {
     const shown = Math.floor(Math.max(0, scrollTop - padding) / rowHeight);
+
     return {
         first: Math.max(0, Math.min(shown, active) - margin),
         last: Math.min(total, Math.max(shown + visible + 1, active + 1) + margin)