@codingame/monaco-vscode-api 15.0.0 → 15.0.2

package/vscode/src/vs/platform/actionWidget/browser/actionWidget.js

@@ -0,0 +1,230 @@
+
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { addDisposableListener, EventType, trackFocus, $ } from '../../../base/browser/dom.js';
+import { ActionBar } from '../../../base/browser/ui/actionbar/actionbar.js';
+import { KeyMod as KeyMod$1, KeyCode } from '../../../base/common/keyCodes.js';
+import { Disposable, MutableDisposable, DisposableStore } from '../../../base/common/lifecycle.js';
+import './actionWidget.css.js';
+import { localize, localize2 } from '../../../nls.js';
+import { ActionList, acceptSelectedActionCommand, previewSelectedActionCommand } from './actionList.js';
+import { registerAction2, Action2 } from '../../actions/common/actions.js';
+import { RawContextKey } from '../../contextkey/common/contextkey.js';
+import { IContextKeyService } from '../../contextkey/common/contextkey.service.js';
+import { IContextViewService } from '../../contextview/browser/contextView.service.js';
+import '../../instantiation/common/extensions.js';
+import { IInstantiationService } from '../../instantiation/common/instantiation.js';
+import { KeybindingWeight } from '../../keybinding/common/keybindingsRegistry.js';
+import { registerColor } from '../../theme/common/colorUtils.js';
+import '../../theme/common/colors/baseColors.js';
+import '../../theme/common/colors/chartsColors.js';
+import '../../theme/common/colors/editorColors.js';
+import { inputActiveOptionBackground } from '../../theme/common/colors/inputColors.js';
+import '../../theme/common/colors/listColors.js';
+import '../../theme/common/colors/menuColors.js';
+import '../../theme/common/colors/minimapColors.js';
+import '../../theme/common/colors/miscColors.js';
+import '../../theme/common/colors/quickpickColors.js';
+import '../../theme/common/colors/searchColors.js';
+import { IActionWidgetService } from './actionWidget.service.js';
+
+registerColor('actionBar.toggledBackground', inputActiveOptionBackground, ( localize(1655, 'Background color for toggled action items in action bar.')));
+const ActionWidgetContextKeys = {
+    Visible: ( new RawContextKey('codeActionMenuVisible', false, ( localize(1656, "Whether the action widget list is visible"))))
+};
+let ActionWidgetService = class ActionWidgetService extends Disposable {
+    get isVisible() {
+        return ActionWidgetContextKeys.Visible.getValue(this._contextKeyService) || false;
+    }
+    constructor(_contextViewService, _contextKeyService, _instantiationService) {
+        super();
+        this._contextViewService = _contextViewService;
+        this._contextKeyService = _contextKeyService;
+        this._instantiationService = _instantiationService;
+        this._list = this._register(( new MutableDisposable()));
+    }
+    show(user, supportsPreview, items, delegate, anchor, container, actionBarActions) {
+        const visibleContext = ActionWidgetContextKeys.Visible.bindTo(this._contextKeyService);
+        const list = this._instantiationService.createInstance(ActionList, user, supportsPreview, items, delegate);
+        this._contextViewService.showContextView({
+            getAnchor: () => anchor,
+            render: (container) => {
+                visibleContext.set(true);
+                return this._renderWidget(container, list, actionBarActions ?? []);
+            },
+            onHide: (didCancel) => {
+                visibleContext.reset();
+                this._onWidgetClosed(didCancel);
+            },
+        }, container, false);
+    }
+    acceptSelected(preview) {
+        this._list.value?.acceptSelected(preview);
+    }
+    focusPrevious() {
+        this._list?.value?.focusPrevious();
+    }
+    focusNext() {
+        this._list?.value?.focusNext();
+    }
+    hide(didCancel) {
+        this._list.value?.hide(didCancel);
+        this._list.clear();
+    }
+    clear() {
+        this._list.clear();
+    }
+    _renderWidget(element, list, actionBarActions) {
+        const widget = document.createElement('div');
+        widget.classList.add('action-widget');
+        element.appendChild(widget);
+        this._list.value = list;
+        if (this._list.value) {
+            widget.appendChild(this._list.value.domNode);
+        }
+        else {
+            throw ( new Error('List has no value'));
+        }
+        const renderDisposables = ( new DisposableStore());
+        const menuBlock = document.createElement('div');
+        const block = element.appendChild(menuBlock);
+        block.classList.add('context-view-block');
+        renderDisposables.add(addDisposableListener(block, EventType.MOUSE_DOWN, e => e.stopPropagation()));
+        const pointerBlockDiv = document.createElement('div');
+        const pointerBlock = element.appendChild(pointerBlockDiv);
+        pointerBlock.classList.add('context-view-pointerBlock');
+        renderDisposables.add(addDisposableListener(pointerBlock, EventType.POINTER_MOVE, () => pointerBlock.remove()));
+        renderDisposables.add(addDisposableListener(pointerBlock, EventType.MOUSE_DOWN, () => pointerBlock.remove()));
+        let actionBarWidth = 0;
+        if (actionBarActions.length) {
+            const actionBar = this._createActionBar('.action-widget-action-bar', actionBarActions);
+            if (actionBar) {
+                widget.appendChild(actionBar.getContainer().parentElement);
+                renderDisposables.add(actionBar);
+                actionBarWidth = actionBar.getContainer().offsetWidth;
+            }
+        }
+        const width = this._list.value?.layout(actionBarWidth);
+        widget.style.width = `${width}px`;
+        const focusTracker = renderDisposables.add(trackFocus(element));
+        renderDisposables.add(focusTracker.onDidBlur(() => this.hide(true)));
+        return renderDisposables;
+    }
+    _createActionBar(className, actions) {
+        if (!actions.length) {
+            return undefined;
+        }
+        const container = $(className);
+        const actionBar = ( new ActionBar(container));
+        actionBar.push(actions, { icon: false, label: true });
+        return actionBar;
+    }
+    _onWidgetClosed(didCancel) {
+        this._list.value?.hide(didCancel);
+    }
+};
+ActionWidgetService = ( __decorate([
+    ( __param(0, IContextViewService)),
+    ( __param(1, IContextKeyService)),
+    ( __param(2, IInstantiationService))
+], ActionWidgetService));
+const weight = KeybindingWeight.EditorContrib + 1000;
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: 'hideCodeActionWidget',
+            title: ( localize2(1657, "Hide action widget")),
+            precondition: ActionWidgetContextKeys.Visible,
+            keybinding: {
+                weight,
+                primary: KeyCode.Escape,
+                secondary: [KeyMod$1.Shift | KeyCode.Escape]
+            },
+        });
+    }
+    run(accessor) {
+        accessor.get(IActionWidgetService).hide(true);
+    }
+});
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: 'selectPrevCodeAction',
+            title: ( localize2(1658, "Select previous action")),
+            precondition: ActionWidgetContextKeys.Visible,
+            keybinding: {
+                weight,
+                primary: KeyCode.UpArrow,
+                secondary: [KeyMod$1.CtrlCmd | KeyCode.UpArrow],
+                mac: { primary: KeyCode.UpArrow, secondary: [KeyMod$1.CtrlCmd | KeyCode.UpArrow, KeyMod$1.WinCtrl | KeyCode.KeyP] },
+            }
+        });
+    }
+    run(accessor) {
+        const widgetService = accessor.get(IActionWidgetService);
+        if (widgetService instanceof ActionWidgetService) {
+            widgetService.focusPrevious();
+        }
+    }
+});
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: 'selectNextCodeAction',
+            title: ( localize2(1659, "Select next action")),
+            precondition: ActionWidgetContextKeys.Visible,
+            keybinding: {
+                weight,
+                primary: KeyCode.DownArrow,
+                secondary: [KeyMod$1.CtrlCmd | KeyCode.DownArrow],
+                mac: { primary: KeyCode.DownArrow, secondary: [KeyMod$1.CtrlCmd | KeyCode.DownArrow, KeyMod$1.WinCtrl | KeyCode.KeyN] }
+            }
+        });
+    }
+    run(accessor) {
+        const widgetService = accessor.get(IActionWidgetService);
+        if (widgetService instanceof ActionWidgetService) {
+            widgetService.focusNext();
+        }
+    }
+});
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: acceptSelectedActionCommand,
+            title: ( localize2(1660, "Accept selected action")),
+            precondition: ActionWidgetContextKeys.Visible,
+            keybinding: {
+                weight,
+                primary: KeyCode.Enter,
+                secondary: [KeyMod$1.CtrlCmd | KeyCode.Period],
+            }
+        });
+    }
+    run(accessor) {
+        const widgetService = accessor.get(IActionWidgetService);
+        if (widgetService instanceof ActionWidgetService) {
+            widgetService.acceptSelected();
+        }
+    }
+});
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: previewSelectedActionCommand,
+            title: ( localize2(1661, "Preview selected action")),
+            precondition: ActionWidgetContextKeys.Visible,
+            keybinding: {
+                weight,
+                primary: KeyMod$1.CtrlCmd | KeyCode.Enter,
+            }
+        });
+    }
+    run(accessor) {
+        const widgetService = accessor.get(IActionWidgetService);
+        if (widgetService instanceof ActionWidgetService) {
+            widgetService.acceptSelected(true);
+        }
+    }
+});
+
+export { ActionWidgetService };

