monaco-editor11 1.1.0 → 1.1.2

package/dist/workers/codeAction.js

@@ -0,0 +1,306 @@
+import { equals, coalesce, isNonEmptyArray } from '../../../../base/common/arrays.js';
+import { CancellationToken } from '../../../../base/common/cancellation.js';
+import { illegalArgument, isCancellationError, onUnexpectedExternalError } from '../../../../base/common/errors.js';
+import { HierarchicalKind } from '../../../../base/common/hierarchicalKind.js';
+import { DisposableStore, Disposable } from '../../../../base/common/lifecycle.js';
+import { URI } from '../../../../base/common/uri.js';
+import { localize } from '../../../../nls.js';
+import { IAccessibilitySignalService, AccessibilitySignal } from '../../../../platform/accessibilitySignal/browser/accessibilitySignalService.js';
+import { CommandsRegistry, ICommandService } from '../../../../platform/commands/common/commands.js';
+import { INotificationService } from '../../../../platform/notification/common/notification.js';
+import { Progress } from '../../../../platform/progress/common/progress.js';
+import { ITelemetryService } from '../../../../platform/telemetry/common/telemetry.js';
+import { IBulkEditService } from '../../../browser/services/bulkEditService.js';
+import { Range } from '../../../common/core/range.js';
+import { Selection } from '../../../common/core/selection.js';
+import { ProviderId } from '../../../common/languages.js';
+import { ILanguageFeaturesService } from '../../../common/services/languageFeatures.js';
+import { IModelService } from '../../../common/services/model.js';
+import { EditSources } from '../../../common/textModelEditSource.js';
+import { TextModelCancellationTokenSource } from '../../editorState/browser/editorState.js';
+import { CodeActionTriggerSource, CodeActionKind, filtersAction, CodeActionItem, mayIncludeActionsOfKind } from '../common/types.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+const codeActionCommandId = 'editor.action.codeAction';
+const quickFixCommandId = 'editor.action.quickFix';
+const autoFixCommandId = 'editor.action.autoFix';
+const refactorCommandId = 'editor.action.refactor';
+const sourceActionCommandId = 'editor.action.sourceAction';
+const organizeImportsCommandId = 'editor.action.organizeImports';
+const fixAllCommandId = 'editor.action.fixAll';
+const CODE_ACTION_SOUND_APPLIED_DURATION = 1000;
+class ManagedCodeActionSet extends Disposable {
+    static codeActionsPreferredComparator(a, b) {
+        if (a.isPreferred && !b.isPreferred) {
+            return -1;
+        }
+        else if (!a.isPreferred && b.isPreferred) {
+            return 1;
+        }
+        else {
+            return 0;
+        }
+    }
+    static codeActionsComparator({ action: a }, { action: b }) {
+        if (a.isAI && !b.isAI) {
+            return 1;
+        }
+        else if (!a.isAI && b.isAI) {
+            return -1;
+        }
+        if (isNonEmptyArray(a.diagnostics)) {
+            return isNonEmptyArray(b.diagnostics) ? ManagedCodeActionSet.codeActionsPreferredComparator(a, b) : -1;
+        }
+        else if (isNonEmptyArray(b.diagnostics)) {
+            return 1;
+        }
+        else {
+            return ManagedCodeActionSet.codeActionsPreferredComparator(a, b); // both have no diagnostics
+        }
+    }
+    constructor(actions, documentation, disposables) {
+        super();
+        this.documentation = documentation;
+        this._register(disposables);
+        this.allActions = [...actions].sort(ManagedCodeActionSet.codeActionsComparator);
+        this.validActions = this.allActions.filter(({ action }) => !action.disabled);
+    }
+    get hasAutoFix() {
+        return this.validActions.some(({ action: fix }) => !!fix.kind && CodeActionKind.QuickFix.contains(new HierarchicalKind(fix.kind)) && !!fix.isPreferred);
+    }
+    get hasAIFix() {
+        return this.validActions.some(({ action: fix }) => !!fix.isAI);
+    }
+    get allAIFixes() {
+        return this.validActions.every(({ action: fix }) => !!fix.isAI);
+    }
+}
+const emptyCodeActionsResponse = { actions: [], documentation: undefined };
+async function getCodeActions(registry, model, rangeOrSelection, trigger, progress, token) {
+    const filter = trigger.filter || {};
+    const notebookFilter = {
+        ...filter,
+        excludes: [...(filter.excludes || []), CodeActionKind.Notebook],
+    };
+    const codeActionContext = {
+        only: filter.include?.value,
+        trigger: trigger.type,
+    };
+    const cts = new TextModelCancellationTokenSource(model, token);
+    // if the trigger is auto (autosave, lightbulb, etc), we should exclude notebook codeActions
+    const excludeNotebookCodeActions = (trigger.type === 2 /* languages.CodeActionTriggerType.Auto */);
+    const providers = getCodeActionProviders(registry, model, (excludeNotebookCodeActions) ? notebookFilter : filter);
+    const disposables = new DisposableStore();
+    const promises = providers.map(async (provider) => {
+        const handle = setTimeout(() => progress.report(provider), 1250);
+        try {
+            const providedCodeActions = await provider.provideCodeActions(model, rangeOrSelection, codeActionContext, cts.token);
+            if (cts.token.isCancellationRequested) {
+                providedCodeActions?.dispose();
+                return emptyCodeActionsResponse;
+            }
+            if (providedCodeActions) {
+                disposables.add(providedCodeActions);
+            }
+            const filteredActions = (providedCodeActions?.actions || []).filter(action => action && filtersAction(filter, action));
+            const documentation = getDocumentationFromProvider(provider, filteredActions, filter.include);
+            return {
+                actions: filteredActions.map(action => new CodeActionItem(action, provider)),
+                documentation
+            };
+        }
+        catch (err) {
+            if (isCancellationError(err)) {
+                throw err;
+            }
+            onUnexpectedExternalError(err);
+            return emptyCodeActionsResponse;
+        }
+        finally {
+            clearTimeout(handle);
+        }
+    });
+    const listener = registry.onDidChange(() => {
+        const newProviders = registry.all(model);
+        if (!equals(newProviders, providers)) {
+            cts.cancel();
+        }
+    });
+    try {
+        const actions = await Promise.all(promises);
+        const allActions = actions.map(x => x.actions).flat();
+        const allDocumentation = [
+            ...coalesce(actions.map(x => x.documentation)),
+            ...getAdditionalDocumentationForShowingActions(registry, model, trigger, allActions)
+        ];
+        const managedCodeActionSet = new ManagedCodeActionSet(allActions, allDocumentation, disposables);
+        disposables.add(managedCodeActionSet);
+        return managedCodeActionSet;
+    }
+    catch (err) {
+        disposables.dispose();
+        throw err;
+    }
+    finally {
+        listener.dispose();
+        cts.dispose();
+    }
+}
+function getCodeActionProviders(registry, model, filter) {
+    return registry.all(model)
+        // Don't include providers that we know will not return code actions of interest
+        .filter(provider => {
+        if (!provider.providedCodeActionKinds) {
+            // We don't know what type of actions this provider will return.
+            return true;
+        }
+        return provider.providedCodeActionKinds.some(kind => mayIncludeActionsOfKind(filter, new HierarchicalKind(kind)));
+    });
+}
+function* getAdditionalDocumentationForShowingActions(registry, model, trigger, actionsToShow) {
+    if (model && actionsToShow.length) {
+        for (const provider of registry.all(model)) {
+            if (provider._getAdditionalMenuItems) {
+                yield* provider._getAdditionalMenuItems?.({ trigger: trigger.type, only: trigger.filter?.include?.value }, actionsToShow.map(item => item.action));
+            }
+        }
+    }
+}
+function getDocumentationFromProvider(provider, providedCodeActions, only) {
+    if (!provider.documentation) {
+        return undefined;
+    }
+    const documentation = provider.documentation.map(entry => ({ kind: new HierarchicalKind(entry.kind), command: entry.command }));
+    if (only) {
+        let currentBest;
+        for (const entry of documentation) {
+            if (entry.kind.contains(only)) {
+                if (!currentBest) {
+                    currentBest = entry;
+                }
+                else {
+                    // Take best match
+                    if (currentBest.kind.contains(entry.kind)) {
+                        currentBest = entry;
+                    }
+                }
+            }
+        }
+        if (currentBest) {
+            return currentBest?.command;
+        }
+    }
+    // Otherwise, check to see if any of the provided actions match.
+    for (const action of providedCodeActions) {
+        if (!action.kind) {
+            continue;
+        }
+        for (const entry of documentation) {
+            if (entry.kind.contains(new HierarchicalKind(action.kind))) {
+                return entry.command;
+            }
+        }
+    }
+    return undefined;
+}
+var ApplyCodeActionReason;
+(function (ApplyCodeActionReason) {
+    ApplyCodeActionReason["OnSave"] = "onSave";
+    ApplyCodeActionReason["FromProblemsView"] = "fromProblemsView";
+    ApplyCodeActionReason["FromCodeActions"] = "fromCodeActions";
+    ApplyCodeActionReason["FromAILightbulb"] = "fromAILightbulb";
+    ApplyCodeActionReason["FromProblemsHover"] = "fromProblemsHover";
+})(ApplyCodeActionReason || (ApplyCodeActionReason = {}));
+async function applyCodeAction(accessor, item, codeActionReason, options, token = CancellationToken.None) {
+    const bulkEditService = accessor.get(IBulkEditService);
+    const commandService = accessor.get(ICommandService);
+    const telemetryService = accessor.get(ITelemetryService);
+    const notificationService = accessor.get(INotificationService);
+    const accessibilitySignalService = accessor.get(IAccessibilitySignalService);
+    telemetryService.publicLog2('codeAction.applyCodeAction', {
+        codeActionTitle: item.action.title,
+        codeActionKind: item.action.kind,
+        codeActionIsPreferred: !!item.action.isPreferred,
+        reason: codeActionReason,
+    });
+    accessibilitySignalService.playSignal(AccessibilitySignal.codeActionTriggered);
+    await item.resolve(token);
+    if (token.isCancellationRequested) {
+        return;
+    }
+    if (item.action.edit?.edits.length) {
+        const result = await bulkEditService.apply(item.action.edit, {
+            editor: options?.editor,
+            label: item.action.title,
+            quotableLabel: item.action.title,
+            code: 'undoredo.codeAction',
+            respectAutoSaveConfig: codeActionReason !== ApplyCodeActionReason.OnSave,
+            showPreview: options?.preview,
+            reason: EditSources.codeAction({ kind: item.action.kind, providerId: ProviderId.fromExtensionId(item.provider?.extensionId) }),
+        });
+        if (!result.isApplied) {
+            return;
+        }
+    }
+    if (item.action.command) {
+        try {
+            await commandService.executeCommand(item.action.command.id, ...(item.action.command.arguments || []));
+        }
+        catch (err) {
+            const message = asMessage(err);
+            notificationService.error(typeof message === 'string'
+                ? message
+                : localize(830, "An unknown error occurred while applying the code action"));
+        }
+    }
+    // ensure the start sound and end sound do not overlap
+    setTimeout(() => accessibilitySignalService.playSignal(AccessibilitySignal.codeActionApplied), CODE_ACTION_SOUND_APPLIED_DURATION);
+}
+function asMessage(err) {
+    if (typeof err === 'string') {
+        return err;
+    }
+    else if (err instanceof Error && typeof err.message === 'string') {
+        return err.message;
+    }
+    else {
+        return undefined;
+    }
+}
+CommandsRegistry.registerCommand('_executeCodeActionProvider', async function (accessor, resource, rangeOrSelection, kind, itemResolveCount) {
+    if (!(resource instanceof URI)) {
+        throw illegalArgument();
+    }
+    const { codeActionProvider } = accessor.get(ILanguageFeaturesService);
+    const model = accessor.get(IModelService).getModel(resource);
+    if (!model) {
+        throw illegalArgument();
+    }
+    const validatedRangeOrSelection = Selection.isISelection(rangeOrSelection)
+        ? Selection.liftSelection(rangeOrSelection)
+        : Range.isIRange(rangeOrSelection)
+            ? model.validateRange(rangeOrSelection)
+            : undefined;
+    if (!validatedRangeOrSelection) {
+        throw illegalArgument();
+    }
+    const include = typeof kind === 'string' ? new HierarchicalKind(kind) : undefined;
+    const codeActionSet = await getCodeActions(codeActionProvider, model, validatedRangeOrSelection, { type: 1 /* languages.CodeActionTriggerType.Invoke */, triggerAction: CodeActionTriggerSource.Default, filter: { includeSourceActions: true, include } }, Progress.None, CancellationToken.None);
+    const resolving = [];
+    const resolveCount = Math.min(codeActionSet.validActions.length, typeof itemResolveCount === 'number' ? itemResolveCount : 0);
+    for (let i = 0; i < resolveCount; i++) {
+        resolving.push(codeActionSet.validActions[i].resolve(CancellationToken.None));
+    }
+    try {
+        await Promise.all(resolving);
+        return codeActionSet.validActions.map(item => item.action);
+    }
+    finally {
+        setTimeout(() => codeActionSet.dispose(), 100);
+    }
+});
+
+export { ApplyCodeActionReason, applyCodeAction, autoFixCommandId, codeActionCommandId, fixAllCommandId, getCodeActions, organizeImportsCommandId, quickFixCommandId, refactorCommandId, sourceActionCommandId };

