@codingame/monaco-vscode-api 9.0.3 → 10.0.1

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

@@ -1,13 +1,11 @@
 import { HierarchicalKind } from '../../../../base/common/hierarchicalKind.js';
-import { KeyMod as KeyMod$1, KeyCode } from '../../../../base/common/keyCodes.js';
 import { escapeRegExpCharacters } from '../../../../base/common/strings.js';
 import { EditorCommand, EditorAction } from '../../../browser/editorExtensions.js';
 import { EditorContextKeys } from '../../../common/editorContextKeys.js';
 import { codeActionCommandId, quickFixCommandId, refactorCommandId, sourceActionCommandId, organizeImportsCommandId, fixAllCommandId, autoFixCommandId } from './codeAction.js';
 import { localize } from '../../../../nls.js';
 import { ContextKeyExpr } from '../../../../platform/contextkey/common/contextkey.js';
-import { KeybindingWeight } from '../../../../platform/keybinding/common/keybindingsRegistry.js';
-import { CodeActionCommandArgs, CodeActionAutoApply, CodeActionTriggerSource, CodeActionKind } from '../common/types.js';
+import { CodeActionCommandArgs, CodeActionTriggerSource, CodeActionKind } from '../common/types.js';
 import { CodeActionController } from './codeActionController.js';
 import { SUPPORTED_CODE_ACTIONS } from './codeActionModel.js';
 function contextKeyForSupportedActions(kind) {
@@ -24,23 +22,23 @@ const argsSchema = {
     properties: {
         'kind': {
             type: 'string',
-            description: ( localize(4980, "Kind of the code action to run.")),
+            description: ( localize(5011, "Kind of the code action to run.")),
         },
         'apply': {
             type: 'string',
-            description: ( localize(4981, "Controls when the returned actions are applied.")),
-            default: CodeActionAutoApply.IfSingle,
-            enum: [CodeActionAutoApply.First, CodeActionAutoApply.IfSingle, CodeActionAutoApply.Never],
+            description: ( localize(5012, "Controls when the returned actions are applied.")),
+            default: "ifSingle" ,
+            enum: ["first" , "ifSingle" , "never" ],
             enumDescriptions: [
-                ( localize(4982, "Always apply the first returned code action.")),
-                ( localize(4983, "Apply the first returned code action if it is the only one.")),
-                ( localize(4984, "Do not apply the returned code actions.")),
+                ( localize(5013, "Always apply the first returned code action.")),
+                ( localize(5014, "Apply the first returned code action if it is the only one.")),
+                ( localize(5015, "Do not apply the returned code actions.")),
             ]
         },
         'preferred': {
             type: 'boolean',
             default: false,
-            description: ( localize(4985, "Controls if only preferred code actions should be returned.")),
+            description: ( localize(5016, "Controls if only preferred code actions should be returned.")),
         }
     }
 };
@@ -54,18 +52,18 @@ class QuickFixAction extends EditorAction {
     constructor() {
         super({
             id: quickFixCommandId,
-            label: ( localize(4986, "Quick Fix...")),
+            label: ( localize(5017, "Quick Fix...")),
             alias: 'Quick Fix...',
             precondition: ( (ContextKeyExpr.and(EditorContextKeys.writable, EditorContextKeys.hasCodeActionsProvider))),
             kbOpts: {
                 kbExpr: EditorContextKeys.textInputFocus,
-                primary: KeyMod$1.CtrlCmd | KeyCode.Period,
-                weight: KeybindingWeight.EditorContrib
+                primary: 2048  | 89 ,
+                weight: 100
             }
         });
     }
     run(_accessor, editor) {
-        return triggerCodeActionsForEditorSelection(editor, ( localize(4987, "No code actions available")), undefined, undefined, CodeActionTriggerSource.QuickFix);
+        return triggerCodeActionsForEditorSelection(editor, ( localize(5018, "No code actions available")), undefined, undefined, CodeActionTriggerSource.QuickFix);
     }
 }
 class CodeActionCommand extends EditorCommand {
@@ -82,15 +80,15 @@ class CodeActionCommand extends EditorCommand {
     runEditorCommand(_accessor, editor, userArgs) {
         const args = CodeActionCommandArgs.fromUser(userArgs, {
             kind: HierarchicalKind.Empty,
-            apply: CodeActionAutoApply.IfSingle,
+            apply: "ifSingle" ,
         });
         return triggerCodeActionsForEditorSelection(editor, typeof userArgs?.kind === 'string'
             ? args.preferred
-                ? ( localize(4988, "No preferred code actions for '{0}' available", userArgs.kind))
-                : ( localize(4989, "No code actions for '{0}' available", userArgs.kind))
+                ? ( localize(5019, "No preferred code actions for '{0}' available", userArgs.kind))
+                : ( localize(5020, "No code actions for '{0}' available", userArgs.kind))
             : args.preferred
-                ? ( localize(4990, "No preferred code actions available"))
-                : ( localize(4991, "No code actions available")), {
+                ? ( localize(5021, "No preferred code actions available"))
+                : ( localize(5022, "No code actions available")), {
             include: args.kind,
             includeSourceActions: true,
             onlyIncludePreferredActions: args.preferred,
@@ -101,16 +99,16 @@ class RefactorAction extends EditorAction {
     constructor() {
         super({
             id: refactorCommandId,
-            label: ( localize(4992, "Refactor...")),
+            label: ( localize(5023, "Refactor...")),
             alias: 'Refactor...',
             precondition: ( (ContextKeyExpr.and(EditorContextKeys.writable, EditorContextKeys.hasCodeActionsProvider))),
             kbOpts: {
                 kbExpr: EditorContextKeys.textInputFocus,
-                primary: KeyMod$1.CtrlCmd | KeyMod$1.Shift | KeyCode.KeyR,
+                primary: 2048  | 1024  | 48 ,
                 mac: {
-                    primary: KeyMod$1.WinCtrl | KeyMod$1.Shift | KeyCode.KeyR
+                    primary: 256  | 1024  | 48
                 },
-                weight: KeybindingWeight.EditorContrib
+                weight: 100
             },
             contextMenuOpts: {
                 group: '1_modification',
@@ -129,15 +127,15 @@ class RefactorAction extends EditorAction {
     run(_accessor, editor, userArgs) {
         const args = CodeActionCommandArgs.fromUser(userArgs, {
             kind: CodeActionKind.Refactor,
-            apply: CodeActionAutoApply.Never
+            apply: "never"
         });
         return triggerCodeActionsForEditorSelection(editor, typeof userArgs?.kind === 'string'
             ? args.preferred
-                ? ( localize(4993, "No preferred refactorings for '{0}' available", userArgs.kind))
-                : ( localize(4994, "No refactorings for '{0}' available", userArgs.kind))
+                ? ( localize(5024, "No preferred refactorings for '{0}' available", userArgs.kind))
+                : ( localize(5025, "No refactorings for '{0}' available", userArgs.kind))
             : args.preferred
-                ? ( localize(4995, "No preferred refactorings available"))
-                : ( localize(4996, "No refactorings available")), {
+                ? ( localize(5026, "No preferred refactorings available"))
+                : ( localize(5027, "No refactorings available")), {
             include: CodeActionKind.Refactor.contains(args.kind) ? args.kind : HierarchicalKind.None,
             onlyIncludePreferredActions: args.preferred
         }, args.apply, CodeActionTriggerSource.Refactor);
@@ -147,7 +145,7 @@ class SourceAction extends EditorAction {
     constructor() {
         super({
             id: sourceActionCommandId,
-            label: ( localize(4997, "Source Action...")),
+            label: ( localize(5028, "Source Action...")),
             alias: 'Source Action...',
             precondition: ( (ContextKeyExpr.and(EditorContextKeys.writable, EditorContextKeys.hasCodeActionsProvider))),
             contextMenuOpts: {
@@ -167,15 +165,15 @@ class SourceAction extends EditorAction {
     run(_accessor, editor, userArgs) {
         const args = CodeActionCommandArgs.fromUser(userArgs, {
             kind: CodeActionKind.Source,
-            apply: CodeActionAutoApply.Never
+            apply: "never"
         });
         return triggerCodeActionsForEditorSelection(editor, typeof userArgs?.kind === 'string'
             ? args.preferred
-                ? ( localize(4998, "No preferred source actions for '{0}' available", userArgs.kind))
-                : ( localize(4999, "No source actions for '{0}' available", userArgs.kind))
+                ? ( localize(5029, "No preferred source actions for '{0}' available", userArgs.kind))
+                : ( localize(5030, "No source actions for '{0}' available", userArgs.kind))
             : args.preferred
-                ? ( localize(5000, "No preferred source actions available"))
-                : ( localize(5001, "No source actions available")), {
+                ? ( localize(5031, "No preferred source actions available"))
+                : ( localize(5032, "No source actions available")), {
             include: CodeActionKind.Source.contains(args.kind) ? args.kind : HierarchicalKind.None,
             includeSourceActions: true,
             onlyIncludePreferredActions: args.preferred,
@@ -186,7 +184,7 @@ class OrganizeImportsAction extends EditorAction {
     constructor() {
         super({
             id: organizeImportsCommandId,
-            label: ( localize(5002, "Organize Imports")),
+            label: ( localize(5033, "Organize Imports")),
             alias: 'Organize Imports',
             precondition: ( (ContextKeyExpr.and(
                 EditorContextKeys.writable,
@@ -194,20 +192,20 @@ class OrganizeImportsAction extends EditorAction {
             ))),
             kbOpts: {
                 kbExpr: EditorContextKeys.textInputFocus,
-                primary: KeyMod$1.Shift | KeyMod$1.Alt | KeyCode.KeyO,
-                weight: KeybindingWeight.EditorContrib
+                primary: 1024  | 512  | 45 ,
+                weight: 100
             },
         });
     }
     run(_accessor, editor) {
-        return triggerCodeActionsForEditorSelection(editor, ( localize(5003, "No organize imports action available")), { include: CodeActionKind.SourceOrganizeImports, includeSourceActions: true }, CodeActionAutoApply.IfSingle, CodeActionTriggerSource.OrganizeImports);
+        return triggerCodeActionsForEditorSelection(editor, ( localize(5034, "No organize imports action available")), { include: CodeActionKind.SourceOrganizeImports, includeSourceActions: true }, "ifSingle" , CodeActionTriggerSource.OrganizeImports);
     }
 }
 class FixAllAction extends EditorAction {
     constructor() {
         super({
             id: fixAllCommandId,
-            label: ( localize(5004, "Fix All")),
+            label: ( localize(5035, "Fix All")),
             alias: 'Fix All',
             precondition: ( (ContextKeyExpr.and(
                 EditorContextKeys.writable,
@@ -216,14 +214,14 @@ class FixAllAction extends EditorAction {
         });
     }
     run(_accessor, editor) {
-        return triggerCodeActionsForEditorSelection(editor, ( localize(5005, "No fix all action available")), { include: CodeActionKind.SourceFixAll, includeSourceActions: true }, CodeActionAutoApply.IfSingle, CodeActionTriggerSource.FixAll);
+        return triggerCodeActionsForEditorSelection(editor, ( localize(5036, "No fix all action available")), { include: CodeActionKind.SourceFixAll, includeSourceActions: true }, "ifSingle" , CodeActionTriggerSource.FixAll);
     }
 }
 class AutoFixAction extends EditorAction {
     constructor() {
         super({
             id: autoFixCommandId,
-            label: ( localize(5006, "Auto Fix...")),
+            label: ( localize(5037, "Auto Fix...")),
             alias: 'Auto Fix...',
             precondition: ( (ContextKeyExpr.and(
                 EditorContextKeys.writable,
@@ -231,19 +229,19 @@ class AutoFixAction extends EditorAction {
             ))),
             kbOpts: {
                 kbExpr: EditorContextKeys.textInputFocus,
-                primary: KeyMod$1.Alt | KeyMod$1.Shift | KeyCode.Period,
+                primary: 512  | 1024  | 89 ,
                 mac: {
-                    primary: KeyMod$1.CtrlCmd | KeyMod$1.Alt | KeyCode.Period
+                    primary: 2048  | 512  | 89
                 },
-                weight: KeybindingWeight.EditorContrib
+                weight: 100
             }
         });
     }
     run(_accessor, editor) {
-        return triggerCodeActionsForEditorSelection(editor, ( localize(5007, "No auto fixes available")), {
+        return triggerCodeActionsForEditorSelection(editor, ( localize(5038, "No auto fixes available")), {
             include: CodeActionKind.QuickFix,
             onlyIncludePreferredActions: true
-        }, CodeActionAutoApply.IfSingle, CodeActionTriggerSource.AutoFix);
+        }, "ifSingle" , CodeActionTriggerSource.AutoFix);
     }
 }
 export { AutoFixAction, CodeActionCommand, FixAllAction, OrganizeImportsAction, QuickFixAction, RefactorAction, SourceAction };

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

@@ -1,13 +1,13 @@
-import { registerEditorContribution, registerEditorAction, registerEditorCommand, EditorContributionInstantiation } from '../../../browser/editorExtensions.js';
+import { registerEditorContribution, registerEditorAction, registerEditorCommand } from '../../../browser/editorExtensions.js';
 import { editorConfigurationBaseNode } from '../../../common/config/editorConfigurationSchema.js';
 import { CodeActionCommand, QuickFixAction, RefactorAction, SourceAction, OrganizeImportsAction, AutoFixAction, FixAllAction } from './codeActionCommands.js';
 import { CodeActionController } from './codeActionController.js';
 import { LightBulbWidget } from './lightBulbWidget.js';
 import { localize } from '../../../../nls.js';
-import { Extensions, ConfigurationScope } from '../../../../platform/configuration/common/configurationRegistry.js';
+import { Extensions } from '../../../../platform/configuration/common/configurationRegistry.js';
 import { Registry } from '../../../../platform/registry/common/platform.js';
-registerEditorContribution(CodeActionController.ID, CodeActionController, EditorContributionInstantiation.Eventually);
-registerEditorContribution(LightBulbWidget.ID, LightBulbWidget, EditorContributionInstantiation.Lazy);
+registerEditorContribution(CodeActionController.ID, CodeActionController, 3 );
+registerEditorContribution(LightBulbWidget.ID, LightBulbWidget, 4 );
 registerEditorAction(QuickFixAction);
 registerEditorAction(RefactorAction);
 registerEditorAction(SourceAction);
@@ -20,8 +20,8 @@ registerEditorCommand(( (new CodeActionCommand())));
     properties: {
         'editor.codeActionWidget.showHeaders': {
             type: 'boolean',
-            scope: ConfigurationScope.LANGUAGE_OVERRIDABLE,
-            description: ( localize(1364, "Enable/disable showing group headers in the Code Action menu.")),
+            scope: 5 ,
+            description: ( localize(1379, "Enable/disable showing group headers in the Code Action menu.")),
             default: true,
         },
     }
@@ -31,9 +31,9 @@ registerEditorCommand(( (new CodeActionCommand())));
     properties: {
         'editor.codeActionWidget.includeNearbyQuickFixes': {
             type: 'boolean',
-            scope: ConfigurationScope.LANGUAGE_OVERRIDABLE,
+            scope: 5 ,
             description: ( localize(
-                1365,
+                1380,
                 "Enable/disable showing nearest Quick Fix within a line when not currently on a diagnostic."
             )),
             default: true,
@@ -45,9 +45,9 @@ registerEditorCommand(( (new CodeActionCommand())));
     properties: {
         'editor.codeActions.triggerOnFocusChange': {
             type: 'boolean',
-            scope: ConfigurationScope.LANGUAGE_OVERRIDABLE,
+            scope: 5 ,
             markdownDescription: ( localize(
-                1366,
+                1381,
                 '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#`',

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

@@ -5,8 +5,6 @@ import { onUnexpectedError } from '../../../../base/common/errors.js';
 import { Lazy } from '../../../../base/common/lazy.js';
 import { Disposable, MutableDisposable } from '../../../../base/common/lifecycle.js';
 import { Position } from '../../../common/core/position.js';
-import { ScrollType } from '../../../common/editorCommon.js';
-import { CodeActionTriggerType } from '../../../common/languages.js';
 import { ModelDecorationOptions } from '../../../common/model/textModel.js';
 import { ILanguageFeaturesService } from '../../../common/services/languageFeatures.js';
 import { ApplyCodeActionReason, applyCodeAction } from './codeAction.js';
@@ -35,8 +33,8 @@ import '../../../../platform/theme/common/colors/quickpickColors.js';
 import '../../../../platform/theme/common/colors/searchColors.js';
 import { isHighContrast } from '../../../../platform/theme/common/theme.js';
 import { registerThemingParticipant } from '../../../../platform/theme/common/themeService.js';
-import { CodeActionTriggerSource, CodeActionAutoApply, CodeActionKind } from '../common/types.js';
-import { CodeActionModel, CodeActionsState } from './codeActionModel.js';
+import { CodeActionTriggerSource, CodeActionKind } from '../common/types.js';
+import { CodeActionModel } from './codeActionModel.js';
 import { HierarchicalKind } from '../../../../base/common/hierarchicalKind.js';
 import { ITelemetryService } from '../../../../platform/telemetry/common/telemetry.service.js';
 var CodeActionController_1;
@@ -108,7 +106,7 @@ let CodeActionController = class CodeActionController extends Disposable {
         }
         MessageController.get(this._editor)?.closeMessage();
         const triggerPosition = this._editor.getPosition();
-        this._trigger({ type: CodeActionTriggerType.Invoke, triggerAction, filter, autoApply, context: { notAvailableMessage, position: triggerPosition } });
+        this._trigger({ type: 1 , triggerAction, filter, autoApply, context: { notAvailableMessage, position: triggerPosition } });
     }
     _trigger(trigger) {
         return this._model.trigger(trigger);
@@ -119,7 +117,7 @@ let CodeActionController = class CodeActionController extends Disposable {
         }
         finally {
             if (retrigger) {
-                this._trigger({ type: CodeActionTriggerType.Auto, triggerAction: CodeActionTriggerSource.QuickFix, filter: {} });
+                this._trigger({ type: 2 , triggerAction: CodeActionTriggerSource.QuickFix, filter: {} });
             }
         }
     }
@@ -128,7 +126,7 @@ let CodeActionController = class CodeActionController extends Disposable {
         this._lightBulbWidget.rawValue?.gutterHide();
     }
     async update(newState) {
-        if (newState.type !== CodeActionsState.Type.Triggered) {
+        if (newState.type !== 1 ) {
             this.hideLightBulbWidget();
             return;
         }
@@ -148,7 +146,7 @@ let CodeActionController = class CodeActionController extends Disposable {
             return;
         }
         this._lightBulbWidget.value?.update(actions, newState.trigger, newState.position);
-        if (newState.trigger.type === CodeActionTriggerType.Invoke) {
+        if (newState.trigger.type === 1 ) {
             if (newState.trigger.filter?.include) {
                 const validActionToApply = this.tryGetValidActionToApply(newState.trigger, actions);
                 if (validActionToApply) {
@@ -195,8 +193,8 @@ let CodeActionController = class CodeActionController extends Disposable {
         if (!actions.allActions.length) {
             return undefined;
         }
-        if ((trigger.autoApply === CodeActionAutoApply.First && actions.validActions.length === 0)
-            || (trigger.autoApply === CodeActionAutoApply.IfSingle && actions.allActions.length === 1)) {
+        if ((trigger.autoApply === "first"  && actions.validActions.length === 0)
+            || (trigger.autoApply === "ifSingle"  && actions.allActions.length === 1)) {
             return actions.allActions.find(({ action }) => action.disabled);
         }
         return undefined;
@@ -205,8 +203,8 @@ let CodeActionController = class CodeActionController extends Disposable {
         if (!actions.validActions.length) {
             return undefined;
         }
-        if ((trigger.autoApply === CodeActionAutoApply.First && actions.validActions.length > 0)
-            || (trigger.autoApply === CodeActionAutoApply.IfSingle && actions.validActions.length === 1)) {
+        if ((trigger.autoApply === "first"  && actions.validActions.length > 0)
+            || (trigger.autoApply === "ifSingle"  && actions.validActions.length === 1)) {
             return actions.validActions[0];
         }
         return undefined;
@@ -277,7 +275,7 @@ let CodeActionController = class CodeActionController extends Disposable {
                         if (diagnostic.startLineNumber && diagnostic.startColumn) {
                             const selectionText = this._editor.getModel()?.getWordAtPosition({ lineNumber: diagnostic.startLineNumber, column: diagnostic.startColumn })?.word;
                             status(( localize(
-                                5008,
+                                5039,
                                 "Context: {0} at line {1} and column {2}.",
                                 selectionText,
                                 diagnostic.startLineNumber,
@@ -297,7 +295,7 @@ let CodeActionController = class CodeActionController extends Disposable {
         if (!this._editor.hasModel()) {
             return { x: 0, y: 0 };
         }
-        this._editor.revealPosition(position, ScrollType.Immediate);
+        this._editor.revealPosition(position, 1 );
         this._editor.render();
         const cursorCoords = this._editor.getScrolledVisiblePosition(position);
         const editorCoords = getDomNodePagePosition(this._editor.getDomNode());
@@ -324,7 +322,7 @@ let CodeActionController = class CodeActionController extends Disposable {
         if (options.includeDisabledActions && actions.validActions.length > 0 && actions.allActions.length !== actions.validActions.length) {
             resultActions.push(this._showDisabled ? {
                 id: 'hideMoreActions',
-                label: ( localize(5009, 'Hide Disabled')),
+                label: ( localize(5040, 'Hide Disabled')),
                 enabled: true,
                 tooltip: '',
                 class: undefined,
@@ -334,7 +332,7 @@ let CodeActionController = class CodeActionController extends Disposable {
                 }
             } : {
                 id: 'showMoreActions',
-                label: ( localize(5010, 'Show Disabled')),
+                label: ( localize(5041, 'Show Disabled')),
                 enabled: true,
                 tooltip: '',
                 class: undefined,

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

@@ -2,7 +2,7 @@ import { __decorate, __param } from '../../../../../../../external/tslib/tslib.e
 import { HierarchicalKind } from '../../../../base/common/hierarchicalKind.js';
 import { Lazy } from '../../../../base/common/lazy.js';
 import { refactorCommandId, codeActionCommandId, sourceActionCommandId, organizeImportsCommandId, fixAllCommandId } from './codeAction.js';
-import { CodeActionCommandArgs, CodeActionAutoApply, CodeActionKind } from '../common/types.js';
+import { CodeActionCommandArgs, CodeActionKind } from '../common/types.js';
 import { IKeybindingService } from '../../../../platform/keybinding/common/keybinding.service.js';
 var CodeActionKeybindingResolver_1;
 let CodeActionKeybindingResolver = class CodeActionKeybindingResolver {
@@ -33,7 +33,7 @@ let CodeActionKeybindingResolver = class CodeActionKeybindingResolver {
                 resolvedKeybinding: item.resolvedKeybinding,
                 ...CodeActionCommandArgs.fromUser(commandArgs, {
                     kind: HierarchicalKind.None,
-                    apply: CodeActionAutoApply.Never
+                    apply: "never"
                 })
             };
         }))));

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

@@ -4,17 +4,16 @@ import { Codicon } from '../../../../base/common/codicons.js';
 import { CodeActionKind } from '../common/types.js';
 import '../../symbolIcons/browser/symbolIcons.js';
 import { localize } from '../../../../nls.js';
-import { ActionListItemKind } from '../../../../platform/actionWidget/browser/actionList.js';
 import { HierarchicalKind } from '../../../../base/common/hierarchicalKind.js';
-const uncategorizedCodeActionGroup = ( (Object.freeze({ kind: HierarchicalKind.Empty, title: ( localize(9877, 'More Actions...')) })));
+const uncategorizedCodeActionGroup = ( (Object.freeze({ kind: HierarchicalKind.Empty, title: ( localize(9962, 'More Actions...')) })));
 const codeActionGroups = ( (Object.freeze([
-    { kind: CodeActionKind.QuickFix, title: ( localize(9878, 'Quick Fix')) },
-    { kind: CodeActionKind.RefactorExtract, title: ( localize(9879, 'Extract')), icon: Codicon.wrench },
-    { kind: CodeActionKind.RefactorInline, title: ( localize(9880, 'Inline')), icon: Codicon.wrench },
-    { kind: CodeActionKind.RefactorRewrite, title: ( localize(9881, 'Rewrite')), icon: Codicon.wrench },
-    { kind: CodeActionKind.RefactorMove, title: ( localize(9882, 'Move')), icon: Codicon.wrench },
-    { kind: CodeActionKind.SurroundWith, title: ( localize(9883, 'Surround With')), icon: Codicon.surroundWith },
-    { kind: CodeActionKind.Source, title: ( localize(9884, 'Source Action')), icon: Codicon.symbolFile },
+    { kind: CodeActionKind.QuickFix, title: ( localize(9963, 'Quick Fix')) },
+    { kind: CodeActionKind.RefactorExtract, title: ( localize(9964, 'Extract')), icon: Codicon.wrench },
+    { kind: CodeActionKind.RefactorInline, title: ( localize(9965, 'Inline')), icon: Codicon.wrench },
+    { kind: CodeActionKind.RefactorRewrite, title: ( localize(9966, 'Rewrite')), icon: Codicon.wrench },
+    { kind: CodeActionKind.RefactorMove, title: ( localize(9967, 'Move')), icon: Codicon.wrench },
+    { kind: CodeActionKind.SurroundWith, title: ( localize(9968, 'Surround With')), icon: Codicon.surroundWith },
+    { kind: CodeActionKind.Source, title: ( localize(9969, 'Source Action')), icon: Codicon.symbolFile },
     uncategorizedCodeActionGroup,
 ])));
 function toMenuItems(inputCodeActions, showHeaders, keybindingResolver) {
@@ -22,7 +21,7 @@ function toMenuItems(inputCodeActions, showHeaders, keybindingResolver) {
         return (
              (inputCodeActions.map((action) => {
                 return {
-                    kind: ActionListItemKind.Action,
+                    kind: "action" ,
                     item: action,
                     group: uncategorizedCodeActionGroup,
                     disabled: !!action.action.disabled,
@@ -45,11 +44,11 @@ function toMenuItems(inputCodeActions, showHeaders, keybindingResolver) {
     const allMenuItems = [];
     for (const menuEntry of menuEntries) {
         if (menuEntry.actions.length) {
-            allMenuItems.push({ kind: ActionListItemKind.Header, group: menuEntry.group });
+            allMenuItems.push({ kind: "header" , group: menuEntry.group });
             for (const action of menuEntry.actions) {
                 const group = menuEntry.group;
                 allMenuItems.push({
-                    kind: ActionListItemKind.Action,
+                    kind: "action" ,
                     item: action,
                     group: action.action.isAI ? { title: group.title, kind: group.kind, icon: Codicon.sparkle } : group,
                     label: action.action.title,

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

@@ -3,10 +3,9 @@ import { isCancellationError } from '../../../../base/common/errors.js';
 import { Emitter } from '../../../../base/common/event.js';
 import { Disposable, MutableDisposable } from '../../../../base/common/lifecycle.js';
 import { isEqual } from '../../../../base/common/resources.js';
-import { EditorOption, ShowLightbulbIconMode } from '../../../common/config/editorOptions.js';
+import { ShowLightbulbIconMode } from '../../../common/config/editorOptions.js';
 import { Position } from '../../../common/core/position.js';
 import { Selection } from '../../../common/core/selection.js';
-import { CodeActionTriggerType } from '../../../common/languages.js';
 import { RawContextKey } from '../../../../platform/contextkey/common/contextkey.js';
 import { Progress } from '../../../../platform/progress/common/progress.js';
 import { CodeActionTriggerSource, CodeActionKind } from '../common/types.js';
@@ -38,7 +37,7 @@ class CodeActionOracle extends Disposable {
     }
     _tryAutoTrigger() {
         this._autoTriggerTimer.cancelAndSet(() => {
-            this.trigger({ type: CodeActionTriggerType.Auto, triggerAction: CodeActionTriggerSource.Default });
+            this.trigger({ type: 2 , triggerAction: CodeActionTriggerSource.Default });
         }, this._delay);
     }
     _getRangeOfSelectionUnlessWhitespaceEnclosed(trigger) {
@@ -46,10 +45,10 @@ class CodeActionOracle extends Disposable {
             return undefined;
         }
         const selection = this._editor.getSelection();
-        if (trigger.type === CodeActionTriggerType.Invoke) {
+        if (trigger.type === 1 ) {
             return selection;
         }
-        const enabled = this._editor.getOption(EditorOption.lightbulb).enabled;
+        const enabled = this._editor.getOption(67 ).enabled;
         if (enabled === ShowLightbulbIconMode.Off) {
             return undefined;
         }
@@ -88,18 +87,17 @@ class CodeActionOracle extends Disposable {
 }
 var CodeActionsState;
 ( (function(CodeActionsState) {
-    let Type;
     ( (function(Type) {
         Type[Type["Empty"] = 0] = "Empty";
         Type[Type["Triggered"] = 1] = "Triggered";
-    })(Type = CodeActionsState.Type || (CodeActionsState.Type = {})));
-    CodeActionsState.Empty = { type: Type.Empty };
+    })(CodeActionsState.Type || (CodeActionsState.Type = {})));
+    CodeActionsState.Empty = { type: 0  };
     class Triggered {
         constructor(trigger, position, _cancellablePromise) {
             this.trigger = trigger;
             this.position = position;
             this._cancellablePromise = _cancellablePromise;
-            this.type = Type.Triggered;
+            this.type = 1 ;
             this.actions = _cancellablePromise.catch((e) => {
                 if (isCancellationError(e)) {
                     return emptyCodeActionSet;
@@ -141,7 +139,7 @@ class CodeActionModel extends Disposable {
         this._register(this._editor.onDidChangeModelLanguage(() => this._update()));
         this._register(this._registry.onDidChange(() => this._update()));
         this._register(this._editor.onDidChangeConfiguration((e) => {
-            if (e.hasChanged(EditorOption.lightbulb)) {
+            if (e.hasChanged(67 )) {
                 this._update();
             }
         }));
@@ -168,7 +166,7 @@ class CodeActionModel extends Disposable {
         const model = this._editor.getModel();
         if (model
             && ( this._registry.has(model))
-            && !this._editor.getOption(EditorOption.readOnly)) {
+            && !this._editor.getOption(94 )) {
             const supportedActions = this._registry.all(model).flatMap(provider => provider.providedCodeActionKinds ?? []);
             this._supportedCodeActions.set(supportedActions.join(' '));
             this._codeActionOracle.value = ( new CodeActionOracle(this._editor, this._markerService, trigger => {
@@ -178,7 +176,7 @@ class CodeActionModel extends Disposable {
                 }
                 const startPosition = trigger.selection.getStartPosition();
                 const actions = createCancelablePromise(async (token) => {
-                    if (this._settingEnabledNearbyQuickfixes() && trigger.trigger.type === CodeActionTriggerType.Invoke && (trigger.trigger.triggerAction === CodeActionTriggerSource.QuickFix || trigger.trigger.filter?.include?.contains(CodeActionKind.QuickFix))) {
+                    if (this._settingEnabledNearbyQuickfixes() && trigger.trigger.type === 1  && (trigger.trigger.triggerAction === CodeActionTriggerSource.QuickFix || trigger.trigger.filter?.include?.contains(CodeActionKind.QuickFix))) {
                         const codeActionSet = await getCodeActions(this._registry, model, trigger.selection, trigger.trigger, Progress.None, token);
                         const allCodeActions = [...codeActionSet.allActions];
                         if (token.isCancellationRequested) {
@@ -261,7 +259,7 @@ class CodeActionModel extends Disposable {
                             }
                         }
                     }
-                    if (trigger.trigger.type === CodeActionTriggerType.Invoke) {
+                    if (trigger.trigger.type === 1 ) {
                         const sw = ( new StopWatch());
                         const codeActions = await getCodeActions(this._registry, model, trigger.selection, trigger.trigger, Progress.None, token);
                         if (this._telemetryService) {
@@ -274,15 +272,15 @@ class CodeActionModel extends Disposable {
                     }
                     return getCodeActions(this._registry, model, trigger.selection, trigger.trigger, Progress.None, token);
                 });
-                if (trigger.trigger.type === CodeActionTriggerType.Invoke) {
+                if (trigger.trigger.type === 1 ) {
                     this._progressService?.showWhile(actions, 250);
                 }
                 const newState = new CodeActionsState.Triggered(trigger.trigger, startPosition, actions);
                 let isManualToAutoTransition = false;
-                if (this._state.type === CodeActionsState.Type.Triggered) {
-                    isManualToAutoTransition = this._state.trigger.type === CodeActionTriggerType.Invoke &&
-                        newState.type === CodeActionsState.Type.Triggered &&
-                        newState.trigger.type === CodeActionTriggerType.Auto &&
+                if (this._state.type === 1 ) {
+                    isManualToAutoTransition = this._state.trigger.type === 1  &&
+                        newState.type === 1  &&
+                        newState.trigger.type === 2  &&
                         this._state.position !== newState.position;
                 }
                 if (!isManualToAutoTransition) {
@@ -294,7 +292,7 @@ class CodeActionModel extends Disposable {
                     }, 500);
                 }
             }, undefined));
-            this._codeActionOracle.value.trigger({ type: CodeActionTriggerType.Auto, triggerAction: CodeActionTriggerSource.Default });
+            this._codeActionOracle.value.trigger({ type: 2 , triggerAction: CodeActionTriggerSource.Default });
         }
         else {
             this._supportedCodeActions.reset();
@@ -307,7 +305,7 @@ class CodeActionModel extends Disposable {
         if (newState === this._state) {
             return;
         }
-        if (this._state.type === CodeActionsState.Type.Triggered) {
+        if (this._state.type === 1 ) {
             this._state.cancel();
         }
         this._state = newState;