@codingame/monaco-vscode-api 4.5.1 → 5.0.0

package/vscode/src/vs/editor/contrib/codeAction/browser/codeAction.js

@@ -17,6 +17,7 @@ import { Progress } from '../../../../platform/progress/common/progress.js';
 import { ITelemetryService } from '../../../../platform/telemetry/common/telemetry.service.js';
 import { mayIncludeActionsOfKind, CodeActionKind, filtersAction, CodeActionItem, CodeActionTriggerSource } from '../common/types.js';
 import { HierarchicalKind } from '../../../../base/common/hierarchicalKind.js';
+const _moduleId = "vs/editor/contrib/codeAction/browser/codeAction";
 const codeActionCommandId = 'editor.action.codeAction';
 const quickFixCommandId = 'editor.action.quickFix';
 const autoFixCommandId = 'editor.action.autoFix';
@@ -61,12 +62,16 @@ class ManagedCodeActionSet extends Disposable {
         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
-        ));
+        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));
+        return (
+             (this.validActions.some(({ action: fix }) => !!fix.isAI))
+        );
     }
     get allAIFixes() {
         return this.validActions.every(({ action: fix }) => !!fix.isAI);
@@ -83,11 +88,11 @@ async function getCodeActions(registry, model, rangeOrSelection, trigger, progre
         only: filter.include?.value,
         trigger: trigger.type,
     };
-    const cts = ( new TextModelCancellationTokenSource(model, token));
+    const cts = ( (new TextModelCancellationTokenSource(model, token)));
     const excludeNotebookCodeActions = ((trigger.type === 2) );
     const providers = getCodeActionProviders(registry, model, (excludeNotebookCodeActions) ? notebookFilter : filter);
-    const disposables = ( new DisposableStore());
-    const promises = ( providers.map(async (provider) => {
+    const disposables = ( (new DisposableStore()));
+    const promises = ( (providers.map(async (provider) => {
         try {
             progress.report(provider);
             const providedCodeActions = await provider.provideCodeActions(model, rangeOrSelection, codeActionContext, cts.token);
@@ -100,7 +105,7 @@ async function getCodeActions(registry, model, rangeOrSelection, trigger, progre
             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)))),
+                actions: ( (filteredActions.map(action => ( (new CodeActionItem(action, provider)))))),
                 documentation
             };
         }
@@ -111,7 +116,7 @@ async function getCodeActions(registry, model, rangeOrSelection, trigger, progre
             onUnexpectedExternalError(err);
             return emptyCodeActionsResponse;
         }
-    }));
+    })));
     const listener = registry.onDidChange(() => {
         const newProviders = registry.all(model);
         if (!equals(newProviders, providers)) {
@@ -120,12 +125,14 @@ async function getCodeActions(registry, model, rangeOrSelection, trigger, progre
     });
     try {
         const actions = await Promise.all(promises);
-        const allActions = ( actions.map(x => x.actions)).flat();
+        const allActions = ( (actions.map(x => x.actions))).flat();
         const allDocumentation = [
-            ...coalesce(( actions.map(x => x.documentation))),
+            ...coalesce(( (actions.map(x => x.documentation)))),
             ...getAdditionalDocumentationForShowingActions(registry, model, trigger, allActions)
         ];
-        return ( new ManagedCodeActionSet(allActions, allDocumentation, disposables));
+        return (
+             (new ManagedCodeActionSet(allActions, allDocumentation, disposables))
+        );
     }
     finally {
         listener.dispose();
@@ -138,14 +145,18 @@ function getCodeActionProviders(registry, model, filter) {
         if (!provider.providedCodeActionKinds) {
             return true;
         }
-        return ( provider.providedCodeActionKinds.some(kind => mayIncludeActionsOfKind(filter, ( new HierarchicalKind(kind)))));
+        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)));
+                yield* provider._getAdditionalMenuItems?.({ trigger: trigger.type, only: trigger.filter?.include?.value }, ( (actionsToShow.map(item => item.action))));
             }
         }
     }
