@adecore/editor-react 0.31.12 → 0.32.0

package/dist/code-actions.js

@@ -15,10 +15,9 @@ 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';
 /* A server that would not make the action, with its reason. */
-class ActionRefused extends Error {
-}
+class ActionRefused extends Error {}
 function isRefusal(error) {
-    return error instanceof LspError && error.code === ErrorCodes.InternalError;
+  return error instanceof LspError && error.code === ErrorCodes.InternalError;
 }
 /*
  * What the servers offer at the caret or the selection: the gutter's lightbulb, the list under the caret
@@ -26,307 +25,397 @@ function isRefusal(error) {
  * before it is applied, since a server fills in its edit only when asked for it.
  */
 export class CodeActionsFeature {
-    language;
-    refresher;
-    /* While a list is being asked for, the lightbulb waits: both are the same request and the newer one would cancel the older. */
-    asking = false;
-    resolved = new Map();
-    constructor(language, 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);
-                // An answer for the caret's last place would light the bulb on the line it moved to.
-                this.refresher.cancel();
-                this.refresher.later();
-            }),
-            editor.onTextChange(() => editor.setGutterAction(null)),
-            editor.onGutterAction(() => void this.open()),
-            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);
-        });
+  language;
+  refresher;
+  /* While a list is being asked for, the lightbulb waits: both are the same request and the newer one would cancel the older. */
+  asking = false;
+  resolved = new Map();
+  constructor(language, 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);
+      // An answer for the caret's last place would light the bulb on the line it moved to.
+      this.refresher.cancel();
+      this.refresher.later();
+    }), editor.onTextChange(() => editor.setGutterAction(null)), editor.onGutterAction(() => void this.open()), 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);
+    });
+  }
+  get supported() {
+    return this.language.project.service.supports(METHOD, this.language.uri);
+  }
+  /* The list under the caret, or under the selection's start. */
+  open() {
+    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() {
+    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) {
+    const {
+      range
+    } = problem.diagnostic;
+    return this.ask({
+      range,
+      only: ['quickfix'],
+      anchor: range.start,
+      diagnostics: [problem.diagnostic]
+    });
+  }
+  async organizeImports() {
+    const {
+      editor
+    } = this.language;
+    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;
     }
-    get supported() {
-        return this.language.project.service.supports(METHOD, this.language.uri);
+    await this.apply(entry);
+  }
+  async formatDocument() {
+    const {
+      editor,
+      project,
+      uri
+    } = this.language;
+    if (!project.service.supports('textDocument/formatting', uri)) {
+      this.tell('error', this.say('noFormatter'));
+      return;
     }
-    /* The list under the caret, or under the selection's start. */
-    open() {
-        const range = this.language.editor.getSelection();
-        return this.ask({ range, anchor: range.start, withLine: true });
+    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'));
+      }
+    } catch (error) {
+      this.fail(error);
     }
-    /* Refactor This: only the refactorings, grouped by what they do, under the caret or the selection. */
-    refactorThis() {
-        const range = this.language.editor.getSelection();
-        return this.ask({ range, only: ['refactor'], anchor: range.start, groups: REFACTOR_GROUPS });
+  }
+  /* The actions of one kind for the selection, as entries a menu can list and `apply` runs. */
+  list(only) {
+    if (!this.supported) {
+      return Promise.resolve(null);
     }
-    /* The quick fixes of one problem, under it, as the Quick fix button of its card asks. */
-    quickFixFor(problem) {
-        const { range } = problem.diagnostic;
-        return this.ask({ range, only: ['quickfix'], anchor: range.start, diagnostics: [problem.diagnostic] });
+    return this.request(this.language.editor.getSelection(), AUTOMATIC, {
+      only,
+      order: only.includes('refactor') ? REFACTOR_GROUPS : ACTION_GROUPS
+    });
+  }
+  async ask(options) {
+    if (!this.supported) {
+      this.tell('error', this.say('unavailable'));
+      return;
     }
-    async organizeImports() {
-        const { editor } = this.language;
-        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);
+    // 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;
+    try {
+      entries = options.withLine ? await this.requestWithLine(options.range, INVOKED) : await this.request(options.range, INVOKED, {
+        only: options.only,
+        about: options.diagnostics,
+        order: options.groups
+      });
+    } finally {
+      this.asking = false;
     }
-    async formatDocument() {
-        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'));
-            }
-        }
-        catch (error) {
-            this.fail(error);
-        }
+    if (entries === null) {
+      return;
     }
-    /* The actions of one kind for the selection, as entries a menu can list and `apply` runs. */
-    list(only) {
-        if (!this.supported) {
-            return Promise.resolve(null);
-        }
-        return this.request(this.language.editor.getSelection(), AUTOMATIC, { only, order: only.includes('refactor') ? REFACTOR_GROUPS : ACTION_GROUPS });
+    if (entries.length === 0) {
+      this.tell('success', this.say('none'));
+      return;
     }
-    async ask(options) {
-        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;
-        try {
-            entries = options.withLine
-                ? await this.requestWithLine(options.range, INVOKED)
-                : await this.request(options.range, INVOKED, { only: options.only, about: options.diagnostics, order: options.groups });
+    const byId = new Map(entries.map(entry => [entry.id, entry]));
+    const groups = (options.groups ?? ACTION_GROUPS).flatMap(group => {
+      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);
         }
-        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 = (options.groups ?? ACTION_GROUPS).flatMap((group) => {
-            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);
-                }
-            },
-            attempt: (id) => this.refusalOf(byId.get(id)),
-            preview: (id, signal) => this.preview(byId.get(id), signal)
-        });
+      },
+      attempt: id => this.refusalOf(byId.get(id)),
+      preview: (id, signal) => this.preview(byId.get(id), signal)
+    });
+  }
+  /* Asks the servers; null when they could not answer, with the reason said aloud for a request a person made. */
+  async request(range, triggerKind, options = {}) {
+    const {
+      project,
+      uri,
+      diagnostics
+    } = this.language;
+    const {
+      only,
+      signal,
+      order
+    } = options;
+    try {
+      const about = options.about ?? diagnosticsAt(diagnostics.problems.map(problem => problem.diagnostic), range);
+      const context = {
+        diagnostics: [...about],
+        ...(only ? {
+          only: [...only]
+        } : {}),
+        triggerKind: triggerKind
+      };
+      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;
     }
-    /* Asks the servers; null when they could not answer, with the reason said aloud for a request a person made. */
-    async request(range, triggerKind, options = {}) {
-        const { project, uri, diagnostics } = this.language;
-        const { only, signal, order } = options;
-        try {
-            const about = options.about ??
-                diagnosticsAt(diagnostics.problems.map((problem) => problem.diagnostic), range);
-            const context = {
-                diagnostics: [...about],
-                ...(only ? { only: [...only] } : {}),
-                triggerKind: triggerKind
-            };
-            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;
-        }
+  }
+  /*
+   * What the servers offer at the range, and when no problem touches it, the quick fixes of the problems
+   * elsewhere on its line too, since the fix of an error is wanted from anywhere on the line it is on.
+   */
+  async requestWithLine(range, triggerKind, signal) {
+    const entries = await this.request(range, triggerKind, {
+      signal
+    });
+    if (entries === null || range.start.line !== range.end.line) {
+      return entries;
     }
-    /*
-     * What the servers offer at the range, and when no problem touches it, the quick fixes of the problems
-     * elsewhere on its line too, since the fix of an error is wanted from anywhere on the line it is on.
-     */
-    async requestWithLine(range, triggerKind, signal) {
-        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 ?? [])]);
+    const all = this.language.diagnostics.problems.map(problem => problem.diagnostic);
+    if (diagnosticsAt(all, range).length > 0) {
+      return entries;
     }
