@codingame/monaco-vscode-katex-common 25.1.1 → 26.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-katex-common",
-  "version": "25.1.1",
+  "version": "26.0.0",
   "private": false,
   "description": "VSCode public API plugged on the monaco editor - common package depending on katex",
   "keywords": [],
@@ -15,7 +15,7 @@
   },
   "type": "module",
   "dependencies": {
-    "@codingame/monaco-vscode-api": "25.1.1",
+    "@codingame/monaco-vscode-api": "26.0.0",
     "katex": "0.16.27",
     "marked": "14.0.0"
   },

package/vscode/src/vs/platform/actionWidget/browser/actionWidgetDropdown.d.ts

@@ -1,8 +1,10 @@
 import { IActionWidgetService } from "@codingame/monaco-vscode-api/vscode/vs/platform/actionWidget/browser/actionWidget.service";
 import { IAction } from "@codingame/monaco-vscode-api/vscode/vs/base/common/actions";
 import { BaseDropdown, IActionProvider, IBaseDropdownOptions } from "@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/dropdown/dropdown";
+import { IActionListItemHover } from "@codingame/monaco-vscode-api/vscode/vs/platform/actionWidget/browser/actionList";
 import { ThemeIcon } from "@codingame/monaco-vscode-api/vscode/vs/base/common/themables";
 import { IKeybindingService } from "@codingame/monaco-vscode-api/vscode/vs/platform/keybinding/common/keybinding.service";