@@ -154,7 +165,9 @@ function getDocumentationFromProvider(provider, providedCodeActions, only) {
     if (!provider.documentation) {
         return undefined;
     }
-    const documentation = ( provider.documentation.map(entry => ({ kind: ( new HierarchicalKind(entry.kind)), command: entry.command })));
+    const documentation = ( (provider.documentation.map(
+        entry => ({ kind: ( (new HierarchicalKind(entry.kind))), command: entry.command })
+    )));
     if (only) {
         let currentBest;
         for (const entry of documentation) {
@@ -178,7 +191,7 @@ function getDocumentationFromProvider(provider, providedCodeActions, only) {
             continue;
         }
         for (const entry of documentation) {
-            if (entry.kind.contains(( new HierarchicalKind(action.kind)))) {
+            if (entry.kind.contains(( (new HierarchicalKind(action.kind))))) {
                 return entry.command;
             }
         }
@@ -186,12 +199,12 @@ function getDocumentationFromProvider(provider, providedCodeActions, only) {
     return undefined;
 }
 var ApplyCodeActionReason;
-( (function(ApplyCodeActionReason) {
+( ((function(ApplyCodeActionReason) {
     ApplyCodeActionReason["OnSave"] = "onSave";
     ApplyCodeActionReason["FromProblemsView"] = "fromProblemsView";
     ApplyCodeActionReason["FromCodeActions"] = "fromCodeActions";
     ApplyCodeActionReason["FromAILightbulb"] = "fromAILightbulb";
-})(ApplyCodeActionReason || (ApplyCodeActionReason = {})));
+})(ApplyCodeActionReason || (ApplyCodeActionReason = {}))));
 async function applyCodeAction(accessor, item, codeActionReason, options, token = CancellationToken.None) {
     const bulkEditService = accessor.get(IBulkEditService);
     const commandService = accessor.get(ICommandService);
@@ -228,11 +241,7 @@ async function applyCodeAction(accessor, item, codeActionReason, options, token
             const message = asMessage(err);
             notificationService.error(typeof message === 'string'
                 ? message
-                : ( localizeWithPath(
-                'vs/editor/contrib/codeAction/browser/codeAction',
-                'applyCodeActionFailed',
-                "An unknown error occurred while applying the code action"
-            )));
+                : ( localizeWithPath(_moduleId, 0, "An unknown error occurred while applying the code action")));
         }
     }
 }
@@ -264,7 +273,7 @@ CommandsRegistry.registerCommand('_executeCodeActionProvider', async function (a
     if (!validatedRangeOrSelection) {
         throw illegalArgument();
     }
-    const include = typeof kind === 'string' ? ( new HierarchicalKind(kind)) : undefined;
+    const include = typeof kind === 'string' ? ( (new HierarchicalKind(kind))) : undefined;
     const codeActionSet = await getCodeActions(codeActionProvider, model, validatedRangeOrSelection, { type: 1 , 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);
@@ -273,7 +282,9 @@ CommandsRegistry.registerCommand('_executeCodeActionProvider', async function (a
     }
     try {
         await Promise.all(resolving);
-        return ( codeActionSet.validActions.map(item => item.action));
+        return (
+             (codeActionSet.validActions.map(item => item.action))
+        );
     }
     finally {
         setTimeout(() => codeActionSet.dispose(), 100);

package/vscode/src/vs/editor/contrib/codeAction/browser/codeActionCommands.js

@@ -8,8 +8,14 @@ import { ContextKeyExpr } from '../../../../platform/contextkey/common/contextke
 import { CodeActionCommandArgs, CodeActionTriggerSource, CodeActionKind } from '../common/types.js';
 import { CodeActionController } from './codeActionController.js';
 import { SUPPORTED_CODE_ACTIONS } from './codeActionModel.js';
+const _moduleId = "vs/editor/contrib/codeAction/browser/codeActionCommands";
 function contextKeyForSupportedActions(kind) {
-    return ( ContextKeyExpr.regex(( SUPPORTED_CODE_ACTIONS.keys())[0], ( new RegExp('(\\s|^)' + escapeRegExpCharacters(kind.value) + '\\b'))));
+    return (
+         (ContextKeyExpr.regex(
+            ( (SUPPORTED_CODE_ACTIONS.keys()))[0],
+             (new RegExp('(\\s|^)' + escapeRegExpCharacters(kind.value) + '\\b'))
+        ))
+    );
 }
 const argsSchema = {
     type: 'object',
@@ -17,45 +23,29 @@ const argsSchema = {
     properties: {
         'kind': {
             type: 'string',
-            description: ( localizeWithPath(
-                'vs/editor/contrib/codeAction/browser/codeActionCommands',
-                'args.schema.kind',
-                "Kind of the code action to run."
-            )),
+            description: ( localizeWithPath(_moduleId, 0, "Kind of the code action to run.")),
         },
         'apply': {
             type: 'string',
-            description: ( localizeWithPath(
-                'vs/editor/contrib/codeAction/browser/codeActionCommands',
-                'args.schema.apply',
-                "Controls when the returned actions are applied."
-            )),
+            description: ( localizeWithPath(_moduleId, 1, "Controls when the returned actions are applied.")),
             default: "ifSingle" ,
             enum: ["first" , "ifSingle" , "never" ],
             enumDescriptions: [
+                ( localizeWithPath(_moduleId, 2, "Always apply the first returned code action.")),
                 ( localizeWithPath(
-                    'vs/editor/contrib/codeAction/browser/codeActionCommands',
-                    'args.schema.apply.first',
-                    "Always apply the first returned code action."
-                )),
-                ( localizeWithPath(
-                    'vs/editor/contrib/codeAction/browser/codeActionCommands',
-                    'args.schema.apply.ifSingle',
+                    _moduleId,
+                    3,
                     "Apply the first returned code action if it is the only one."
                 )),
-                ( localizeWithPath(
-                    'vs/editor/contrib/codeAction/browser/codeActionCommands',
-                    'args.schema.apply.never',
-                    "Do not apply the returned code actions."
-                )),
+                ( localizeWithPath(_moduleId, 4, "Do not apply the returned code actions.")),
             ]
         },
         'preferred': {
             type: 'boolean',
             default: false,
             description: ( localizeWithPath(
-                'vs/editor/contrib/codeAction/browser/codeActionCommands',
-                'args.schema.preferred',
+                _moduleId,
+                5,
                 "Controls if only preferred code actions should be returned."
             )),
         }
@@ -71,13 +61,9 @@ class QuickFixAction extends EditorAction {
     constructor() {
         super({
             id: quickFixCommandId,
-            label: ( localizeWithPath(
-                'vs/editor/contrib/codeAction/browser/codeActionCommands',
-                'quickfix.trigger.label',
-                "Quick Fix..."
-            )),
+            label: ( localizeWithPath(_moduleId, 6, "Quick Fix...")),
             alias: 'Quick Fix...',
-            precondition: ( ContextKeyExpr.and(EditorContextKeys.writable, EditorContextKeys.hasCodeActionsProvider)),
+            precondition: ( (ContextKeyExpr.and(EditorContextKeys.writable, EditorContextKeys.hasCodeActionsProvider))),
             kbOpts: {
                 kbExpr: EditorContextKeys.textInputFocus,
                 primary: 2048  | 89 ,
@@ -86,18 +72,14 @@ class QuickFixAction extends EditorAction {
         });
     }
     run(_accessor, editor) {
-        return triggerCodeActionsForEditorSelection(editor, ( localizeWithPath(
-            'vs/editor/contrib/codeAction/browser/codeActionCommands',
-            'editor.action.quickFix.noneMessage',
-            "No code actions available"
-        )), undefined, undefined, CodeActionTriggerSource.QuickFix);
+        return triggerCodeActionsForEditorSelection(editor, ( localizeWithPath(_moduleId, 7, "No code actions available")), undefined, undefined, CodeActionTriggerSource.QuickFix);
     }
 }
 class CodeActionCommand extends EditorCommand {
     constructor() {
         super({
             id: codeActionCommandId,
-            precondition: ( ContextKeyExpr.and(EditorContextKeys.writable, EditorContextKeys.hasCodeActionsProvider)),
+            precondition: ( (ContextKeyExpr.and(EditorContextKeys.writable, EditorContextKeys.hasCodeActionsProvider))),
             metadata: {
                 description: 'Trigger a code action',
                 args: [{ name: 'args', schema: argsSchema, }]
@@ -112,28 +94,15 @@ class CodeActionCommand extends EditorCommand {
         return triggerCodeActionsForEditorSelection(editor, typeof userArgs?.kind === 'string'
             ? args.preferred
                 ? ( localizeWithPath(
-            'vs/editor/contrib/codeAction/browser/codeActionCommands',
-            'editor.action.codeAction.noneMessage.preferred.kind',
+            _moduleId,
+            8,
             "No preferred code actions for '{0}' available",
             userArgs.kind
         ))
-                : ( localizeWithPath(
-            'vs/editor/contrib/codeAction/browser/codeActionCommands',
-            'editor.action.codeAction.noneMessage.kind',
-            "No code actions for '{0}' available",
-            userArgs.kind
-        ))
+                : ( localizeWithPath(_moduleId, 9, "No code actions for '{0}' available", userArgs.kind))
             : args.preferred
-                ? ( localizeWithPath(
-            'vs/editor/contrib/codeAction/browser/codeActionCommands',
-            'editor.action.codeAction.noneMessage.preferred',
-            "No preferred code actions available"
-        ))
-                : ( localizeWithPath(
-            'vs/editor/contrib/codeAction/browser/codeActionCommands',
-            'editor.action.codeAction.noneMessage',
-            "No code actions available"
-        )), {
+                ? ( localizeWithPath(_moduleId, 10, "No preferred code actions available"))
+                : ( localizeWithPath(_moduleId, 11, "No code actions available")), {
             include: args.kind,
             includeSourceActions: true,
             onlyIncludePreferredActions: args.preferred,
@@ -144,13 +113,9 @@ class RefactorAction extends EditorAction {
     constructor() {
         super({
             id: refactorCommandId,
-            label: ( localizeWithPath(
-                'vs/editor/contrib/codeAction/browser/codeActionCommands',
-                'refactor.label',
-                "Refactor..."
-            )),
+            label: ( localizeWithPath(_moduleId, 12, "Refactor...")),
             alias: 'Refactor...',
-            precondition: ( ContextKeyExpr.and(EditorContextKeys.writable, EditorContextKeys.hasCodeActionsProvider)),
+            precondition: ( (ContextKeyExpr.and(EditorContextKeys.writable, EditorContextKeys.hasCodeActionsProvider))),
             kbOpts: {
                 kbExpr: EditorContextKeys.textInputFocus,
                 primary: 2048  | 1024  | 48 ,
@@ -162,10 +127,10 @@ class RefactorAction extends EditorAction {
             contextMenuOpts: {
                 group: '1_modification',
                 order: 2,
-                when: ( ContextKeyExpr.and(
+                when: ( (ContextKeyExpr.and(
                     EditorContextKeys.writable,
                     contextKeyForSupportedActions(CodeActionKind.Refactor)
-                )),
+                ))),
             },
             metadata: {
                 description: 'Refactor...',
@@ -181,28 +146,15 @@ class RefactorAction extends EditorAction {
         return triggerCodeActionsForEditorSelection(editor, typeof userArgs?.kind === 'string'
             ? args.preferred
                 ? ( localizeWithPath(
-            'vs/editor/contrib/codeAction/browser/codeActionCommands',
-            'editor.action.refactor.noneMessage.preferred.kind',
+            _moduleId,
+            13,
             "No preferred refactorings for '{0}' available",
             userArgs.kind
         ))
-                : ( localizeWithPath(
-            'vs/editor/contrib/codeAction/browser/codeActionCommands',
-            'editor.action.refactor.noneMessage.kind',
-            "No refactorings for '{0}' available",
-            userArgs.kind
-        ))
+                : ( localizeWithPath(_moduleId, 14, "No refactorings for '{0}' available", userArgs.kind))
             : args.preferred
-                ? ( localizeWithPath(
-            'vs/editor/contrib/codeAction/browser/codeActionCommands',
-            'editor.action.refactor.noneMessage.preferred',
-            "No preferred refactorings available"
-        ))
-                : ( localizeWithPath(
-            'vs/editor/contrib/codeAction/browser/codeActionCommands',
-            'editor.action.refactor.noneMessage',
-            "No refactorings available"
-        )), {
+                ? ( localizeWithPath(_moduleId, 15, "No preferred refactorings available"))
+                : ( localizeWithPath(_moduleId, 16, "No refactorings available")), {
             include: CodeActionKind.Refactor.contains(args.kind) ? args.kind : HierarchicalKind.None,
             onlyIncludePreferredActions: args.preferred
         }, args.apply, CodeActionTriggerSource.Refactor);
@@ -212,20 +164,16 @@ class SourceAction extends EditorAction {
     constructor() {
         super({
             id: sourceActionCommandId,
-            label: ( localizeWithPath(
-                'vs/editor/contrib/codeAction/browser/codeActionCommands',
-                'source.label',
-                "Source Action..."
-            )),
+            label: ( localizeWithPath(_moduleId, 17, "Source Action...")),
             alias: 'Source Action...',
-            precondition: ( ContextKeyExpr.and(EditorContextKeys.writable, EditorContextKeys.hasCodeActionsProvider)),
+            precondition: ( (ContextKeyExpr.and(EditorContextKeys.writable, EditorContextKeys.hasCodeActionsProvider))),
             contextMenuOpts: {
                 group: '1_modification',
                 order: 2.1,
-                when: ( ContextKeyExpr.and(
+                when: ( (ContextKeyExpr.and(
                     EditorContextKeys.writable,
                     contextKeyForSupportedActions(CodeActionKind.Source)
-                )),
+                ))),
             },
             metadata: {
                 description: 'Source Action...',
@@ -241,28 +189,15 @@ class SourceAction extends EditorAction {
         return triggerCodeActionsForEditorSelection(editor, typeof userArgs?.kind === 'string'
             ? args.preferred
                 ? ( localizeWithPath(
-            'vs/editor/contrib/codeAction/browser/codeActionCommands',
-            'editor.action.source.noneMessage.preferred.kind',
+            _moduleId,
+            18,
             "No preferred source actions for '{0}' available",
             userArgs.kind
         ))
-                : ( localizeWithPath(
-            'vs/editor/contrib/codeAction/browser/codeActionCommands',
-            'editor.action.source.noneMessage.kind',
-            "No source actions for '{0}' available",
-            userArgs.kind
-        ))
+                : ( localizeWithPath(_moduleId, 19, "No source actions for '{0}' available", userArgs.kind))
             : args.preferred
-                ? ( localizeWithPath(
-            'vs/editor/contrib/codeAction/browser/codeActionCommands',
-            'editor.action.source.noneMessage.preferred',
-            "No preferred source actions available"
-        ))
-                : ( localizeWithPath(
-            'vs/editor/contrib/codeAction/browser/codeActionCommands',
-            'editor.action.source.noneMessage',
-            "No source actions available"
-        )), {
+                ? ( localizeWithPath(_moduleId, 20, "No preferred source actions available"))
+                : ( localizeWithPath(_moduleId, 21, "No source actions available")), {
             include: CodeActionKind.Source.contains(args.kind) ? args.kind : HierarchicalKind.None,
             includeSourceActions: true,
             onlyIncludePreferredActions: args.preferred,
@@ -273,16 +208,12 @@ class OrganizeImportsAction extends EditorAction {
     constructor() {
         super({
             id: organizeImportsCommandId,
-            label: ( localizeWithPath(
-                'vs/editor/contrib/codeAction/browser/codeActionCommands',
-                'organizeImports.label',
-                "Organize Imports"
-            )),
+            label: ( localizeWithPath(_moduleId, 22, "Organize Imports")),
             alias: 'Organize Imports',
-            precondition: ( ContextKeyExpr.and(
+            precondition: ( (ContextKeyExpr.and(
                 EditorContextKeys.writable,
                 contextKeyForSupportedActions(CodeActionKind.SourceOrganizeImports)
-            )),
+            ))),
             kbOpts: {
                 kbExpr: EditorContextKeys.textInputFocus,
                 primary: 1024  | 512  | 45 ,
@@ -291,51 +222,35 @@ class OrganizeImportsAction extends EditorAction {
         });
     }
     run(_accessor, editor) {
-        return triggerCodeActionsForEditorSelection(editor, ( localizeWithPath(
-            'vs/editor/contrib/codeAction/browser/codeActionCommands',
-            'editor.action.organize.noneMessage',
-            "No organize imports action available"
-        )), { include: CodeActionKind.SourceOrganizeImports, includeSourceActions: true }, "ifSingle" , CodeActionTriggerSource.OrganizeImports);
+        return triggerCodeActionsForEditorSelection(editor, ( localizeWithPath(_moduleId, 23, "No organize imports action available")), { include: CodeActionKind.SourceOrganizeImports, includeSourceActions: true }, "ifSingle" , CodeActionTriggerSource.OrganizeImports);
     }
 }
 class FixAllAction extends EditorAction {
     constructor() {
         super({
             id: fixAllCommandId,
-            label: ( localizeWithPath(
-                'vs/editor/contrib/codeAction/browser/codeActionCommands',
-                'fixAll.label',
-                "Fix All"
-            )),
+            label: ( localizeWithPath(_moduleId, 24, "Fix All")),
             alias: 'Fix All',
-            precondition: ( ContextKeyExpr.and(
+            precondition: ( (ContextKeyExpr.and(
                 EditorContextKeys.writable,
                 contextKeyForSupportedActions(CodeActionKind.SourceFixAll)
-            ))
+            )))
         });
     }
     run(_accessor, editor) {
-        return triggerCodeActionsForEditorSelection(editor, ( localizeWithPath(
-            'vs/editor/contrib/codeAction/browser/codeActionCommands',
-            'fixAll.noneMessage',
-            "No fix all action available"
-        )), { include: CodeActionKind.SourceFixAll, includeSourceActions: true }, "ifSingle" , CodeActionTriggerSource.FixAll);
+        return triggerCodeActionsForEditorSelection(editor, ( localizeWithPath(_moduleId, 25, "No fix all action available")), { include: CodeActionKind.SourceFixAll, includeSourceActions: true }, "ifSingle" , CodeActionTriggerSource.FixAll);
     }
 }
 class AutoFixAction extends EditorAction {
     constructor() {
         super({
             id: autoFixCommandId,
-            label: ( localizeWithPath(
-                'vs/editor/contrib/codeAction/browser/codeActionCommands',
-                'autoFix.label',
-                "Auto Fix..."
-            )),
+            label: ( localizeWithPath(_moduleId, 26, "Auto Fix...")),
             alias: 'Auto Fix...',
-            precondition: ( ContextKeyExpr.and(
+            precondition: ( (ContextKeyExpr.and(
                 EditorContextKeys.writable,
                 contextKeyForSupportedActions(CodeActionKind.QuickFix)
-            )),
+            ))),
             kbOpts: {
                 kbExpr: EditorContextKeys.textInputFocus,
                 primary: 512  | 1024  | 89 ,
@@ -347,11 +262,7 @@ class AutoFixAction extends EditorAction {
         });
     }
     run(_accessor, editor) {
-        return triggerCodeActionsForEditorSelection(editor, ( localizeWithPath(
-            'vs/editor/contrib/codeAction/browser/codeActionCommands',
-            'editor.action.autoFix.noneMessage',
-            "No auto fixes available"
-        )), {
+        return triggerCodeActionsForEditorSelection(editor, ( localizeWithPath(_moduleId, 27, "No auto fixes available")), {
             include: CodeActionKind.QuickFix,
             onlyIncludePreferredActions: true
         }, "ifSingle" , CodeActionTriggerSource.AutoFix);

package/vscode/src/vs/editor/contrib/codeAction/browser/codeActionContributions.js

@@ -6,6 +6,7 @@ import { LightBulbWidget } from './lightBulbWidget.js';
 import { localizeWithPath } from '../../../../nls.js';
 import { Extensions } from '../../../../platform/configuration/common/configurationRegistry.js';
 import { Registry } from '../../../../platform/registry/common/platform.js';
+const _moduleId = "vs/editor/contrib/codeAction/browser/codeActionContributions";
 registerEditorContribution(CodeActionController.ID, CodeActionController, 3 );
 registerEditorContribution(LightBulbWidget.ID, LightBulbWidget, 4 );
 registerEditorAction(QuickFixAction);
@@ -14,31 +15,31 @@ registerEditorAction(SourceAction);
 registerEditorAction(OrganizeImportsAction);
 registerEditorAction(AutoFixAction);
 registerEditorAction(FixAllAction);
-registerEditorCommand(( new CodeActionCommand()));
-( Registry.as(Extensions.Configuration)).registerConfiguration({
+registerEditorCommand(( (new CodeActionCommand())));
+( (Registry.as(Extensions.Configuration))).registerConfiguration({
     ...editorConfigurationBaseNode,
     properties: {
         'editor.codeActionWidget.showHeaders': {
             type: 'boolean',
             scope: 5 ,
             description: ( localizeWithPath(
-                'vs/editor/contrib/codeAction/browser/codeActionContributions',
-                'showCodeActionHeaders',
+                _moduleId,
+                0,
                 "Enable/disable showing group headers in the Code Action menu."
             )),
             default: true,
         },
     }
 });
-( Registry.as(Extensions.Configuration)).registerConfiguration({
+( (Registry.as(Extensions.Configuration))).registerConfiguration({
     ...editorConfigurationBaseNode,
     properties: {
         'editor.codeActionWidget.includeNearbyQuickFixes': {
             type: 'boolean',
             scope: 5 ,
             description: ( localizeWithPath(
-                'vs/editor/contrib/codeAction/browser/codeActionContributions',
-                'includeNearbyQuickFixes',
+                _moduleId,
+                1,
                 "Enable/disable showing nearest Quick Fix within a line when not currently on a diagnostic."
             )),
             default: true,