@adecore/editor-react 0.38.0 → 0.40.0

package/src/code-actions.ts

@@ -26,8 +26,10 @@ const PAUSE_MS = 250;
 const INVOKED = 1;
 const AUTOMATIC = 2;
 const TOAST_ID = 'language-action';
+
 /* How many problems of the line are asked for their fixes besides the caret's own request. */
 const LINE_PROBLEMS = 3;
+
 /* The command of the PHP server that asks the client to rename the name a refactor just wrote; the server answers it with nothing. */
 const INLINE_RENAME_COMMAND = 'php.rename';
 
@@ -66,17 +68,21 @@ interface AskOptions {
 export class CodeActionsFeature {
     private readonly language: EditorLanguage;
     private readonly refresher: Refresher;
+
     /* While a list is being asked for, the lightbulb waits: both are the same request and the newer one would cancel the older. */
     private asking = false;
+
     private readonly resolved = new Map<ActionEntry, CodeAction>();
 
     constructor(language: EditorLanguage, timers: Timers = realTimers) {
         this.language = language;
         const { editor } = language;
         this.refresher = new Refresher((signal) => this.hint(signal), PAUSE_MS, timers);
+
         const providers = language.onProvidersChanged(() => {
             this.refresher.later();
         });
+
         const offs = [
             editor.onCaret(() => {
                 editor.setGutterAction(null);
@@ -89,21 +95,27 @@ export class CodeActionsFeature {
             language.onKey((event) => {
                 if (isShortcut(this.language.shortcuts.codeActions, event)) {
                     void this.open();
+
                     return true;
                 }
+
                 if (isShortcut(this.language.shortcuts.refactorThis, event)) {
                     void this.refactorThis();
+
                     return true;
                 }
+
                 return false;
             }, KEY_PRIORITY.codeActions),
             language.diagnostics.onChange(() => this.refresher.later()),
             providers
         ];
+
         language.onDispose(() => {
             for (const off of offs) {
                 off();
             }
+
             this.refresher.dispose();
             editor.setGutterAction(null);
         });
@@ -116,18 +128,21 @@ export class CodeActionsFeature {
     /* The list under the caret, or under the selection's start. */
     open(): Promise<void> {
         const range = this.language.editor.getSelection();
+
         return this.ask({ range, anchor: range.start, withLine: true });
     }
 
     /* Refactor This: only the refactorings, grouped by what they do, under the caret or the selection. */
     refactorThis(): Promise<void> {
         const range = this.language.editor.getSelection();
+
         return this.ask({ range, only: ['refactor'], anchor: range.start, groups: REFACTOR_GROUPS });
     }
 
     /* The quick fixes of one problem, under it, as the Quick fix button of its card asks. */
     quickFixFor(problem: Problem): Promise<void> {
         const { range } = problem.diagnostic;
+
         return this.ask({ range, only: ['quickfix'], anchor: range.start, diagnostics: [problem.diagnostic] });
     }
 
@@ -136,21 +151,28 @@ export class CodeActionsFeature {
         const everything = { start: { line: 0, character: 0 }, end: editor.positionAt(Number.MAX_SAFE_INTEGER) };
         const entries = await this.request(everything, INVOKED, { only: ['source.organizeImports'] });
         const entry = entries?.find((candidate) => candidate.action.kind?.startsWith('source.organizeImports') === true);
+
         if (entry === undefined) {
             this.tell('success', this.say(entries === null ? 'unavailable' : 'organized'));
+
             return;
         }
+
         await this.apply(entry);
     }
 
     async formatDocument(): Promise<void> {
         const { editor, project, uri } = this.language;
+
         if (!project.service.supports('textDocument/formatting', uri)) {
             this.tell('error', this.say('noFormatter'));
+
             return;
         }
+
         try {
             const edits = await project.service.formatting(uri, { ...editor.getIndentation() });
+
             if (edits !== null && edits.length > 0 && !editor.applyEdits(edits.map((edit) => ({ range: edit.range, text: edit.newText })))) {
                 this.tell('error', this.say('readOnly'));
             }
@@ -164,18 +186,22 @@ export class CodeActionsFeature {
         if (!this.supported) {
             return Promise.resolve(null);
         }
+
         return this.request(this.language.editor.getSelection(), AUTOMATIC, { only, order: only.includes('refactor') ? REFACTOR_GROUPS : ACTION_GROUPS });
     }
 
     private async ask(options: AskOptions): Promise<void> {
         if (!this.supported) {
             this.tell('error', this.say('unavailable'));
+
             return;
         }
+
         // The press on a card or the gutter may have taken the focus, and the list answers to the editor's keys.
         this.language.editor.focus();
         this.asking = true;
         let entries: ActionEntry[] | null;
+
         try {
             entries = options.withLine
                 ? await this.requestWithLine(options.range, INVOKED)
@@ -183,24 +209,33 @@ export class CodeActionsFeature {
         } finally {
             this.asking = false;
         }
+
         if (entries === null) {
             return;
         }
+
         if (entries.length === 0) {
             this.tell('success', this.say('none'));
+
             return;
         }
+
         const byId = new Map(entries.map((entry) => [entry.id, entry]));
+
         const groups: PickGroup[] = (options.groups ?? ACTION_GROUPS).flatMap((group): PickGroup[] => {
             const rows = entries.filter((entry) => entry.group === group).map((entry) => ({ id: entry.id, label: entry.action.title, detail: '' }));
+
             return rows.length === 0 ? [] : [{ title: this.say(`groups.${group}`), rows }];
         });
+
         this.language.completion.close();
+
         this.language.pick.open({
             anchor: options.anchor,
             groups,
             accept: (id) => {
                 const entry = byId.get(id);
+
                 if (entry !== undefined) {
                     void this.apply(entry);
                 }
@@ -214,6 +249,7 @@ export class CodeActionsFeature {
     private async request(range: EditorRange, triggerKind: number, options: RequestOptions = {}): Promise<ActionEntry[] | null> {
         const { project, uri, diagnostics } = this.language;
         const { only, signal, order } = options;
+
         try {
             const about =
                 options.about ??
@@ -221,18 +257,22 @@ export class CodeActionsFeature {
                     diagnostics.problems.map((problem) => problem.diagnostic),
                     range
                 );
+
             const context = {
                 diagnostics: [...about],
                 ...(only ? { only: [...only] } : {}),
                 triggerKind: triggerKind as 1 | 2
             };
+
             const entries = actionsOf(await project.service.codeActions(uri, range, context, { signal }), order);
+
             // A server may answer with more than the kinds asked for.
             return only ? entries.filter((entry) => only.some((kind) => entry.action.kind === kind || entry.action.kind?.startsWith(`${kind}.`))) : entries;
         } catch (error) {
             if (triggerKind === INVOKED) {
                 this.fail(error);
             }
+
             return null;
         }
     }
@@ -243,42 +283,56 @@ export class CodeActionsFeature {
      */
     private async requestWithLine(range: EditorRange, triggerKind: number, signal?: AbortSignal): Promise<ActionEntry[] | null> {
         const entries = await this.request(range, triggerKind, { signal });
+
         if (entries === null || range.start.line !== range.end.line) {
             return entries;
         }
+
         const all = this.language.diagnostics.problems.map((problem) => problem.diagnostic);
+
         if (diagnosticsAt(all, range).length > 0) {
             return entries;
         }
+
         const onLine = fixableOnLine(all, range.start.line).slice(0, LINE_PROBLEMS);
+
         const fixes = await Promise.all(
             onLine.map((diagnostic) => this.request(diagnostic.range, triggerKind, { only: ['quickfix'], signal, about: [diagnostic] }))
         );
+
         return mergeEntries([entries, ...fixes.map((list) => list ?? [])]);
     }
 
     private async hint(signal: AbortSignal): Promise<void> {
         const { editor } = this.language;
+
         if (this.asking || !this.supported) {
             editor.setGutterAction(null);
+
             return;
         }
+
         const range = editor.getSelection();
         const entries = await this.requestWithLine(range, AUTOMATIC, signal);
+
         if (signal.aborted || this.asking) {
             return;
         }
+
         editor.setGutterAction(entries?.some(isHint) === true ? { line: editor.getCaret().line, label: this.say('show') } : null);
     }
 
     private async resolve(entry: ActionEntry, signal?: AbortSignal): Promise<CodeAction> {
         const known = this.resolved.get(entry);
+
         if (known !== undefined) {
             return known;
         }
+
         const { project, uri } = this.language;
         const { action } = entry;
         let result = action;
+
         if (action.edit === undefined && project.service.providerOptions(METHOD, uri)?.resolveProvider === true) {
             try {
                 result = await project.service.resolveCodeAction(uri, action, { signal });
@@ -286,13 +340,16 @@ export class CodeActionsFeature {
                 if (isRefusal(error)) {
                     throw new ActionRefused((error as Error).message);
                 }
+
                 // An action the server cannot resolve is still tried as it is, unless the text moved under it.
                 if (error instanceof StaleResultError) {
                     throw error;
                 }
             }
         }
+
         this.resolved.set(entry, result);
+
         return result;
     }
 
@@ -300,27 +357,38 @@ export class CodeActionsFeature {
         if (entry === undefined) {
             return null;
         }
+
         let action: CodeAction;
+
         try {
             action = await this.resolve(entry, signal);
         } catch (error) {
             if (error instanceof ActionRefused) {
                 return { removed: [], added: [], note: null, refusal: error.message };
             }
+
             throw error;
         }
+
         const { editor, uri } = this.language;
         const found = action.edit === undefined ? null : previewOf(editor.getText(), action.edit, uri);
+
         if (found === null) {
             return null;
         }
-        const notes = [
-            ...(found.hiddenLines > 0 ? [this.say('moreLines', { count: found.hiddenLines })] : []),
-            ...(found.otherFiles > 0 ? [this.say('otherFiles', { count: found.otherFiles })] : []),
-            ...(found.moves > 0 ? [this.say('moves', { count: found.moves })] : []),
-            ...((found.creates ?? 0) > 0 ? [this.say('creates', { count: found.creates })] : []),
-            ...((found.deletes ?? 0) > 0 ? [this.say('deletes', { count: found.deletes })] : [])
-        ];
+
+        const counts = {
+            moreLines: found.hiddenLines,
+            otherFiles: found.otherFiles,
+            moves: found.moves,
+            creates: found.creates ?? 0,
+            deletes: found.deletes ?? 0
+        };
+
+        const notes = Object.entries(counts)
+            .filter(([, count]) => count > 0)
+            .map(([key, count]) => this.say(key, { count }));
+
         return { removed: found.removed, added: found.added, note: notes.length === 0 ? null : notes.join(' · ') };
     }
 
@@ -329,8 +397,10 @@ export class CodeActionsFeature {
         if (entry === undefined) {
             return null;
         }
+
         try {
             await this.resolve(entry);
+
             return null;
         } catch (error) {
             return error instanceof ActionRefused ? error.message : null;
@@ -340,15 +410,20 @@ export class CodeActionsFeature {
     /* Resolves the action, makes its edit as one undo step, and then runs its command. */
     async apply(entry: ActionEntry): Promise<void> {
         const { editor, project, uri } = this.language;
+
         try {
             const action = await this.resolve(entry);
+
             if (action.edit !== undefined) {
                 const result = await project.applyWorkspaceEdit(action.edit);
+
                 if (!result.applied) {
                     this.tell('error', this.say('failed', { message: result.failureReason ?? this.say('refused') }));
+
                     return;
                 }
             }
+
             if (action.command?.command === INLINE_RENAME_COMMAND) {
                 await this.startRename(action.command);
             } else if (action.command !== undefined) {
@@ -365,6 +440,7 @@ export class CodeActionsFeature {
     /* The name a refactor wrote is offered for a rename right where it stands, the way the platform does after an extraction. */
     private async startRename(command: Command): Promise<void> {
         const target = (command.arguments?.[0] ?? null) as { textDocument?: { uri?: string }; position?: Position } | null;
+
         if (target?.position !== undefined && target.textDocument?.uri === this.language.uri) {
             this.language.editor.setCaret(target.position);
             await this.language.rename.start();

package/src/code-authors.ts

@@ -13,23 +13,29 @@ export const UNCOMMITTED = -1;
  */
 export function mapBlame(blame: GitBlameResult, base: string, current: readonly string[]): Int32Array | null {
     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: number): void => {
         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;
 }
 
@@ -65,40 +71,54 @@ export function authorshipOf(commits: readonly GitBlameCommit[], mapped: Int32Ar
     let uncommittedLines = 0;
     let modified = false;
     let latest: GitBlameCommit | null = 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: CodeAuthorship, i18n: i18n): string {
     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/src/code-vision-model.ts

@@ -7,6 +7,7 @@ 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;
@@ -62,6 +63,7 @@ function isUsageKind(kind: number, parentKind: number | null): boolean {
     if (TYPES.has(kind) || CALLABLES.has(kind)) {
         return true;
     }
+
     return (kind === PROPERTY || kind === FIELD || kind === CONSTANT) && (parentKind === CLASS || parentKind === STRUCT);
 }
 
@@ -80,6 +82,7 @@ function walk(symbols: readonly DocumentSymbol[], path: readonly string[], paren
             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);
@@ -89,20 +92,27 @@ function walk(symbols: readonly DocumentSymbol[], path: readonly string[], paren
 
 function candidatesOf(result: DocumentSymbolResult): Candidate[] {
     const out: Candidate[] = [];
+
     if (result === null || result.length === 0) {
         return out;
     }
+
     if ('range' in result[0]!) {
         walk(result as DocumentSymbol[], [], null, out);
+
         return out;
     }
+
     const flat = result as SymbolInformation[];
     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,
@@ -113,6 +123,7 @@ function candidatesOf(result: DocumentSymbolResult): Candidate[] {
             parentKind: container === '' ? null : (containers.get(container) ?? null)
         });
     }
+
     return out;
 }
 
@@ -124,38 +135,51 @@ export function startAfterComments(source: DeclarationSource, from: Position, 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;
 }
 
@@ -168,12 +192,14 @@ function lastLineWithCode(source: DeclarationSource, from: number, to: number):
             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: DeclarationSource, name: string, start: Position): Position | null {
     const at = source.lineAt(start.line).indexOf(name, start.character);
+
     return at === -1 ? null : { line: start.line, character: at };
 }
 
@@ -185,26 +211,35 @@ function nameIn(source: DeclarationSource, name: string, start: Position): Posit
 export function declarationsOf(result: DocumentSymbolResult, source: DeclarationSource): CodeVisionDeclaration[] {
     const declarations: CodeVisionDeclaration[] = [];
     const seen = new Map<string, number>();
+
     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,
@@ -215,10 +250,12 @@ export function declarationsOf(result: DocumentSymbolResult, source: Declaration
             authorFrom: position.line,
             authorTo: lastLineWithCode(source, position.line, candidate.end.line)
         });
+
         if (declarations.length > MAX_DECLARATIONS) {
             return [];
         }
     }
+
     return declarations;
 }