package/dist/workers/codeActionCommands.js

@@ -0,0 +1,230 @@
+import { HierarchicalKind } from '../../../../base/common/hierarchicalKind.js';
+import { escapeRegExpCharacters } from '../../../../base/common/strings.js';
+import { EditorAction, EditorCommand } from '../../../browser/editorExtensions.js';
+import { EditorContextKeys } from '../../../common/editorContextKeys.js';
+import { quickFixCommandId, refactorCommandId, sourceActionCommandId, organizeImportsCommandId, autoFixCommandId, fixAllCommandId, codeActionCommandId } from './codeAction.js';
+import { localize, localize2 } from '../../../../nls.js';
+import { ContextKeyExpr } from '../../../../platform/contextkey/common/contextkey.js';
+import { CodeActionTriggerSource, CodeActionKind, CodeActionCommandArgs } from '../common/types.js';
+import { CodeActionController } from './codeActionController.js';
+import { SUPPORTED_CODE_ACTIONS } from './codeActionModel.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+function contextKeyForSupportedActions(kind) {
+    return ContextKeyExpr.regex(SUPPORTED_CODE_ACTIONS.keys()[0], new RegExp('(\\s|^)' + escapeRegExpCharacters(kind.value) + '\\b'));
+}
+const argsSchema = {
+    type: 'object',
+    defaultSnippets: [{ body: { kind: '' } }],
+    properties: {
+        'kind': {
+            type: 'string',
+            description: localize(831, "Kind of the code action to run."),
+        },
+        'apply': {
+            type: 'string',
+            description: localize(832, "Controls when the returned actions are applied."),
+            default: "ifSingle" /* CodeActionAutoApply.IfSingle */,
+            enum: ["first" /* CodeActionAutoApply.First */, "ifSingle" /* CodeActionAutoApply.IfSingle */, "never" /* CodeActionAutoApply.Never */],
+            enumDescriptions: [
+                localize(833, "Always apply the first returned code action."),
+                localize(834, "Apply the first returned code action if it is the only one."),
+                localize(835, "Do not apply the returned code actions."),
+            ]
+        },
+        'preferred': {
+            type: 'boolean',
+            default: false,
+            description: localize(836, "Controls if only preferred code actions should be returned."),
+        }
+    }
+};
+function triggerCodeActionsForEditorSelection(editor, notAvailableMessage, filter, autoApply, triggerAction = CodeActionTriggerSource.Default) {
+    if (editor.hasModel()) {
+        const controller = CodeActionController.get(editor);
+        controller?.manualTriggerAtCurrentPosition(notAvailableMessage, triggerAction, filter, autoApply);
+    }
+}
+class QuickFixAction extends EditorAction {
+    constructor() {
+        super({
+            id: quickFixCommandId,
+            label: localize2(853, "Quick Fix..."),
+            precondition: ContextKeyExpr.and(EditorContextKeys.writable, EditorContextKeys.hasCodeActionsProvider),
+            kbOpts: {
+                kbExpr: EditorContextKeys.textInputFocus,
+                primary: 2048 /* KeyMod.CtrlCmd */ | 89 /* KeyCode.Period */,
+                weight: 100 /* KeybindingWeight.EditorContrib */
+            }
+        });
+    }
+    run(_accessor, editor) {
+        return triggerCodeActionsForEditorSelection(editor, localize(837, "No code actions available"), undefined, undefined, CodeActionTriggerSource.QuickFix);
+    }
+}
+class CodeActionCommand extends EditorCommand {
+    constructor() {
+        super({
+            id: codeActionCommandId,
+            precondition: ContextKeyExpr.and(EditorContextKeys.writable, EditorContextKeys.hasCodeActionsProvider),
+            metadata: {
+                description: 'Trigger a code action',
+                args: [{ name: 'args', schema: argsSchema, }]
+            }
+        });
+    }
+    runEditorCommand(_accessor, editor, userArgs) {
+        const args = CodeActionCommandArgs.fromUser(userArgs, {
+            kind: HierarchicalKind.Empty,
+            apply: "ifSingle" /* CodeActionAutoApply.IfSingle */,
+        });
+        return triggerCodeActionsForEditorSelection(editor, typeof userArgs?.kind === 'string'
+            ? args.preferred
+                ? localize(838, "No preferred code actions for '{0}' available", userArgs.kind)
+                : localize(839, "No code actions for '{0}' available", userArgs.kind)
+            : args.preferred
+                ? localize(840, "No preferred code actions available")
+                : localize(841, "No code actions available"), {
+            include: args.kind,
+            includeSourceActions: true,
+            onlyIncludePreferredActions: args.preferred,
+        }, args.apply);
+    }
+}
+class RefactorAction extends EditorAction {
+    constructor() {
+        super({
+            id: refactorCommandId,
+            label: localize2(854, "Refactor..."),
+            precondition: ContextKeyExpr.and(EditorContextKeys.writable, EditorContextKeys.hasCodeActionsProvider),
+            kbOpts: {
+                kbExpr: EditorContextKeys.textInputFocus,
+                primary: 2048 /* KeyMod.CtrlCmd */ | 1024 /* KeyMod.Shift */ | 48 /* KeyCode.KeyR */,
+                mac: {
+                    primary: 256 /* KeyMod.WinCtrl */ | 1024 /* KeyMod.Shift */ | 48 /* KeyCode.KeyR */
+                },
+                weight: 100 /* KeybindingWeight.EditorContrib */
+            },
+            contextMenuOpts: {
+                group: '1_modification',
+                order: 2,
+                when: ContextKeyExpr.and(EditorContextKeys.writable, contextKeyForSupportedActions(CodeActionKind.Refactor)),
+            },
+            metadata: {
+                description: 'Refactor...',
+                args: [{ name: 'args', schema: argsSchema }]
+            }
+        });
+    }
+    run(_accessor, editor, userArgs) {
+        const args = CodeActionCommandArgs.fromUser(userArgs, {
+            kind: CodeActionKind.Refactor,
+            apply: "never" /* CodeActionAutoApply.Never */
+        });
+        return triggerCodeActionsForEditorSelection(editor, typeof userArgs?.kind === 'string'
+            ? args.preferred
+                ? localize(842, "No preferred refactorings for '{0}' available", userArgs.kind)
+                : localize(843, "No refactorings for '{0}' available", userArgs.kind)
+            : args.preferred
+                ? localize(844, "No preferred refactorings available")
+                : localize(845, "No refactorings available"), {
+            include: CodeActionKind.Refactor.contains(args.kind) ? args.kind : HierarchicalKind.None,
+            onlyIncludePreferredActions: args.preferred
+        }, args.apply, CodeActionTriggerSource.Refactor);
+    }
+}
+class SourceAction extends EditorAction {
+    constructor() {
+        super({
+            id: sourceActionCommandId,
+            label: localize2(855, "Source Action..."),
+            precondition: ContextKeyExpr.and(EditorContextKeys.writable, EditorContextKeys.hasCodeActionsProvider),
+            contextMenuOpts: {
+                group: '1_modification',
+                order: 2.1,
+                when: ContextKeyExpr.and(EditorContextKeys.writable, contextKeyForSupportedActions(CodeActionKind.Source)),
+            },
+            metadata: {
+                description: 'Source Action...',
+                args: [{ name: 'args', schema: argsSchema }]
+            }
+        });
+    }
+    run(_accessor, editor, userArgs) {
+        const args = CodeActionCommandArgs.fromUser(userArgs, {
+            kind: CodeActionKind.Source,
+            apply: "never" /* CodeActionAutoApply.Never */
+        });
+        return triggerCodeActionsForEditorSelection(editor, typeof userArgs?.kind === 'string'
+            ? args.preferred
+                ? localize(846, "No preferred source actions for '{0}' available", userArgs.kind)
+                : localize(847, "No source actions for '{0}' available", userArgs.kind)
+            : args.preferred
+                ? localize(848, "No preferred source actions available")
+                : localize(849, "No source actions available"), {
+            include: CodeActionKind.Source.contains(args.kind) ? args.kind : HierarchicalKind.None,
+            includeSourceActions: true,
+            onlyIncludePreferredActions: args.preferred,
+        }, args.apply, CodeActionTriggerSource.SourceAction);
+    }
+}
+class OrganizeImportsAction extends EditorAction {
+    constructor() {
+        super({
+            id: organizeImportsCommandId,
+            label: localize2(856, "Organize Imports"),
+            precondition: ContextKeyExpr.and(EditorContextKeys.writable, contextKeyForSupportedActions(CodeActionKind.SourceOrganizeImports)),
+            kbOpts: {
+                kbExpr: EditorContextKeys.textInputFocus,
+                primary: 1024 /* KeyMod.Shift */ | 512 /* KeyMod.Alt */ | 45 /* KeyCode.KeyO */,
+                weight: 100 /* KeybindingWeight.EditorContrib */
+            },
+            metadata: {
+                description: localize2(857, "Organize imports in the current file. Also called 'Optimize Imports' by some tools")
+            }
+        });
+    }
+    run(_accessor, editor) {
+        return triggerCodeActionsForEditorSelection(editor, localize(850, "No organize imports action available"), { include: CodeActionKind.SourceOrganizeImports, includeSourceActions: true }, "ifSingle" /* CodeActionAutoApply.IfSingle */, CodeActionTriggerSource.OrganizeImports);
+    }
+}
+class FixAllAction extends EditorAction {
+    constructor() {
+        super({
+            id: fixAllCommandId,
+            label: localize2(858, "Fix All"),
+            precondition: ContextKeyExpr.and(EditorContextKeys.writable, contextKeyForSupportedActions(CodeActionKind.SourceFixAll))
+        });
+    }
+    run(_accessor, editor) {
+        return triggerCodeActionsForEditorSelection(editor, localize(851, "No fix all action available"), { include: CodeActionKind.SourceFixAll, includeSourceActions: true }, "ifSingle" /* CodeActionAutoApply.IfSingle */, CodeActionTriggerSource.FixAll);
+    }
+}
+class AutoFixAction extends EditorAction {
+    constructor() {
+        super({
+            id: autoFixCommandId,
+            label: localize2(859, "Auto Fix..."),
+            precondition: ContextKeyExpr.and(EditorContextKeys.writable, contextKeyForSupportedActions(CodeActionKind.QuickFix)),
+            kbOpts: {
+                kbExpr: EditorContextKeys.textInputFocus,
+                primary: 512 /* KeyMod.Alt */ | 1024 /* KeyMod.Shift */ | 89 /* KeyCode.Period */,
+                mac: {
+                    primary: 2048 /* KeyMod.CtrlCmd */ | 512 /* KeyMod.Alt */ | 89 /* KeyCode.Period */
+                },
+                weight: 100 /* KeybindingWeight.EditorContrib */
+            }
+        });
+    }
+    run(_accessor, editor) {
+        return triggerCodeActionsForEditorSelection(editor, localize(852, "No auto fixes available"), {
+            include: CodeActionKind.QuickFix,
+            onlyIncludePreferredActions: true
+        }, "ifSingle" /* CodeActionAutoApply.IfSingle */, CodeActionTriggerSource.AutoFix);
+    }
+}
+
+export { AutoFixAction, CodeActionCommand, FixAllAction, OrganizeImportsAction, QuickFixAction, RefactorAction, SourceAction };