+import { ITelemetryService } from "@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service";
 export interface IActionWidgetDropdownAction extends IAction {
     category?: {
         label: string;
@@ -11,6 +13,14 @@ export interface IActionWidgetDropdownAction extends IAction {
     };
     icon?: ThemeIcon;
     description?: string;
+    /**
+     * Optional flyout hover configuration shown when focusing/hovering over the action.
+     */
+    hover?: IActionListItemHover;
+    /**
+     * Optional toolbar actions shown when the item is focused or hovered.
+     */
+    toolbarActions?: IAction[];
 }
 export interface IActionWidgetDropdownActionProvider {
     getActions(): IActionWidgetDropdownAction[];
@@ -21,6 +31,15 @@ export interface IActionWidgetDropdownOptions extends IBaseDropdownOptions {
     readonly actionBarActions?: IAction[];
     readonly actionBarActionProvider?: IActionProvider;
     readonly showItemKeybindings?: boolean;
+    getAnchor?: () => HTMLElement;
+    /**
+     * Name used for telemetry tracking when the dropdown closes.
+     * If not provided, no telemetry will be sent.
+     */
+    readonly reporter?: {
+        name: string;
+        includeOptions?: boolean;
+    };
 }
 /**
  * Action widget dropdown is a dropdown that uses the action widget under the hood to simulate a native dropdown menu
@@ -30,8 +49,10 @@ export declare class ActionWidgetDropdown extends BaseDropdown {
     private readonly _options;
     private readonly actionWidgetService;
     private readonly keybindingService;
-    private enabled;
-    constructor(container: HTMLElement, _options: IActionWidgetDropdownOptions, actionWidgetService: IActionWidgetService, keybindingService: IKeybindingService);
+    private readonly telemetryService;
+    private _enabled;
+    constructor(container: HTMLElement, _options: IActionWidgetDropdownOptions, actionWidgetService: IActionWidgetService, keybindingService: IKeybindingService, telemetryService: ITelemetryService);
     show(): void;
     setEnabled(enabled: boolean): void;
+    private _emitCloseEvent;
 }

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

@@ -7,35 +7,47 @@ import { ThemeIcon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/th
 import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
 import { getActiveElement, isHTMLElement } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
 import { IKeybindingService } from '@codingame/monaco-vscode-api/vscode/vs/platform/keybinding/common/keybinding.service';
+import { ITelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service';
 
 let ActionWidgetDropdown = class ActionWidgetDropdown extends BaseDropdown {
-    constructor(container, _options, actionWidgetService, keybindingService) {
+    constructor(
+        container,
+        _options,
+        actionWidgetService,
+        keybindingService,
+        telemetryService
+    ) {
         super(container, _options);
         this._options = _options;
         this.actionWidgetService = actionWidgetService;
         this.keybindingService = keybindingService;
-        this.enabled = true;
+        this.telemetryService = telemetryService;
+        this._enabled = true;
     }
     show() {
-        if (!this.enabled) {
+        if (!this._enabled) {
             return;
         }
         let actionBarActions = this._options.actionBarActions ?? this._options.actionBarActionProvider?.getActions() ?? [];
         const actions = this._options.actions ?? this._options.actionProvider?.getActions() ?? [];
+        const optionBeforeOpen = actions.find(a => a.checked);
+        let selectedOption = optionBeforeOpen;
         const actionWidgetItems = [];
         const actionsByCategory = ( new Map());
         for (const action of actions) {
             let category = action.category;
             if (!category) {
-                category = { label: '', order: Number.MIN_SAFE_INTEGER };
+                category = {
+                    label: "",
+                    order: Number.MIN_SAFE_INTEGER
+                };
             }
             if (!( actionsByCategory.has(category.label))) {
                 actionsByCategory.set(category.label, []);
             }
             actionsByCategory.get(category.label).push(action);
         }
-        const sortedCategories = Array.from(actionsByCategory.entries())
-            .sort((a, b) => {
+        const sortedCategories = Array.from(actionsByCategory.entries()).sort((a, b) => {
             const aOrder = a[1][0]?.category?.order ?? Number.MAX_SAFE_INTEGER;
             const bOrder = b[1][0]?.category?.order ?? Number.MAX_SAFE_INTEGER;
             return aOrder - bOrder;
@@ -49,7 +61,7 @@ let ActionWidgetDropdown = class ActionWidgetDropdown extends BaseDropdown {
                     label: categoryLabel,
                     canPreview: false,
                     disabled: false,
-                    hideIcon: false,
+                    hideIcon: false
                 });
             }
             for (const action of categoryActions) {
@@ -57,30 +69,34 @@ let ActionWidgetDropdown = class ActionWidgetDropdown extends BaseDropdown {
                     item: action,
                     tooltip: action.tooltip,
                     description: action.description,
+                    hover: action.hover,
+                    toolbarActions: action.toolbarActions,
                     kind: ActionListItemKind.Action,
                     canPreview: false,
-                    group: { title: '', icon: action.icon ?? ThemeIcon.fromId(action.checked ? Codicon.check.id : Codicon.blank.id) },
+                    group: {
+                        title: "",
+                        icon: action.icon ?? ThemeIcon.fromId(action.checked ? Codicon.check.id : Codicon.blank.id)
+                    },
                     disabled: !action.enabled,
                     hideIcon: false,
                     label: action.label,
-                    keybinding: this._options.showItemKeybindings ?
-                        this.keybindingService.lookupKeybinding(action.id) :
-                        undefined,
+                    keybinding: this._options.showItemKeybindings ? this.keybindingService.lookupKeybinding(action.id) : undefined
                 });
             }
             if (i < sortedCategories.length - 1) {
                 actionWidgetItems.push({
-                    label: '',
+                    label: "",
                     kind: ActionListItemKind.Separator,
                     canPreview: false,
                     disabled: false,
-                    hideIcon: false,
+                    hideIcon: false
                 });
             }
         }
         const previouslyFocusedElement = getActiveElement();
         const actionWidgetDelegate = {
             onSelect: (action, preview) => {
+                selectedOption = action;
                 this.actionWidgetService.hide();
                 action.run();
             },
@@ -88,6 +104,7 @@ let ActionWidgetDropdown = class ActionWidgetDropdown extends BaseDropdown {
                 if (isHTMLElement(previouslyFocusedElement)) {
                     previouslyFocusedElement.focus();
                 }
+                this._emitCloseEvent(optionBeforeOpen, selectedOption);
             }
         };
         actionBarActions = ( actionBarActions.map(action => ({
@@ -101,27 +118,47 @@ let ActionWidgetDropdown = class ActionWidgetDropdown extends BaseDropdown {
             isChecked(element) {
                 return element.kind === ActionListItemKind.Action && !!element?.item?.checked;
             },
-            getRole: (e) => {
+            getRole: e => {
                 switch (e.kind) {
-                    case ActionListItemKind.Action:
-                        return 'menuitemcheckbox';
-                    case ActionListItemKind.Separator:
-                        return 'separator';
-                    default:
-                        return 'separator';
+                case ActionListItemKind.Action:
+                    return "menuitemcheckbox";
+                case ActionListItemKind.Separator:
+                    return "separator";
+                default:
+                    return "separator";
                 }
             },
-            getWidgetRole: () => 'menu',
+            getWidgetRole: () => "menu"
         };
-        this.actionWidgetService.show(this._options.label ?? '', false, actionWidgetItems, actionWidgetDelegate, this.element, undefined, actionBarActions, accessibilityProvider);
+        this.actionWidgetService.show(
+            this._options.label ?? "",
+            false,
+            actionWidgetItems,
+            actionWidgetDelegate,
+            this._options.getAnchor?.() ?? this.element,
+            undefined,
+            actionBarActions,
+            accessibilityProvider
+        );
     }
     setEnabled(enabled) {
-        this.enabled = enabled;
+        this._enabled = enabled;
+    }
+    _emitCloseEvent(optionBeforeOpen, selectedOption) {
+        const optionBefore = optionBeforeOpen;
+        const optionAfter = selectedOption;
+        if (this._options.reporter) {
+            this.telemetryService.publicLog2("actionWidgetDropdownClosed", {
+                name: this._options.reporter.name,
+                selectionChanged: optionBefore?.id !== optionAfter?.id,
+                optionIdBefore: this._options.reporter.includeOptions ? optionBefore?.id : undefined,
+                optionIdAfter: this._options.reporter.includeOptions ? optionAfter?.id : undefined,
+                optionLabelBefore: this._options.reporter.includeOptions ? optionBefore?.label : undefined,
+                optionLabelAfter: this._options.reporter.includeOptions ? optionAfter?.label : undefined
+            });
+        }
     }
 };
-ActionWidgetDropdown = ( __decorate([
-    ( __param(2, IActionWidgetService)),
-    ( __param(3, IKeybindingService))
-], ActionWidgetDropdown));
+ActionWidgetDropdown = ( __decorate([( __param(2, IActionWidgetService)), ( __param(3, IKeybindingService)), ( __param(4, ITelemetryService))], ActionWidgetDropdown));
 
 export { ActionWidgetDropdown };

package/vscode/src/vs/platform/actions/browser/actionWidgetDropdownActionViewItem.d.ts

@@ -5,6 +5,7 @@ import { IActionWidgetService } from "@codingame/monaco-vscode-api/vscode/vs/pla
 import { IActionWidgetDropdownOptions } from "../../actionWidget/browser/actionWidgetDropdown.js";
 import { IContextKeyService } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service";
 import { IKeybindingService } from "@codingame/monaco-vscode-api/vscode/vs/platform/keybinding/common/keybinding.service";
+import { ITelemetryService } from "@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service";
 /**
  * Action view item for the custom action widget dropdown widget.
  * Very closely based off of `DropdownMenuActionViewItem`, would be good to have some code re-use in the future
@@ -14,9 +15,10 @@ export declare class ActionWidgetDropdownActionViewItem extends BaseActionViewIt
     private readonly _actionWidgetService;
     private readonly _keybindingService;
     private readonly _contextKeyService;
+    private readonly _telemetryService;
     private actionWidgetDropdown;
     private actionItem;
-    constructor(action: IAction, actionWidgetOptions: Omit<IActionWidgetDropdownOptions, "label" | "labelRenderer">, _actionWidgetService: IActionWidgetService, _keybindingService: IKeybindingService, _contextKeyService: IContextKeyService);
+    constructor(action: IAction, actionWidgetOptions: Omit<IActionWidgetDropdownOptions, "label" | "labelRenderer">, _actionWidgetService: IActionWidgetService, _keybindingService: IKeybindingService, _contextKeyService: IContextKeyService, _telemetryService: ITelemetryService);
     render(container: HTMLElement): void;
     protected renderLabel(element: HTMLElement): IDisposable | null;
     protected updateAriaLabel(): void;

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

@@ -8,38 +8,49 @@ import { IActionWidgetService } from '@codingame/monaco-vscode-api/vscode/vs/pla
 import { ActionWidgetDropdown } from '../../actionWidget/browser/actionWidgetDropdown.js';
 import { IContextKeyService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service';
 import { IKeybindingService } from '@codingame/monaco-vscode-api/vscode/vs/platform/keybinding/common/keybinding.service';
+import { ITelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service';
 
 let ActionWidgetDropdownActionViewItem = class ActionWidgetDropdownActionViewItem extends BaseActionViewItem {
-    constructor(action, actionWidgetOptions, _actionWidgetService, _keybindingService, _contextKeyService) {
+    constructor(
+        action,
+        actionWidgetOptions,
+        _actionWidgetService,
+        _keybindingService,
+        _contextKeyService,
+        _telemetryService
+    ) {
         super(undefined, action);
         this.actionWidgetOptions = actionWidgetOptions;
         this._actionWidgetService = _actionWidgetService;
         this._keybindingService = _keybindingService;
         this._contextKeyService = _contextKeyService;
+        this._telemetryService = _telemetryService;
         this.actionItem = null;
     }
     render(container) {
         this.actionItem = container;
-        const labelRenderer = (el) => {
-            this.element = append(el, $('a.action-label'));
+        const labelRenderer = el => {
+            this.element = append(el, $("a.action-label"));
             return this.renderLabel(this.element);
         };
-        this.actionWidgetDropdown = this._register(( new ActionWidgetDropdown(
-            container,
-            { ...this.actionWidgetOptions, labelRenderer },
-            this._actionWidgetService,
-            this._keybindingService
-        )));
+        this.actionWidgetDropdown = this._register(( new ActionWidgetDropdown(container, {
+            ...this.actionWidgetOptions,
+            labelRenderer
+        }, this._actionWidgetService, this._keybindingService, this._telemetryService)));
         this._register(this.actionWidgetDropdown.onDidChangeVisibility(visible => {
-            this.element?.setAttribute('aria-expanded', `${visible}`);
+            this.element?.setAttribute("aria-expanded", `${visible}`);
         }));
         this.updateTooltip();
         this.updateEnabled();
     }
     renderLabel(element) {
-        element.classList.add('codicon');
+        element.classList.add("codicon");
         if (this._action.label) {
-            this._register(getBaseLayerHoverDelegate().setupManagedHover(this.options.hoverDelegate ?? getDefaultHoverDelegate('mouse'), element, this._action.label));
+            this._register(getBaseLayerHoverDelegate().setupManagedHover(
+                this.options.hoverDelegate ?? getDefaultHoverDelegate("mouse"),
+                element,
+                this._action.label
+            ));
         }
         return null;
     }
@@ -49,33 +60,25 @@ let ActionWidgetDropdownActionViewItem = class ActionWidgetDropdownActionViewIte
         }
     }
     setAriaLabelAttributes(element) {
-        element.setAttribute('role', 'button');
-        element.setAttribute('aria-haspopup', 'true');
-        element.setAttribute('aria-expanded', 'false');
-        element.ariaLabel = (this.getTooltip() + ' - ' + (element.textContent || this._action.label)) || '';
+        element.setAttribute("role", "button");
+        element.setAttribute("aria-haspopup", "true");
+        element.setAttribute("aria-expanded", "false");
+        element.ariaLabel = (this.getTooltip() + " - " + (element.textContent || this._action.label)) || "";
     }
     getTooltip() {
-        const keybinding = this._keybindingService.lookupKeybinding(this.action.id, this._contextKeyService);
-        const keybindingLabel = keybinding && keybinding.getLabel();
         const tooltip = this.action.tooltip ?? this.action.label;
-        return keybindingLabel
-            ? `${tooltip} (${keybindingLabel})`
-            : tooltip;
+        return this._keybindingService.appendKeybinding(tooltip, this.action.id, this._contextKeyService);
     }
     show() {
         this.actionWidgetDropdown?.show();
     }
     updateEnabled() {
         const disabled = !this.action.enabled;
-        this.actionItem?.classList.toggle('disabled', disabled);
-        this.element?.classList.toggle('disabled', disabled);
+        this.actionItem?.classList.toggle("disabled", disabled);
+        this.element?.classList.toggle("disabled", disabled);
         this.actionWidgetDropdown?.setEnabled(!disabled);
     }
 };
-ActionWidgetDropdownActionViewItem = ( __decorate([
-    ( __param(2, IActionWidgetService)),
-    ( __param(3, IKeybindingService)),
-    ( __param(4, IContextKeyService))
-], ActionWidgetDropdownActionViewItem));
+ActionWidgetDropdownActionViewItem = ( __decorate([( __param(2, IActionWidgetService)), ( __param(3, IKeybindingService)), ( __param(4, IContextKeyService)), ( __param(5, ITelemetryService))], ActionWidgetDropdownActionViewItem));
 
 export { ActionWidgetDropdownActionViewItem };

package/vscode/src/vs/platform/actions/browser/buttonbar.d.ts

@@ -18,6 +18,8 @@ export type IButtonConfigProvider = (action: IAction, index: number) => {
 export interface IWorkbenchButtonBarOptions {
     telemetrySource?: string;
     buttonConfigProvider?: IButtonConfigProvider;
+    small?: boolean;
+    disableWhileRunning?: boolean;
 }
 export declare class WorkbenchButtonBar extends ButtonBar {
     private readonly _options;

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

@@ -18,7 +18,14 @@ import { IKeybindingService } from '@codingame/monaco-vscode-api/vscode/vs/platf
 import { ITelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service';
 
 let WorkbenchButtonBar = class WorkbenchButtonBar extends ButtonBar {
-    constructor(container, _options, _contextMenuService, _keybindingService, telemetryService, _hoverService) {
+    constructor(
+        container,
+        _options,
+        _contextMenuService,
+        _keybindingService,
+        telemetryService,
+        _hoverService
+    ) {
         super(container);
         this._options = _options;
         this._contextMenuService = _contextMenuService;
@@ -31,7 +38,10 @@ let WorkbenchButtonBar = class WorkbenchButtonBar extends ButtonBar {
         this._actionRunner = this._store.add(( new ActionRunner()));
         if (_options?.telemetrySource) {
             this._actionRunner.onDidRun(e => {
-                telemetryService.publicLog2('workbenchActionExecuted', { id: e.action.id, from: _options.telemetrySource });
+                telemetryService.publicLog2("workbenchActionExecuted", {
+                    id: e.action.id,
+                    from: _options.telemetrySource
+                });
             }, undefined, this._store);
         }
     }
@@ -42,7 +52,9 @@ let WorkbenchButtonBar = class WorkbenchButtonBar extends ButtonBar {
         super.dispose();
     }
     update(actions, secondary) {
-        const conifgProvider = this._options?.buttonConfigProvider ?? (() => ({ showLabel: true }));
+        const conifgProvider = this._options?.buttonConfigProvider ?? (() => ({
+            showLabel: true
+        }));
         this._updateStore.clear();
         this.clear();
         const hoverDelegate = this._updateStore.add(createInstantHoverDelegate());
@@ -51,18 +63,9 @@ let WorkbenchButtonBar = class WorkbenchButtonBar extends ButtonBar {
             const actionOrSubmenu = actions[i];
             let action;
             let btn;
-            let tooltip = '';
-            const kb = actionOrSubmenu instanceof SubmenuAction ? '' : this._keybindingService.lookupKeybinding(actionOrSubmenu.id);
-            if (kb) {
-                tooltip = ( localize(
-                    1757,
-                    "{0} ({1})",
-                    actionOrSubmenu.tooltip || actionOrSubmenu.label,
-                    kb.getLabel()
-                ));
-            }
-            else {
-                tooltip = actionOrSubmenu.tooltip || actionOrSubmenu.label;
+            let tooltip = actionOrSubmenu.tooltip || actionOrSubmenu.label;
+            if (!(actionOrSubmenu instanceof SubmenuAction)) {
+                tooltip = this._keybindingService.appendKeybinding(tooltip, actionOrSubmenu.id);
             }
             if (actionOrSubmenu instanceof SubmenuAction && actionOrSubmenu.actions.length > 0) {
                 const [first, ...rest] = actionOrSubmenu.actions;
@@ -74,80 +77,105 @@ let WorkbenchButtonBar = class WorkbenchButtonBar extends ButtonBar {
                     contextMenuProvider: this._contextMenuService,
                     ariaLabel: tooltip,
                     supportIcons: true,
+                    small: this._options?.small
                 });
-            }
-            else {
+            } else {
                 action = actionOrSubmenu;
                 btn = this.addButton({
                     secondary: conifgProvider(action, i)?.isSecondary ?? secondary,
                     ariaLabel: tooltip,
                     supportIcons: true,
+                    small: this._options?.small
                 });
             }
             btn.enabled = action.enabled;
             btn.checked = action.checked ?? false;
-            btn.element.classList.add('default-colors');
+            btn.element.classList.add("default-colors");
             const showLabel = conifgProvider(action, i)?.showLabel ?? true;
             if (showLabel) {
                 btn.label = action.label;
-            }
-            else {
-                btn.element.classList.add('monaco-text-button');
+            } else {
+                btn.element.classList.add("monaco-text-button");
             }
             if (conifgProvider(action, i)?.showIcon) {
                 if (action instanceof MenuItemAction && ThemeIcon.isThemeIcon(action.item.icon)) {
                     if (!showLabel) {
                         btn.icon = action.item.icon;
-                    }
-                    else {
+                    } else {
                         btn.label = `$(${action.item.icon.id}) ${action.label}`;
                     }
-                }
-                else if (action.class) {
-                    btn.element.classList.add(...action.class.split(' '));
+                } else if (action.class) {
+                    btn.element.classList.add(...action.class.split(" "));
                 }
             }
             this._updateStore.add(this._hoverService.setupManagedHover(hoverDelegate, btn.element, tooltip));
             this._updateStore.add(btn.onDidClick(async () => {
-                this._actionRunner.run(action);
+                if (this._options?.disableWhileRunning) {
+                    btn.enabled = false;
+                    try {
+                        await this._actionRunner.run(action);
+                    } finally {
+                        btn.enabled = action.enabled;
+                    }
+                } else {
+                    this._actionRunner.run(action);
+                }
             }));
         }
         if (secondary.length > 0) {
             const btn = this.addButton({
                 secondary: true,
-                ariaLabel: ( localize(1758, "More Actions"))
+                ariaLabel: ( localize(1758, "More Actions")),
+                small: this._options?.small
             });
             btn.icon = Codicon.dropDownButton;
-            btn.element.classList.add('default-colors', 'monaco-text-button');
+            btn.element.classList.add("default-colors", "monaco-text-button");
             btn.enabled = true;
-            this._updateStore.add(this._hoverService.setupManagedHover(hoverDelegate, btn.element, ( localize(1758, "More Actions"))));
+            this._updateStore.add(
+                this._hoverService.setupManagedHover(hoverDelegate, btn.element, ( localize(1758, "More Actions")))
+            );
             this._updateStore.add(btn.onDidClick(async () => {
                 this._contextMenuService.showContextMenu({
                     getAnchor: () => btn.element,
                     getActions: () => secondary,
                     actionRunner: this._actionRunner,
-                    onHide: () => btn.element.setAttribute('aria-expanded', 'false')
+                    onHide: () => btn.element.setAttribute("aria-expanded", "false")
                 });
-                btn.element.setAttribute('aria-expanded', 'true');
+                btn.element.setAttribute("aria-expanded", "true");
             }));
         }
         this._onDidChange.fire(this);
     }
 };
-WorkbenchButtonBar = ( __decorate([
-    ( __param(2, IContextMenuService)),
-    ( __param(3, IKeybindingService)),
-    ( __param(4, ITelemetryService)),
-    ( __param(5, IHoverService))
-], WorkbenchButtonBar));
+WorkbenchButtonBar = ( __decorate([( __param(2, IContextMenuService)), ( __param(3, IKeybindingService)), ( __param(4, ITelemetryService)), ( __param(5, IHoverService))], WorkbenchButtonBar));
 let MenuWorkbenchButtonBar = class MenuWorkbenchButtonBar extends WorkbenchButtonBar {
-    constructor(container, menuId, options, menuService, contextKeyService, contextMenuService, keybindingService, telemetryService, hoverService) {
-        super(container, options, contextMenuService, keybindingService, telemetryService, hoverService);
+    constructor(
+        container,
+        menuId,
+        options,
+        menuService,
+        contextKeyService,
+        contextMenuService,
+        keybindingService,
+        telemetryService,
+        hoverService
+    ) {
+        super(
+            container,
+            options,
+            contextMenuService,
+            keybindingService,
+            telemetryService,
+            hoverService
+        );
         const menu = menuService.createMenu(menuId, contextKeyService);
         this._store.add(menu);
         const update = () => {
             this.clear();
-            const actions = getActionBarActions(menu.getActions(options?.menuOptions), options?.toolbarOptions?.primaryGroup);
+            const actions = getActionBarActions(
+                menu.getActions(options?.menuOptions),
+                options?.toolbarOptions?.primaryGroup
+            );
             super.update(actions.primary, actions.secondary);
         };
         this._store.add(menu.onDidChange(update));
@@ -157,16 +185,9 @@ let MenuWorkbenchButtonBar = class MenuWorkbenchButtonBar extends WorkbenchButto
         super.dispose();
     }
     update(_actions) {
-        throw ( new Error('Use Menu or WorkbenchButtonBar'));
+        throw ( new Error("Use Menu or WorkbenchButtonBar"));
     }
 };
-MenuWorkbenchButtonBar = ( __decorate([
-    ( __param(3, IMenuService)),
-    ( __param(4, IContextKeyService)),
-    ( __param(5, IContextMenuService)),
-    ( __param(6, IKeybindingService)),
-    ( __param(7, ITelemetryService)),
-    ( __param(8, IHoverService))
-], MenuWorkbenchButtonBar));
+MenuWorkbenchButtonBar = ( __decorate([( __param(3, IMenuService)), ( __param(4, IContextKeyService)), ( __param(5, IContextMenuService)), ( __param(6, IKeybindingService)), ( __param(7, ITelemetryService)), ( __param(8, IHoverService))], MenuWorkbenchButtonBar));
 
 export { MenuWorkbenchButtonBar, WorkbenchButtonBar };

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

@@ -34,17 +34,27 @@ function toOpenEditorOptions(event, isDoubleClick) {
         let preserveFocus = undefined;
         if (event.equals(KeyCode.Enter) || (isMacintosh && event.equals(KeyMod.CtrlCmd | KeyCode.DownArrow))) {
             preserveFocus = false;
-        }
-        else if (event.equals(KeyCode.Space)) {
+        } else if (event.equals(KeyCode.Space)) {
             preserveFocus = true;
         }
-        if (typeof preserveFocus === 'undefined') {
+        if (typeof preserveFocus === "undefined") {
             return;
         }
-        return { editorOptions: { preserveFocus, pinned: !preserveFocus }, openToSide: false };
-    }
-    else {
-        return { editorOptions: { preserveFocus: !isDoubleClick, pinned: isDoubleClick || event.middleButton }, openToSide: event.ctrlKey || event.metaKey || event.altKey };
+        return {
+            editorOptions: {
+                preserveFocus,
+                pinned: !preserveFocus
+            },
+            openToSide: false
+        };
+    } else {
+        return {
+            editorOptions: {
+                preserveFocus: !isDoubleClick,
+                pinned: isDoubleClick || event.middleButton
+            },
+            openToSide: event.ctrlKey || event.metaKey || event.altKey
+        };
     }
 }