@adecore/editor-react 0.39.0 → 0.40.1

package/src/project-problems.ts

@@ -38,6 +38,7 @@ export type ProblemSource = (listener: (report: ProblemReport) => void) => () =>
 export function serviceProblems(service: LanguageService, pathOf: (uri: string) => string = (uri) => uri): ProblemSource {
     return (listener) => {
         const subscription = service.onDiagnostics((report) => listener({ path: pathOf(report.uri), server: report.source, diagnostics: report.diagnostics }));
+
         return () => subscription.dispose();
     };
 }
@@ -51,8 +52,10 @@ export class ProjectProblems {
     private readonly files = new Map<string, ProblemFile>();
     private readonly listeners = new Set<() => void>();
     private readonly stop: () => void;
+
     /* The paths of `files` in order; null once a file came or went. */
     private order: string[] | null = [];
+
     /* Made on first read after a report, so a project nobody lists does no sorting. */
     private snapshot: readonly ProblemFile[] | null = [];
 
@@ -65,15 +68,18 @@ export class ProjectProblems {
     report(path: string, server: string, diagnostics: readonly Diagnostic[]): void {
         const kept = diagnostics.filter((diagnostic) => severityOf(diagnostic) !== 'hint');
         const servers = this.reports.get(path) ?? new Map<string, readonly Diagnostic[]>();
+
         if (kept.length === 0 && !servers.has(server)) {
             // A clean file reported clean again, as servers do after every edit.
             return;
         }
+
         if (kept.length === 0) {
             servers.delete(server);
         } else {
             servers.set(server, kept);
         }
+
         if (servers.size === 0) {
             this.reports.delete(path);
             this.files.delete(path);
@@ -82,11 +88,14 @@ export class ProjectProblems {
             if (!this.files.has(path)) {
                 this.order = null;
             }
+
             this.reports.set(path, servers);
             const rows = [...servers].flatMap(([name, list]) => list.map((diagnostic): ProblemRow => ({ diagnostic, server: name }))).sort(compareRows);
             this.files.set(path, { path, rows });
         }
+
         this.snapshot = null;
+
         for (const listener of [...this.listeners]) {
             listener();
         }
@@ -98,11 +107,13 @@ export class ProjectProblems {
             this.order ??= [...this.files.keys()].sort((left, right) => left.localeCompare(right));
             this.snapshot = this.order.map((path) => this.files.get(path)!);
         }
+
         return this.snapshot;
     };
 
     subscribe = (listener: () => void): (() => void) => {
         this.listeners.add(listener);
+
         return () => {
             this.listeners.delete(listener);
         };

package/src/proposal-model.ts

@@ -10,6 +10,7 @@ export interface LineSpan {
 
 export function lineSpanOf(range: EditorRange): LineSpan {
     const endsOnBreak = range.end.character === 0 && range.end.line > range.start.line;
+
     return { startLine: range.start.line + 1, endLine: endsOnBreak ? range.end.line : range.end.line + 1 };
 }
 
@@ -22,7 +23,9 @@ export function inlineRangeOf(selection: EditorRange, lineLength: (line: number)
     if (!isEmptyRange(selection)) {
         return selection;
     }
+
     const { line } = selection.start;
+
     return { start: { line, character: 0 }, end: { line, character: lineLength(line) } };
 }
 
@@ -58,19 +61,24 @@ const OPENING = /^( {0,3})(`{3,}|~{3,})(.*)$/;
 
 function openingOf(line: string): FenceStart | null {
     const match = OPENING.exec(line);
+
     if (match === null) {
         return null;
     }
+
     const [, indent = '', marks = '', info = ''] = match;
+
     // The info string of a backtick fence holds no backtick, which is what keeps a line of inline code from opening one.
     if (marks.startsWith('`') && info.includes('`')) {
         return null;
     }
+
     return { char: marks[0]!, length: marks.length, indent: indent.length, info: info.trim() };
 }
 
 function closes(line: string, start: FenceStart): boolean {
     const match = /^ {0,3}(`+|~+)\s*$/.exec(line);
+
     return match !== null && match[1]![0] === start.char && match[1]!.length >= start.length;
 }
 
@@ -97,26 +105,35 @@ export function parseAnswer(text: string): InlineAnswer {
     const lines = text.replace(/\r\n/g, '\n').split('\n');
     let open: { start: FenceStart; from: number; body: string[] } | null = null;
     let found: { from: number; to: number; body: string[] } | null = null;
+
     for (const [index, line] of lines.entries()) {
         if (open === null) {
             const start = openingOf(line);
+
             if (start !== null) {
                 open = { start, from: index, body: [] };
             }
+
             continue;
         }
+
         if (closes(line, open.start)) {
             if (isReplacement(open.start.info)) {
                 found = { from: open.from, to: index, body: open.body };
             }
+
             open = null;
+
             continue;
         }
+
         open.body.push(line.replace(new RegExp(`^ {0,${open.start.indent}}`), ''));
     }
+
     if (found === null) {
         return { replacement: null, rest: text.trim() };
     }
+
     return {
         replacement: found.body.join('\n'),
         rest: [...lines.slice(0, found.from), ...lines.slice(found.to + 1)]
@@ -131,11 +148,13 @@ export function fitReplacement(selected: string, replacement: string): string {
     const breaks = selected.includes('\r\n') ? '\r\n' : '\n';
     let fitted = replacement.replace(/\r\n/g, '\n');
     const endsOnBreak = selected.endsWith('\n');
+
     if (fitted !== '' && endsOnBreak && !fitted.endsWith('\n')) {
         fitted += '\n';
     } else if (!endsOnBreak && fitted.endsWith('\n')) {
         fitted = fitted.slice(0, -1);
     }
+
     return breaks === '\n' ? fitted : fitted.replace(/\n/g, breaks);
 }
 
@@ -151,6 +170,7 @@ export interface DiffSegment {
 
 function linesOf(text: string): string[] {
     const lines = text.replace(/\r\n/g, '\n').split('\n');
+
     return lines.length > 1 && lines.at(-1) === '' ? lines.slice(0, -1) : lines;
 }
 
@@ -164,13 +184,16 @@ export function diffSegments(selected: string, proposal: string, startLine: numb
     const other = linesOf(proposal);
     const segments: DiffSegment[] = [];
     let cursor = 0;
+
     const same = (until: number): void => {
         if (until > cursor) {
             segments.push({ kind: 'same', text: other.slice(cursor, until).join('\n'), firstLine: startLine + cursor });
         }
     };
+
     for (const change of diffLines(base, other)) {
         same(change.otherStart);
+
         if (change.otherEnd > change.otherStart) {
             segments.push({
                 kind: 'added',
@@ -181,9 +204,12 @@ export function diffSegments(selected: string, proposal: string, startLine: numb
         } else {
             segments.push({ kind: 'removed', text: base.slice(change.baseStart, change.baseEnd).join('\n') });
         }
+
         cursor = change.otherEnd;
     }
+
     same(other.length);
+
     return segments;
 }
 
@@ -192,22 +218,29 @@ export function emphasisOf(segment: DiffSegment): Array<Array<[number, number]>>
     if (segment.kind !== 'added' || segment.replaces === undefined) {
         return undefined;
     }
+
     const ranges = replacedWords(linesOf(segment.text), linesOf(segment.replaces));
+
     return ranges.some((line) => line.length > 0) ? ranges : undefined;
 }
 
 /* The offset of a position in a text whose lines end in `\n` or `\r\n`; null when the text is not that long. */
 export function offsetOf(text: string, position: EditorPosition): number | null {
     let offset = 0;
+
     for (let line = 0; line < position.line; line++) {
         const end = text.indexOf('\n', offset);
+
         if (end === -1) {
             return null;
         }
+
         offset = end + 1;
     }
+
     const lineEnd = text.indexOf('\n', offset);
     const length = (lineEnd === -1 ? text.length : lineEnd) - offset;
+
     return position.character > length ? null : offset + position.character;
 }
 
@@ -215,6 +248,7 @@ export function offsetOf(text: string, position: EditorPosition): number | null
 export function textInRange(text: string, range: EditorRange): string | null {
     const from = offsetOf(text, range.start);
     const to = offsetOf(text, range.end);
+
     return from === null || to === null || to < from ? null : text.slice(from, to);
 }
 
@@ -222,6 +256,7 @@ export function textInRange(text: string, range: EditorRange): string | null {
 export function replaceRange(text: string, range: EditorRange, replacement: string): string | null {
     const from = offsetOf(text, range.start);
     const to = offsetOf(text, range.end);
+
     return from === null || to === null || to < from ? null : `${text.slice(0, from)}${replacement}${text.slice(to)}`;
 }
 
@@ -233,18 +268,23 @@ export function locateSelection(text: string, range: EditorRange, selected: stri
     if (textInRange(text, range) === selected) {
         return range;
     }
+
     if (selected === '') {
         return null;
     }
+
     const first = text.indexOf(selected);
+
     if (first === -1 || text.indexOf(selected, first + 1) !== -1) {
         return null;
     }
+
     return { start: positionAt(text, first), end: positionAt(text, first + selected.length) };
 }
 
 function positionAt(text: string, offset: number): EditorPosition {
     const before = text.slice(0, offset);
     const line = before.split('\n').length - 1;
+
     return { line, character: offset - (before.lastIndexOf('\n') + 1) };
 }

package/src/recent-choices.ts

@@ -20,6 +20,7 @@ export class RecentChoices {
         const key = RecentChoices.keyOf(item);
         this.order.delete(key);
         this.order.set(key, ++this.tick);
+
         if (this.order.size > LIMIT) {
             this.order.delete(this.order.keys().next().value!);
         }
@@ -35,14 +36,11 @@ const stores = new Map<string, RecentChoices>();
 
 export function recentChoicesOf(languageId: string): RecentChoices {
     let store = stores.get(languageId);
+
     if (store === undefined) {
         store = new RecentChoices();
         stores.set(languageId, store);
     }
-    return store;
-}
 
-/* For a test that must not hear the choices an earlier one made. */
-export function forgetRecentChoices(): void {
-    stores.clear();
+    return store;
 }

package/src/refresher.ts

@@ -29,10 +29,12 @@ export class Refresher {
         if (this.disposed) {
             return;
         }
+
         this.timers.clear(this.timer);
         this.controller?.abort();
         const controller = new AbortController();
         this.controller = controller;
+
         this.run(controller.signal).catch((error: unknown) => {
             // A server that cannot answer yet is asked again when it says it can; a stale text is asked again by its own change.
             if (!(error instanceof StaleResultError) && !controller.signal.aborted && !isQuiet(error)) {
@@ -64,5 +66,6 @@ const QUIET_CODES: ReadonlySet<number> = new Set([
 /* A server that is not up, does not offer the feature or was asked to stop is not worth a line in the console. */
 function isQuiet(error: unknown): boolean {
     const code = (error as { code?: number } | null)?.code;
+
     return code !== undefined && QUIET_CODES.has(code);
 }

package/src/rename-model.ts

@@ -8,12 +8,15 @@ import { textEntriesOf } from './workspace-edit.ts';
 export function wordRangeAt(lineText: string, position: EditorPosition): EditorRange | null {
     let start = Math.min(position.character, lineText.length);
     let end = start;
+
     while (start > 0 && isIdentifierCharacter(lineText[start - 1]!)) {
         start--;
     }
+
     while (end < lineText.length && isIdentifierCharacter(lineText[end]!)) {
         end++;
     }
+
     return start === end ? null : { start: { line: position.line, character: start }, end: { line: position.line, character: end } };
 }
 
@@ -35,13 +38,17 @@ export function renameTargetOf(
     if (result === null) {
         return null;
     }
+
     if ('placeholder' in result) {
         return { range: result.range, placeholder: result.placeholder };
     }
+
     if ('start' in result) {
         return { range: result, placeholder: textOf(result) };
     }
+
     const word = wordAtCaret();
+
     return word === null ? null : { range: word, placeholder: textOf(word) };
 }
 
@@ -99,22 +106,30 @@ export function renameKindOf(result: DocumentSymbolResult, name: string, places:
     if (result === null || result.length === 0) {
         return undefined;
     }
+
     const named = (range: EditorRange) => places.some((place) => rangeHolds(range, place.start));
+
     if ('range' in result[0]!) {
         let found: DocumentSymbol | undefined;
+
         const walk = (symbols: readonly DocumentSymbol[]): void => {
             for (const symbol of symbols) {
                 if (named(symbol.selectionRange)) {
                     found = symbol;
                 }
+
                 walk(symbol.children ?? []);
             }
         };
+
         walk(result as DocumentSymbol[]);
+
         return found === undefined ? undefined : SYMBOL_KINDS[found.kind];
     }
+
     // A flat list only gives the whole span of a symbol, so the name has to match as well.
     const found = result.find((symbol) => 'location' in symbol && symbol.name === name && named(symbol.location.range));
+
     return found === undefined ? undefined : SYMBOL_KINDS[found.kind];
 }
 
@@ -133,8 +148,10 @@ export interface RenameFile {
 
 function lineStarts(text: string): number[] {
     const starts = [0];
+
     for (let index = 0; index < text.length; index++) {
         const code = text.charCodeAt(index);
+
         if (code === 13 && text.charCodeAt(index + 1) === 10) {
             index++;
             starts.push(index + 1);
@@ -142,34 +159,43 @@ function lineStarts(text: string): number[] {
             starts.push(index + 1);
         }
     }
+
     return starts;
 }
 
 /* The lines of a file an edit touches, each once, as they read before and after. An edit across lines is shown from its first line. */
 export function renameRowsOf(text: string, edits: readonly TextEdit[]): RenameRow[] {
     const starts = lineStarts(text);
+
     const lineAt = (line: number): { from: number; to: number } => {
         const from = starts[line] ?? text.length;
         let to = (starts[line + 1] ?? text.length + 1) - 1;
+
         while (to > from && (text[to - 1] === '\n' || text[to - 1] === '\r')) {
             to--;
         }
+
         return { from, to: Math.min(to, text.length) };
     };
+
     const byLine = new Map<number, TextEdit[]>();
+
     for (const edit of edits) {
         byLine.set(edit.range.start.line, [...(byLine.get(edit.range.start.line) ?? []), edit]);
     }
+
     return [...byLine]
         .sort((left, right) => left[0] - right[0])
         .map(([line, own]) => {
             const { from, to } = lineAt(line);
             const before = text.slice(from, to);
             let after = before;
+
             for (const edit of [...own].sort((left, right) => right.range.start.character - left.range.start.character)) {
                 const end = edit.range.end.line === line ? edit.range.end.character : before.length;
                 after = after.slice(0, edit.range.start.character) + edit.newText + after.slice(end);
             }
+
             return { line: line + 1, before, after };
         });
 }
@@ -177,9 +203,11 @@ export function renameRowsOf(text: string, edits: readonly TextEdit[]): RenameRo
 /* The lines of the files an edit edits; the files it makes, moves or deletes are listed by `resourceOperationsOf`. */
 export async function renamePreviewOf(edit: WorkspaceEdit, textOf: (uri: string) => Promise<string | null>): Promise<RenameFile[]> {
     const files: RenameFile[] = [];
+
     for (const [uri, list] of textEntriesOf(edit)) {
         const text = await textOf(uri);
         files.push({ uri, rows: text === null ? [] : renameRowsOf(text, list.flat()) });
     }
+
     return files;
 }

package/src/rename.ts

@@ -11,8 +11,10 @@ import { messageOf } from './error-message.ts';
 
 const METHOD = 'textDocument/rename';
 const TOAST_ID = 'language-rename';
+
 /* How much is read to tell a name suggester how the symbol is used: its first places, other files and lines around it. */
 const SAMPLE_LOCATIONS = 8;
+
 const SAMPLE_OTHER_FILES = 3;
 const CONTEXT_LINES = 3;
 
@@ -37,20 +39,25 @@ export class RenameFeature {
     constructor(language: EditorLanguage) {
         this.language = language;
         const { editor } = language;
+
         const offs = [
             language.onKey((event) => {
                 if (!isShortcut(this.language.shortcuts.rename, event)) {
                     return false;
                 }
+
                 void this.start();
+
                 return true;
             }, KEY_PRIORITY.rename),
             editor.onTextChange(() => this.cancel())
         ];
+
         language.onDispose(() => {
             for (const off of offs) {
                 off();
             }
+
             this.cancel();
         });
     }
@@ -61,31 +68,40 @@ export class RenameFeature {
 
     async start(): Promise<void> {
         const { editor, project, uri } = this.language;
+
         if (!project.service.supports(METHOD, uri)) {
             this.tell('error', this.say('unavailable'));
+
             return;
         }
+
         this.cancel();
         const caret = editor.getCaret();
         const prepare = project.service.providerOptions(METHOD, uri)?.prepareProvider === true;
         let answer: PrepareRenameResult;
+
         try {
             answer = prepare ? await project.service.prepareRename(uri, caret) : { defaultBehavior: true };
         } catch (error) {
             if (!(error instanceof StaleResultError)) {
                 this.tell('error', this.say('nothing'));
             }
+
             return;
         }
+
         const target = renameTargetOf(
             answer,
             (range) => editor.textInRange(range),
             () => wordRangeAt(lineTextOf(editor, caret.line), caret)
         );
+
         if (target === null) {
             this.tell('error', this.say('nothing'));
+
             return;
         }
+
         const session: Session = { target, original: editor.textInRange(target.range), edit: null, names: new AbortController() };
         this.session = session;
         this.publish({ phase: 'input', busy: false, name: target.placeholder, files: [], operations: [], occurrences: null, suggestions: [] });
@@ -96,33 +112,47 @@ export class RenameFeature {
     async submit(name: string, preview: boolean): Promise<void> {
         const session = this.session;
         const next = name.trim();
+
         if (session === null) {
             return;
         }
+
         if (next === '' || next === session.original) {
             this.finish();
+
             return;
         }
+
         this.publish({ phase: 'input', busy: true, name: next, error: null });
         const { project, uri } = this.language;
+
         try {
             const edit = await project.service.rename(uri, session.target.range.start, next);
+
             if (this.session !== session) {
                 return;
             }
+
             if (edit === null) {
                 this.fail(this.say('refused'));
+
                 return;
             }
+
             session.edit = edit;
+
             if (!preview) {
                 await this.apply(session);
+
                 return;
             }
+
             const files = await renamePreviewOf(edit, (target) => project.readText(target));
+
             if (this.session !== session) {
                 return;
             }
+
             this.publish({ phase: 'preview', busy: false, name: next, files, operations: resourceOperationsOf(edit) });
         } catch (error) {
             if (this.session === session) {
@@ -134,6 +164,7 @@ export class RenameFeature {
     /* Applies the edit the preview showed. */
     async confirm(): Promise<void> {
         const session = this.session;
+
         if (session?.edit) {
             await this.apply(session);
         }
@@ -143,6 +174,7 @@ export class RenameFeature {
         if (this.session === null) {
             return;
         }
+
         this.finish();
     }
 
@@ -155,9 +187,11 @@ export class RenameFeature {
 
     private async apply(session: Session): Promise<void> {
         const result = await this.language.project.applyWorkspaceEdit(session.edit!);
+
         if (this.session !== session) {
             return;
         }
+
         if (result.applied) {
             this.finish();
         } else {
@@ -185,17 +219,22 @@ export class RenameFeature {
     /* Lights up the places the name has in this file, and counts them all; what the servers listed, or null when they did not. */
     private async light(session: Session): Promise<readonly Location[] | null> {
         const { editor, project, uri } = this.language;
+
         if (!project.service.supports('textDocument/references', uri)) {
             return null;
         }
+
         try {
             const locations = await project.service.references(uri, session.target.range.start, true);
+
             if (this.session !== session || locations === null) {
                 return null;
             }
+
             const found = occurrencesOf(locations, uri);
             editor.setHighlights(found.inFile.map((range: EditorRange) => ({ range, kind: 'write' as const })));
             this.publish({ occurrences: { count: found.count, files: found.files } });
+
             return locations;
         } catch {
             // The count is a courtesy; renaming does not wait for it.
@@ -209,19 +248,25 @@ export class RenameFeature {
      */
     private async suggest(session: Session, locations: readonly Location[] | null): Promise<void> {
         const suggestNames = this.language.project.host.suggestNames;
+
         if (suggestNames === undefined || this.session !== session) {
             return;
         }
+
         const { editor, languageId, uri } = this.language;
+
         try {
             const line = session.target.range.start.line;
+
             const context = editor.textInRange({
                 start: { line: Math.max(0, line - CONTEXT_LINES), character: 0 },
                 end: { line: line + CONTEXT_LINES, character: Number.MAX_SAFE_INTEGER }
             });
+
             const [uses, kind] = await Promise.all([this.linesOf(locations ?? []), this.kindOf(session, locations ?? [])]);
             const request = { uri, languageId, name: session.original, ...(kind === undefined ? {} : { kind }), context, uses };
             const names = await suggestNames(request, session.names.signal);
+
             if (this.session === session && names.length > 0) {
                 this.publish({ suggestions: names });
             }
@@ -233,11 +278,14 @@ export class RenameFeature {
     /* So a suggester knows a function from a variable; a rename on a use finds the kind through the declaration's place in this file. */
     private async kindOf(session: Session, locations: readonly Location[]): Promise<string | undefined> {
         const { project, uri } = this.language;
+
         if (!project.service.supports('textDocument/documentSymbol', uri)) {
             return undefined;
         }
+
         try {
             const symbols = await project.service.documentSymbols(uri, { signal: session.names.signal, parallel: true });
+
             return renameKindOf(symbols, session.original, [session.target.range, ...occurrencesOf(locations, uri).inFile]);
         } catch {
             return undefined;
@@ -250,28 +298,36 @@ export class RenameFeature {
         const texts = new Map<string, string[] | null>();
         const lines: string[] = [];
         let others = 0;
+
         for (const location of locations.slice(0, SAMPLE_LOCATIONS)) {
             if (!texts.has(location.uri)) {
                 if (location.uri !== this.language.uri && others++ >= SAMPLE_OTHER_FILES) {
                     continue;
                 }
+
                 texts.set(location.uri, (await project.readText(location.uri))?.split('\n') ?? null);
             }
+
             const text = texts.get(location.uri)?.[location.range.start.line];
+
             if (text !== undefined && text.trim() !== '' && !lines.includes(text)) {
                 lines.push(text);
             }
         }
+
         return lines;
     }
 
     private publish(patch: Partial<RenameView>): void {
         const session = this.session;
+
         if (session === null) {
             return;
         }
+
         const { popups } = this.language;
         const current = popups.getState().rename;
+
         popups.setState({
             rename: {
                 phase: 'input',