package/vscode/src/vs/platform/actions/browser/menuEntryActionViewItem.js

@@ -184,17 +184,17 @@ let MenuEntryActionViewItem = class MenuEntryActionViewItem extends ActionViewIt
         const keybindingLabel = keybinding && keybinding.getLabel();
         const tooltip = this._commandAction.tooltip || this._commandAction.label;
         let title = keybindingLabel
-            ? ( localize(1651, "{0} ({1})", tooltip, keybindingLabel))
+            ? ( localize(1665, "{0} ({1})", tooltip, keybindingLabel))
             : tooltip;
         if (!this._wantsAltCommand && this._menuItemAction.alt?.enabled) {
             const altTooltip = this._menuItemAction.alt.tooltip || this._menuItemAction.alt.label;
             const altKeybinding = this._keybindingService.lookupKeybinding(this._menuItemAction.alt.id, this._contextKeyService);
             const altKeybindingLabel = altKeybinding && altKeybinding.getLabel();
             const altTitleSection = altKeybindingLabel
-                ? ( localize(1651, "{0} ({1})", altTooltip, altKeybindingLabel))
+                ? ( localize(1665, "{0} ({1})", altTooltip, altKeybindingLabel))
                 : altTooltip;
             title = ( localize(
-                1652,
+                1666,
                 "{0}\n[{1}] {2}",
                 title,
                 UILabelProvider.modifierLabels[OS].altKey,
@@ -270,10 +270,10 @@ class TextOnlyMenuEntryActionViewItem extends MenuEntryActionViewItem {
         if (this.label) {
             const kb2 = TextOnlyMenuEntryActionViewItem._symbolPrintEnter(kb);
             if (this._options?.conversational) {
-                this.label.textContent = ( localize(1653, '{1} to {0}', this._action.label, kb2));
+                this.label.textContent = ( localize(1667, '{1} to {0}', this._action.label, kb2));
             }
             else {
-                this.label.textContent = ( localize(1654, '{0} ({1})', this._action.label, kb2));
+                this.label.textContent = ( localize(1668, '{0} ({1})', this._action.label, kb2));
             }
         }
     }

package/vscode/src/vs/platform/actions/browser/toolbar.js

@@ -144,7 +144,7 @@ let WorkbenchToolBar = class WorkbenchToolBar extends ToolBar {
                     else {
                         primaryActions.push(toAction({
                             id: 'label',
-                            label: ( localize(1655, "Hide")),
+                            label: ( localize(1669, "Hide")),
                             enabled: false,
                             run() { }
                         }));
@@ -158,7 +158,7 @@ let WorkbenchToolBar = class WorkbenchToolBar extends ToolBar {
                     actions.push(( new Separator()));
                     actions.push(toAction({
                         id: 'resetThisMenu',
-                        label: ( localize(1656, "Reset Menu")),
+                        label: ( localize(1670, "Reset Menu")),
                         run: () => this._menuService.resetHiddenStates(menuIds)
                     }));
                 }

package/vscode/src/vs/platform/actions/common/menuResetAction.js

@@ -9,7 +9,7 @@ class MenuHiddenStatesReset extends Action2 {
     constructor() {
         super({
             id: 'menu.resetHiddenStates',
-            title: ( localize2(1657, "Reset All Menus")),
+            title: ( localize2(1671, "Reset All Menus")),
             category: Categories.View,
             f1: true
         });

package/vscode/src/vs/platform/actions/common/menuService.js

@@ -408,7 +408,7 @@ function createMenuHide(menu, command, states) {
     const title = typeof command.title === 'string' ? command.title : command.title.value;
     const hide = toAction({
         id: `hide/${menu.id}/${id}`,
-        label: ( localize(1658, 'Hide \'{0}\'', title)),
+        label: ( localize(1672, 'Hide \'{0}\'', title)),
         run() { states.updateHidden(menu, id, true); }
     });
     const toggle = toAction({
@@ -426,7 +426,7 @@ function createMenuHide(menu, command, states) {
 function createConfigureKeybindingAction(commandService, keybindingService, commandId, when = undefined, enabled = true) {
     return toAction({
         id: `configureKeybinding/${commandId}`,
-        label: ( localize(1659, "Configure Keybinding")),
+        label: ( localize(1673, "Configure Keybinding")),
         enabled,
         run() {
             const hasKeybinding = !!keybindingService.lookupKeybinding(commandId);

package/vscode/src/vs/platform/configuration/common/configurationRegistry.js

@@ -46,7 +46,7 @@ class ConfigurationRegistry {
         this.configurationDefaultsOverrides = ( new Map());
         this.defaultLanguageConfigurationOverridesNode = {
             id: 'defaultOverrides',
-            title: ( localize(1660, "Default Language Configuration Overrides")),
+            title: ( localize(1674, "Default Language Configuration Overrides")),
             properties: {}
         };
         this.configurationContributors = [this.defaultLanguageConfigurationOverridesNode];
@@ -194,7 +194,7 @@ class ConfigurationRegistry {
             type: 'object',
             default: newDefaultOverride.value,
             description: ( localize(
-                1661,
+                1675,
                 "Configure settings to be overridden for the {0} language.",
                 getLanguageTagSettingPlainKey(key)
             )),
@@ -460,8 +460,8 @@ class ConfigurationRegistry {
             const overrideIdentifierProperty = `[${overrideIdentifier}]`;
             const resourceLanguagePropertiesSchema = {
                 type: 'object',
-                description: ( localize(1662, "Configure editor settings to be overridden for a language.")),
-                errorMessage: ( localize(1663, "This setting does not support per-language configuration.")),
+                description: ( localize(1676, "Configure editor settings to be overridden for a language.")),
+                errorMessage: ( localize(1677, "This setting does not support per-language configuration.")),
                 $ref: resourceLanguageSettingsSchemaId,
             };
             this.updatePropertyDefaultValue(overrideIdentifierProperty, resourceLanguagePropertiesSchema);
@@ -477,8 +477,8 @@ class ConfigurationRegistry {
     registerOverridePropertyPatternKey() {
         const resourceLanguagePropertiesSchema = {
             type: 'object',
-            description: ( localize(1662, "Configure editor settings to be overridden for a language.")),
-            errorMessage: ( localize(1663, "This setting does not support per-language configuration.")),
+            description: ( localize(1676, "Configure editor settings to be overridden for a language.")),
+            errorMessage: ( localize(1677, "This setting does not support per-language configuration.")),
             $ref: resourceLanguageSettingsSchemaId,
         };
         allSettings.patternProperties[OVERRIDE_PROPERTY_PATTERN] = resourceLanguagePropertiesSchema;
@@ -554,25 +554,25 @@ const configurationRegistry = ( new ConfigurationRegistry());
 Registry.add(Extensions.Configuration, configurationRegistry);
 function validateProperty(property, schema) {
     if (!property.trim()) {
-        return localize(1664, "Cannot register an empty property");
+        return localize(1678, "Cannot register an empty property");
     }
     if (OVERRIDE_PROPERTY_REGEX.test(property)) {
         return localize(
-            1665,
+            1679,
             "Cannot register '{0}'. This matches property pattern '\\\\[.*\\\\]$' for describing language specific editor settings. Use 'configurationDefaults' contribution.",
             property
         );
     }
     if (configurationRegistry.getConfigurationProperties()[property] !== undefined) {
         return localize(
-            1666,
+            1680,
             "Cannot register '{0}'. This property is already registered.",
             property
         );
     }
     if (schema.policy?.name && configurationRegistry.getPolicyConfigurations().get(schema.policy?.name) !== undefined) {
         return localize(
-            1667,
+            1681,
             "Cannot register '{0}'. The associated policy {1} is already registered with {2}.",
             property,
             schema.policy?.name,

package/vscode/src/vs/platform/contextkey/browser/contextKeyService.js

@@ -487,7 +487,7 @@ CommandsRegistry.registerCommand({
         return [...RawContextKey.all()].sort((a, b) => a.key.localeCompare(b.key));
     },
     metadata: {
-        description: ( localize(1668, "A command that returns information about context keys")),
+        description: ( localize(1682, "A command that returns information about context keys")),
         args: []
     }
 });

package/vscode/src/vs/platform/contextkey/common/contextkey.js

@@ -47,17 +47,17 @@ var ContextKeyExprType;
 const defaultConfig = {
     regexParsingWithErrorRecovery: true
 };
-const errorEmptyString = ( localize(1669, "Empty context key expression"));
+const errorEmptyString = ( localize(1683, "Empty context key expression"));
 const hintEmptyString = ( localize(
-    1670,
+    1684,
     "Did you forget to write an expression? You can also put 'false' or 'true' to always evaluate to false or true, respectively."
 ));
-const errorNoInAfterNot = ( localize(1671, "'in' after 'not'."));
-const errorClosingParenthesis = ( localize(1672, "closing parenthesis ')'"));
-const errorUnexpectedToken = ( localize(1673, "Unexpected token"));
-const hintUnexpectedToken = ( localize(1674, "Did you forget to put && or || before the token?"));
-const errorUnexpectedEOF = ( localize(1675, "Unexpected end of expression"));
-const hintUnexpectedEOF = ( localize(1676, "Did you forget to put a context key?"));
+const errorNoInAfterNot = ( localize(1685, "'in' after 'not'."));
+const errorClosingParenthesis = ( localize(1686, "closing parenthesis ')'"));
+const errorUnexpectedToken = ( localize(1687, "Unexpected token"));
+const hintUnexpectedToken = ( localize(1688, "Did you forget to put && or || before the token?"));
+const errorUnexpectedEOF = ( localize(1689, "Unexpected end of expression"));
+const hintUnexpectedEOF = ( localize(1690, "Did you forget to put a context key?"));
 class Parser {
     static { this._parseError = ( new Error()); }
     get lexingErrors() {
@@ -369,7 +369,7 @@ class Parser {
         throw this._errExpectedButGot(message, this._peek());
     }
     _errExpectedButGot(expected, got, additionalInfo) {
-        const message = ( localize(1677, "Expected: {0}\nReceived: '{1}'.", expected, Scanner.getLexeme(got)));
+        const message = ( localize(1691, "Expected: {0}\nReceived: '{1}'.", expected, Scanner.getLexeme(got)));
         const offset = got.offset;
         const lexeme = Scanner.getLexeme(got);
         this._parsingErrors.push({ message, offset, lexeme, additionalInfo });
@@ -447,8 +447,8 @@ function validateWhenClauses(whenClauses) {
         if (parser.lexingErrors.length > 0) {
             return (parser.lexingErrors.map((se) => ({
                 errorMessage: se.additionalInfo ?
-                    ( localize(1678, "Unexpected token. Hint: {0}", se.additionalInfo)) :
-                    ( localize(1679, "Unexpected token.")),
+                    ( localize(1692, "Unexpected token. Hint: {0}", se.additionalInfo)) :
+                    ( localize(1693, "Unexpected token.")),
                 offset: se.offset,
                 length: se.lexeme.length,
             })));

package/vscode/src/vs/platform/contextkey/common/contextkeys.js

@@ -3,16 +3,16 @@ import { isMacintosh, isLinux, isWindows, isWeb, isIOS, isMobile } from '../../.
 import { localize } from '../../../nls.js';
 import { RawContextKey } from './contextkey.js';
 
-const IsMacContext = ( new RawContextKey('isMac', isMacintosh, ( localize(1680, "Whether the operating system is macOS"))));
-const IsLinuxContext = ( new RawContextKey('isLinux', isLinux, ( localize(1681, "Whether the operating system is Linux"))));
-const IsWindowsContext = ( new RawContextKey('isWindows', isWindows, ( localize(1682, "Whether the operating system is Windows"))));
-const IsWebContext = ( new RawContextKey('isWeb', isWeb, ( localize(1683, "Whether the platform is a web browser"))));
-const IsMacNativeContext = ( new RawContextKey('isMacNative', isMacintosh && !isWeb, ( localize(1684, "Whether the operating system is macOS on a non-browser platform"))));
-const IsIOSContext = ( new RawContextKey('isIOS', isIOS, ( localize(1685, "Whether the operating system is iOS"))));
-const IsMobileContext = ( new RawContextKey('isMobile', isMobile, ( localize(1686, "Whether the platform is a mobile web browser"))));
+const IsMacContext = ( new RawContextKey('isMac', isMacintosh, ( localize(1694, "Whether the operating system is macOS"))));
+const IsLinuxContext = ( new RawContextKey('isLinux', isLinux, ( localize(1695, "Whether the operating system is Linux"))));
+const IsWindowsContext = ( new RawContextKey('isWindows', isWindows, ( localize(1696, "Whether the operating system is Windows"))));
+const IsWebContext = ( new RawContextKey('isWeb', isWeb, ( localize(1697, "Whether the platform is a web browser"))));
+const IsMacNativeContext = ( new RawContextKey('isMacNative', isMacintosh && !isWeb, ( localize(1698, "Whether the operating system is macOS on a non-browser platform"))));
+const IsIOSContext = ( new RawContextKey('isIOS', isIOS, ( localize(1699, "Whether the operating system is iOS"))));
+const IsMobileContext = ( new RawContextKey('isMobile', isMobile, ( localize(1700, "Whether the platform is a mobile web browser"))));
 const IsDevelopmentContext = ( new RawContextKey('isDevelopment', false, true));
-const ProductQualityContext = ( new RawContextKey('productQualityType', '', ( localize(1687, "Quality type of VS Code"))));
+const ProductQualityContext = ( new RawContextKey('productQualityType', '', ( localize(1701, "Quality type of VS Code"))));
 const InputFocusedContextKey = 'inputFocus';
-const InputFocusedContext = ( new RawContextKey(InputFocusedContextKey, false, ( localize(1688, "Whether keyboard focus is inside an input box"))));
+const InputFocusedContext = ( new RawContextKey(InputFocusedContextKey, false, ( localize(1702, "Whether keyboard focus is inside an input box"))));
 
 export { InputFocusedContext, InputFocusedContextKey, IsDevelopmentContext, IsIOSContext, IsLinuxContext, IsMacContext, IsMacNativeContext, IsMobileContext, IsWebContext, IsWindowsContext, ProductQualityContext };

package/vscode/src/vs/platform/contextkey/common/scanner.js

@@ -30,18 +30,18 @@ var TokenType;
 function hintDidYouMean(...meant) {
     switch (meant.length) {
         case 1:
-            return localize(1689, "Did you mean {0}?", meant[0]);
+            return localize(1703, "Did you mean {0}?", meant[0]);
         case 2:
-            return localize(1690, "Did you mean {0} or {1}?", meant[0], meant[1]);
+            return localize(1704, "Did you mean {0} or {1}?", meant[0], meant[1]);
         case 3:
-            return localize(1691, "Did you mean {0}, {1} or {2}?", meant[0], meant[1], meant[2]);
+            return localize(1705, "Did you mean {0}, {1} or {2}?", meant[0], meant[1], meant[2]);
         default:
             return undefined;
     }
 }
-const hintDidYouForgetToOpenOrCloseQuote = ( localize(1692, "Did you forget to open or close the quote?"));
+const hintDidYouForgetToOpenOrCloseQuote = ( localize(1706, "Did you forget to open or close the quote?"));
 const hintDidYouForgetToEscapeSlash = ( localize(
-    1693,
+    1707,
     "Did you forget to escape the '/' (slash) character? Put two backslashes before it to escape, e.g., '\\\\/\'."
 ));
 class Scanner {

package/vscode/src/vs/platform/dnd/browser/dnd.js

@@ -182,7 +182,7 @@ async function extractFileListData(accessor, files) {
         if (file) {
             if (file.size > 100 * ByteSize.MB) {
                 dialogService.warn(( localize(
-                    1699,
+                    1713,
                     "File is too large to open as untitled editor. Please upload it first into the file explorer and then try again."
                 )));
                 continue;

package/vscode/src/vs/platform/extensionManagement/common/extensionManagement.js

@@ -252,8 +252,8 @@ async function computeSize(location, fileService) {
     }
     return stat.size ?? 0;
 }
-const ExtensionsLocalizedLabel = ( localize2(1720, "Extensions"));
-const PreferencesLocalizedLabel = ( localize2(1721, 'Preferences'));
+const ExtensionsLocalizedLabel = ( localize2(1734, "Extensions"));
+const PreferencesLocalizedLabel = ( localize2(1735, 'Preferences'));
 const UseUnpkgResourceApiConfigKey = 'extensions.gallery.useUnpkgResourceApi';
 const AllowedExtensionsConfigKey = 'extensions.allowed';
 

package/vscode/src/vs/platform/extensionManagement/common/extensionNls.js

@@ -28,7 +28,7 @@ function replaceNLStrings(logger, extensionManifest, messages, originalMessages)
                 const originalMessage = typeof original === 'string' ? original : original?.message;
                 if (!message) {
                     if (!originalMessage) {
-                        logger.warn(`[${extensionManifest.name}]: ${( localize(1753, "Couldn't find message for key {0}.", messageKey))}`);
+                        logger.warn(`[${extensionManifest.name}]: ${( localize(1767, "Couldn't find message for key {0}.", messageKey))}`);
                     }
                     return;
                 }

package/vscode/src/vs/platform/extensionManagement/common/extensionsScannerService.js

@@ -441,7 +441,7 @@ let ExtensionManifestTranslator = class ExtensionManifestTranslator extends Disp
         const reportErrors = (localized, errors) => {
             errors.forEach((error) => {
                 this.logService.error(this.formatMessage(extensionLocation, ( localize(
-                    1754,
+                    1768,
                     "Failed to parse {0}: {1}.",
                     localized?.path,
                     getParseErrorMessage(error.error)
@@ -449,7 +449,7 @@ let ExtensionManifestTranslator = class ExtensionManifestTranslator extends Disp
             });
         };
         const reportInvalidFormat = (localized) => {
-            this.logService.error(this.formatMessage(extensionLocation, ( localize(1755, "Invalid format {0}: JSON object expected.", localized?.path))));
+            this.logService.error(this.formatMessage(extensionLocation, ( localize(1769, "Invalid format {0}: JSON object expected.", localized?.path))));
         };
         const translationId = `${extensionManifest.publisher}.${extensionManifest.name}`;
         const translationPath = nlsConfiguration.translations[translationId];
@@ -519,7 +519,7 @@ let ExtensionManifestTranslator = class ExtensionManifestTranslator extends Disp
                 if (errors.length > 0) {
                     errors.forEach((error) => {
                         this.logService.error(this.formatMessage(extensionLocation, ( localize(
-                            1754,
+                            1768,
                             "Failed to parse {0}: {1}.",
                             localizedMessages.default?.path,
                             getParseErrorMessage(error.error)
@@ -529,7 +529,7 @@ let ExtensionManifestTranslator = class ExtensionManifestTranslator extends Disp
                 }
                 else if (getNodeType(localizedMessages) !== 'object') {
                     this.logService.error(this.formatMessage(extensionLocation, ( localize(
-                        1755,
+                        1769,
                         "Invalid format {0}: JSON object expected.",
                         localizedMessages.default?.path
                     ))));
@@ -782,7 +782,7 @@ let ExtensionsScanner = class ExtensionsScanner extends ExtensionManifestTransla
         }
         catch (error) {
             if (toFileOperationResult(error) !== FileOperationResult.FILE_NOT_FOUND) {
-                this.logService.error(this.formatMessage(extensionLocation, ( localize(1756, "Cannot read file {0}: {1}.", manifestLocation.path, error.message))));
+                this.logService.error(this.formatMessage(extensionLocation, ( localize(1770, "Cannot read file {0}: {1}.", manifestLocation.path, error.message))));
             }
             throw error;
         }
@@ -795,7 +795,7 @@ let ExtensionsScanner = class ExtensionsScanner extends ExtensionManifestTransla
             parse(content, errors);
             for (const e of errors) {
                 this.logService.error(this.formatMessage(extensionLocation, ( localize(
-                    1757,
+                    1771,
                     "Failed to parse {0}: [{1}, {2}] {3}.",
                     manifestLocation.path,
                     e.offset,
@@ -807,7 +807,7 @@ let ExtensionsScanner = class ExtensionsScanner extends ExtensionManifestTransla
         }
         if (getNodeType(manifest) !== 'object') {
             const errorMessage = this.formatMessage(extensionLocation, ( localize(
-                1758,
+                1772,
                 "Invalid manifest file {0}: Not a JSON object.",
                 manifestLocation.path
             )));