-    async hint(signal) {
-        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);
+    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 ?? [])]);
+  }
+  async hint(signal) {
+    const {
+      editor
+    } = this.language;
+    if (this.asking || !this.supported) {
+      editor.setGutterAction(null);
+      return;
     }
-    async resolve(entry, signal) {
-        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 });
-            }
-            catch (error) {
-                if (isRefusal(error)) {
-                    throw new ActionRefused(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;
+    const range = editor.getSelection();
+    const entries = await this.requestWithLine(range, AUTOMATIC, signal);
+    if (signal.aborted || this.asking) {
+      return;
     }
-    async preview(entry, signal) {
-        if (entry === undefined) {
-            return null;
-        }
-        let action;
-        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 })] : [])
-        ];
-        return { removed: found.removed, added: found.added, note: notes.length === 0 ? null : notes.join(' · ') };
+    editor.setGutterAction(entries?.some(isHint) === true ? {
+      line: editor.getCaret().line,
+      label: this.say('show')
+    } : null);
+  }
+  async resolve(entry, signal) {
+    const known = this.resolved.get(entry);
+    if (known !== undefined) {
+      return known;
     }
-    /* Why a server would not make the action, or null when it will, which resolves it for `apply` to use. */
-    async refusalOf(entry) {
-        if (entry === undefined) {
-            return null;
-        }
-        try {
-            await this.resolve(entry);
-            return null;
+    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
+        });
+      } catch (error) {
+        if (isRefusal(error)) {
+          throw new ActionRefused(error.message);
         }
-        catch (error) {
-            return error instanceof ActionRefused ? error.message : null;
+        // An action the server cannot resolve is still tried as it is, unless the text moved under it.
+        if (error instanceof StaleResultError) {
+          throw error;
         }
+      }
     }