package/dist/workers/codeActionContributions.js

@@ -0,0 +1,55 @@
+import { registerEditorContribution, registerEditorAction, registerEditorCommand } from '../../../browser/editorExtensions.js';
+import { editorConfigurationBaseNode } from '../../../common/config/editorConfigurationSchema.js';
+import { QuickFixAction, RefactorAction, SourceAction, OrganizeImportsAction, AutoFixAction, FixAllAction, CodeActionCommand } from './codeActionCommands.js';
+import { CodeActionController } from './codeActionController.js';
+import { LightBulbWidget } from './lightBulbWidget.js';
+import { localize } from '../../../../nls.js';
+import { Extensions } from '../../../../platform/configuration/common/configurationRegistry.js';
+import { Registry } from '../../../../platform/registry/common/platform.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+registerEditorContribution(CodeActionController.ID, CodeActionController, 3 /* EditorContributionInstantiation.Eventually */);
+registerEditorContribution(LightBulbWidget.ID, LightBulbWidget, 4 /* EditorContributionInstantiation.Lazy */);
+registerEditorAction(QuickFixAction);
+registerEditorAction(RefactorAction);
+registerEditorAction(SourceAction);
+registerEditorAction(OrganizeImportsAction);
+registerEditorAction(AutoFixAction);
+registerEditorAction(FixAllAction);
+registerEditorCommand(new CodeActionCommand());
+Registry.as(Extensions.Configuration).registerConfiguration({
+    ...editorConfigurationBaseNode,
+    properties: {
+        'editor.codeActionWidget.showHeaders': {
+            type: 'boolean',
+            scope: 6 /* ConfigurationScope.LANGUAGE_OVERRIDABLE */,
+            description: localize(860, "Enable/disable showing group headers in the Code Action menu."),
+            default: true,
+        },
+    }
+});
+Registry.as(Extensions.Configuration).registerConfiguration({
+    ...editorConfigurationBaseNode,
+    properties: {
+        'editor.codeActionWidget.includeNearbyQuickFixes': {
+            type: 'boolean',
+            scope: 6 /* ConfigurationScope.LANGUAGE_OVERRIDABLE */,
+            description: localize(861, "Enable/disable showing nearest Quick Fix within a line when not currently on a diagnostic."),
+            default: true,
+        },
+    }
+});
+Registry.as(Extensions.Configuration).registerConfiguration({
+    ...editorConfigurationBaseNode,
+    properties: {
+        'editor.codeActions.triggerOnFocusChange': {
+            type: 'boolean',
+            scope: 6 /* ConfigurationScope.LANGUAGE_OVERRIDABLE */,
+            markdownDescription: localize(862, 'Enable triggering {0} when {1} is set to {2}. Code Actions must be set to {3} to be triggered for window and focus changes.', '`#editor.codeActionsOnSave#`', '`#files.autoSave#`', '`afterDelay`', '`always`'),
+            default: false,
+        },
+    }
+});