-    /* Resolves the action, makes its edit as one undo step, and then runs its command. */
-    async apply(entry) {
-        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) {
-                await project.service.executeCommand(uri, action.command);
-            }
-        }
-        catch (error) {
-            this.fail(error);
-        }
-        finally {
-            this.resolved.delete(entry);
-            editor.focus();
-        }
+    this.resolved.set(entry, result);
+    return result;
+  }
+  async preview(entry, signal) {
+    if (entry === undefined) {
+      return null;
     }
-    /* The name a refactor wrote is offered for a rename right where it stands, the way the platform does after an extraction. */
-    async startRename(command) {
-        const target = (command.arguments?.[0] ?? null);
-        if (target?.position !== undefined && target.textDocument?.uri === this.language.uri) {
-            this.language.editor.setCaret(target.position);
-            await this.language.rename.start();
-        }
+    let action;
+    try {
+      action = await this.resolve(entry, signal);
+    } catch (error) {
+      if (error instanceof ActionRefused) {
+        return {
+          removed: [],
+          added: [],
+          note: null,
+          refusal: error.message
+        };
+      }
+      throw error;
     }
-    tell(kind, title) {
-        this.language.project.host.notify?.({ id: TOAST_ID, kind, title });
+    const {
+      editor,
+      uri
+    } = this.language;
+    const found = action.edit === undefined ? null : previewOf(editor.getText(), action.edit, uri);
+    if (found === null) {
+      return null;
     }
-    fail(error) {
-        if (!(error instanceof StaleResultError)) {
-            this.tell('error', this.say('failed', { message: messageOf(error) }));
+    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
+    })] : [])];
+    return {
+      removed: found.removed,
+      added: found.added,
+      note: notes.length === 0 ? null : notes.join(' · ')
+    };
+  }
+  /* Why a server would not make the action, or null when it will, which resolves it for `apply` to use. */
+  async refusalOf(entry) {
+    if (entry === undefined) {
+      return null;
+    }
+    try {
+      await this.resolve(entry);
+      return null;
+    } catch (error) {
+      return error instanceof ActionRefused ? error.message : null;
+    }
+  }
+  /* Resolves the action, makes its edit as one undo step, and then runs its command. */
+  async apply(entry) {
+    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) {
+        await project.service.executeCommand(uri, action.command);
+      }
+    } catch (error) {
+      this.fail(error);
+    } finally {
+      this.resolved.delete(entry);
+      editor.focus();
     }
-    say(key, options) {
-        return this.language.project.i18n.t(`editor:language.actions.${key}`, options);
+  }
+  /* The name a refactor wrote is offered for a rename right where it stands, the way the platform does after an extraction. */
+  async startRename(command) {
+    const target = command.arguments?.[0] ?? null;
+    if (target?.position !== undefined && target.textDocument?.uri === this.language.uri) {
+      this.language.editor.setCaret(target.position);
+      await this.language.rename.start();
     }
-}
+  }
+  tell(kind, title) {
+    this.language.project.host.notify?.({
+      id: TOAST_ID,
+      kind,
+      title
+    });
+  }
+  fail(error) {
+    if (!(error instanceof StaleResultError)) {
+      this.tell('error', this.say('failed', {
+        message: messageOf(error)
+      }));
+    }
+  }
+  say(key, options) {
+    return this.language.project.i18n.t(`editor:language.actions.${key}`, options);
+  }
+}