@codingame/monaco-vscode-katex-common 24.1.0

package/empty.js

@@ -0,0 +1 @@
+export {}

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@codingame/monaco-vscode-katex-common",
+  "version": "24.1.0",
+  "private": false,
+  "description": "VSCode public API plugged on the monaco editor - common package depending on katex",
+  "keywords": [],
+  "author": {
+    "name": "CodinGame",
+    "url": "http://www.codingame.com"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/CodinGame/monaco-vscode-api.git"
+  },
+  "type": "module",
+  "dependencies": {
+    "@codingame/monaco-vscode-api": "24.1.0",
+    "katex": "0.16.22",
+    "marked": "14.0.0"
+  },
+  "exports": {
+    ".": {
+      "default": "./empty.js"
+    },
+    "./vscode/*.css": {
+      "default": "./vscode/src/*.css"
+    },
+    "./vscode/*": {
+      "types": "./vscode/src/*.d.ts",
+      "default": "./vscode/src/*.js"
+    },
+    "./*": {
+      "types": "./*.d.ts",
+      "default": "./*.js"
+    }
+  },
+  "typesVersions": {
+    "*": {
+      "vscode/*": [
+        "./vscode/src/*.d.ts"
+      ]
+    }
+  }
+}

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

@@ -0,0 +1,37 @@
+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 { 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";
+export interface IActionWidgetDropdownAction extends IAction {
+    category?: {
+        label: string;
+        order: number;
+        showHeader?: boolean;
+    };
+    icon?: ThemeIcon;
+    description?: string;
+}
+export interface IActionWidgetDropdownActionProvider {
+    getActions(): IActionWidgetDropdownAction[];
+}
+export interface IActionWidgetDropdownOptions extends IBaseDropdownOptions {
+    readonly actions?: IActionWidgetDropdownAction[];
+    readonly actionProvider?: IActionWidgetDropdownActionProvider;
+    readonly actionBarActions?: IAction[];
+    readonly actionBarActionProvider?: IActionProvider;
+    readonly showItemKeybindings?: boolean;
+}
+/**
+ * Action widget dropdown is a dropdown that uses the action widget under the hood to simulate a native dropdown menu
+ * The benefits of this include non native features such as headers, descriptions, icons, and button bar
+ */
+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);
+    show(): void;
+    setEnabled(enabled: boolean): void;
+}

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

@@ -0,0 +1,127 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { IActionWidgetService } from '@codingame/monaco-vscode-api/vscode/vs/platform/actionWidget/browser/actionWidget.service';
+import { BaseDropdown } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/dropdown/dropdown';
+import { ActionListItemKind } from '@codingame/monaco-vscode-api/vscode/vs/platform/actionWidget/browser/actionList';
+import { ThemeIcon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/themables';
+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';
+
+let ActionWidgetDropdown = class ActionWidgetDropdown extends BaseDropdown {
+    constructor(container, _options, actionWidgetService, keybindingService) {
+        super(container, _options);
+        this._options = _options;
+        this.actionWidgetService = actionWidgetService;
+        this.keybindingService = keybindingService;
+        this.enabled = true;
+    }
+    show() {
+        if (!this.enabled) {
+            return;
+        }
+        let actionBarActions = this._options.actionBarActions ?? this._options.actionBarActionProvider?.getActions() ?? [];
+        const actions = this._options.actions ?? this._options.actionProvider?.getActions() ?? [];
+        const actionWidgetItems = [];
+        const actionsByCategory = ( new Map());
+        for (const action of actions) {
+            let category = action.category;
+            if (!category) {
+                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 aOrder = a[1][0]?.category?.order ?? Number.MAX_SAFE_INTEGER;
+            const bOrder = b[1][0]?.category?.order ?? Number.MAX_SAFE_INTEGER;
+            return aOrder - bOrder;
+        });
+        for (let i = 0; i < sortedCategories.length; i++) {
+            const [categoryLabel, categoryActions] = sortedCategories[i];
+            const showHeader = categoryActions[0]?.category?.showHeader ?? false;
+            if (showHeader && categoryLabel) {
+                actionWidgetItems.push({
+                    kind: ActionListItemKind.Header,
+                    label: categoryLabel,
+                    canPreview: false,
+                    disabled: false,
+                    hideIcon: false,
+                });
+            }
+            for (const action of categoryActions) {
+                actionWidgetItems.push({
+                    item: action,
+                    tooltip: action.tooltip,
+                    description: action.description,
+                    kind: ActionListItemKind.Action,
+                    canPreview: false,
+                    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,
+                });
+            }
+            if (i < sortedCategories.length - 1) {
+                actionWidgetItems.push({
+                    label: '',
+                    kind: ActionListItemKind.Separator,
+                    canPreview: false,
+                    disabled: false,
+                    hideIcon: false,
+                });
+            }
+        }
+        const previouslyFocusedElement = getActiveElement();
+        const actionWidgetDelegate = {
+            onSelect: (action, preview) => {
+                this.actionWidgetService.hide();
+                action.run();
+            },
+            onHide: () => {
+                if (isHTMLElement(previouslyFocusedElement)) {
+                    previouslyFocusedElement.focus();
+                }
+            }
+        };
+        actionBarActions = ( actionBarActions.map(action => ({
+            ...action,
+            run: async (...args) => {
+                this.actionWidgetService.hide();
+                return action.run(...args);
+            }
+        })));
+        const accessibilityProvider = {
+            isChecked(element) {
+                return element.kind === ActionListItemKind.Action && !!element?.item?.checked;
+            },
+            getRole: (e) => {
+                switch (e.kind) {
+                    case ActionListItemKind.Action:
+                        return 'menuitemcheckbox';
+                    case ActionListItemKind.Separator:
+                        return 'separator';
+                    default:
+                        return 'separator';
+                }
+            },
+            getWidgetRole: () => 'menu',
+        };
+        this.actionWidgetService.show(this._options.label ?? '', false, actionWidgetItems, actionWidgetDelegate, this.element, undefined, actionBarActions, accessibilityProvider);
+    }
+    setEnabled(enabled) {
+        this.enabled = enabled;
+    }
+};
+ActionWidgetDropdown = ( __decorate([
+    ( __param(2, IActionWidgetService)),
+    ( __param(3, IKeybindingService))
+], ActionWidgetDropdown));
+
+export { ActionWidgetDropdown };

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

@@ -0,0 +1,27 @@
+import { BaseActionViewItem } from "@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/actionbar/actionViewItems";
+import { IAction } from "@codingame/monaco-vscode-api/vscode/vs/base/common/actions";
+import { IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IActionWidgetService } from "@codingame/monaco-vscode-api/vscode/vs/platform/actionWidget/browser/actionWidget.service";
+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";
+/**
+ * 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
+ */
+export declare class ActionWidgetDropdownActionViewItem extends BaseActionViewItem {
+    private readonly actionWidgetOptions;
+    private readonly _actionWidgetService;
+    private readonly _keybindingService;
+    private readonly _contextKeyService;
+    private actionWidgetDropdown;
+    private actionItem;
+    constructor(action: IAction, actionWidgetOptions: Omit<IActionWidgetDropdownOptions, "label" | "labelRenderer">, _actionWidgetService: IActionWidgetService, _keybindingService: IKeybindingService, _contextKeyService: IContextKeyService);
+    render(container: HTMLElement): void;
+    protected renderLabel(element: HTMLElement): IDisposable | null;
+    protected updateAriaLabel(): void;
+    protected setAriaLabelAttributes(element: HTMLElement): void;
+    protected getTooltip(): string;
+    show(): void;
+    protected updateEnabled(): void;
+}

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

@@ -0,0 +1,81 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { append, $ } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { BaseActionViewItem } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/actionbar/actionViewItems';
+import { getBaseLayerHoverDelegate } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/hover/hoverDelegate2';
+import { getDefaultHoverDelegate } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/hover/hoverDelegateFactory';
+import { IActionWidgetService } from '@codingame/monaco-vscode-api/vscode/vs/platform/actionWidget/browser/actionWidget.service';
+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';
+
+let ActionWidgetDropdownActionViewItem = class ActionWidgetDropdownActionViewItem extends BaseActionViewItem {
+    constructor(action, actionWidgetOptions, _actionWidgetService, _keybindingService, _contextKeyService) {
+        super(undefined, action);
+        this.actionWidgetOptions = actionWidgetOptions;
+        this._actionWidgetService = _actionWidgetService;
+        this._keybindingService = _keybindingService;
+        this._contextKeyService = _contextKeyService;
+        this.actionItem = null;
+    }
+    render(container) {
+        this.actionItem = container;
+        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._register(this.actionWidgetDropdown.onDidChangeVisibility(visible => {
+            this.element?.setAttribute('aria-expanded', `${visible}`);
+        }));
+        this.updateTooltip();
+        this.updateEnabled();
+    }
+    renderLabel(element) {
+        element.classList.add('codicon');
+        if (this._action.label) {
+            this._register(getBaseLayerHoverDelegate().setupManagedHover(this.options.hoverDelegate ?? getDefaultHoverDelegate('mouse'), element, this._action.label));
+        }
+        return null;
+    }
+    updateAriaLabel() {
+        if (this.element) {
+            this.setAriaLabelAttributes(this.element);
+        }
+    }
+    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)) || '';
+    }
+    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;
+    }
+    show() {
+        this.actionWidgetDropdown?.show();
+    }
+    updateEnabled() {
+        const disabled = !this.action.enabled;
+        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));
+
+export { ActionWidgetDropdownActionViewItem };

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

@@ -0,0 +1,44 @@
+import { ButtonBar } from "@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/button/button";
+import { IAction } from "@codingame/monaco-vscode-api/vscode/vs/base/common/actions";
+import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
+import { DisposableStore } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IToolBarRenderOptions } from "@codingame/monaco-vscode-api/vscode/vs/platform/actions/browser/toolbar";
+import { MenuId, IMenuActionOptions } from "@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions";
+import { IMenuService } from "@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions.service";
+import { IContextKeyService } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service";
+import { IContextMenuService } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextview/browser/contextView.service";
+import { IHoverService } from "@codingame/monaco-vscode-api/vscode/vs/platform/hover/browser/hover.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";
+export type IButtonConfigProvider = (action: IAction, index: number) => {
+    showIcon?: boolean;
+    showLabel?: boolean;
+    isSecondary?: boolean;
+} | undefined;
+export interface IWorkbenchButtonBarOptions {
+    telemetrySource?: string;
+    buttonConfigProvider?: IButtonConfigProvider;
+}
+export declare class WorkbenchButtonBar extends ButtonBar {
+    private readonly _options;
+    private readonly _contextMenuService;
+    private readonly _keybindingService;
+    private readonly _hoverService;
+    protected readonly _store: DisposableStore;
+    protected readonly _updateStore: DisposableStore;
+    private readonly _actionRunner;
+    private readonly _onDidChange;
+    readonly onDidChange: Event<this>;
+    constructor(container: HTMLElement, _options: IWorkbenchButtonBarOptions | undefined, _contextMenuService: IContextMenuService, _keybindingService: IKeybindingService, telemetryService: ITelemetryService, _hoverService: IHoverService);
+    dispose(): void;
+    update(actions: IAction[], secondary: IAction[]): void;
+}
+export interface IMenuWorkbenchButtonBarOptions extends IWorkbenchButtonBarOptions {
+    menuOptions?: IMenuActionOptions;
+    toolbarOptions?: IToolBarRenderOptions;
+}
+export declare class MenuWorkbenchButtonBar extends WorkbenchButtonBar {
+    constructor(container: HTMLElement, menuId: MenuId, options: IMenuWorkbenchButtonBarOptions | undefined, menuService: IMenuService, contextKeyService: IContextKeyService, contextMenuService: IContextMenuService, keybindingService: IKeybindingService, telemetryService: ITelemetryService, hoverService: IHoverService);
+    dispose(): void;
+    update(_actions: IAction[]): void;
+}

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

@@ -0,0 +1,172 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { ButtonBar } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/button/button';
+import { createInstantHoverDelegate } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/hover/hoverDelegateFactory';
+import { ActionRunner, SubmenuAction } from '@codingame/monaco-vscode-api/vscode/vs/base/common/actions';
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { ThemeIcon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/themables';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { getActionBarActions } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/browser/menuEntryActionViewItem';
+import { MenuItemAction } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
+import { IMenuService } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions.service';
+import { IContextKeyService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service';
+import { IContextMenuService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextview/browser/contextView.service';
+import { IHoverService } from '@codingame/monaco-vscode-api/vscode/vs/platform/hover/browser/hover.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 WorkbenchButtonBar = class WorkbenchButtonBar extends ButtonBar {
+    constructor(container, _options, _contextMenuService, _keybindingService, telemetryService, _hoverService) {
+        super(container);
+        this._options = _options;
+        this._contextMenuService = _contextMenuService;
+        this._keybindingService = _keybindingService;
+        this._hoverService = _hoverService;
+        this._store = ( new DisposableStore());
+        this._updateStore = ( new DisposableStore());
+        this._onDidChange = ( new Emitter());
+        this.onDidChange = this._onDidChange.event;
+        this._actionRunner = this._store.add(( new ActionRunner()));
+        if (_options?.telemetrySource) {
+            this._actionRunner.onDidRun(e => {
+                telemetryService.publicLog2('workbenchActionExecuted', { id: e.action.id, from: _options.telemetrySource });
+            }, undefined, this._store);
+        }
+    }
+    dispose() {
+        this._onDidChange.dispose();
+        this._updateStore.dispose();
+        this._store.dispose();
+        super.dispose();
+    }
+    update(actions, secondary) {
+        const conifgProvider = this._options?.buttonConfigProvider ?? (() => ({ showLabel: true }));
+        this._updateStore.clear();
+        this.clear();
+        const hoverDelegate = this._updateStore.add(createInstantHoverDelegate());
+        for (let i = 0; i < actions.length; i++) {
+            const secondary = i > 0;
+            const actionOrSubmenu = actions[i];
+            let action;
+            let btn;
+            let tooltip = '';
+            const kb = actionOrSubmenu instanceof SubmenuAction ? '' : this._keybindingService.lookupKeybinding(actionOrSubmenu.id);
+            if (kb) {
+                tooltip = ( localize(
+                    1750,
+                    "{0} ({1})",
+                    actionOrSubmenu.tooltip || actionOrSubmenu.label,
+                    kb.getLabel()
+                ));
+            }
+            else {
+                tooltip = actionOrSubmenu.tooltip || actionOrSubmenu.label;
+            }
+            if (actionOrSubmenu instanceof SubmenuAction && actionOrSubmenu.actions.length > 0) {
+                const [first, ...rest] = actionOrSubmenu.actions;
+                action = first;
+                btn = this.addButtonWithDropdown({
+                    secondary: conifgProvider(action, i)?.isSecondary ?? secondary,
+                    actionRunner: this._actionRunner,
+                    actions: rest,
+                    contextMenuProvider: this._contextMenuService,
+                    ariaLabel: tooltip,
+                    supportIcons: true,
+                });
+            }
+            else {
+                action = actionOrSubmenu;
+                btn = this.addButton({
+                    secondary: conifgProvider(action, i)?.isSecondary ?? secondary,
+                    ariaLabel: tooltip,
+                    supportIcons: true,
+                });
+            }
+            btn.enabled = action.enabled;
+            btn.checked = action.checked ?? false;
+            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');
+            }
+            if (conifgProvider(action, i)?.showIcon) {
+                if (action instanceof MenuItemAction && ThemeIcon.isThemeIcon(action.item.icon)) {
+                    if (!showLabel) {
+                        btn.icon = action.item.icon;
+                    }
+                    else {
+                        btn.label = `$(${action.item.icon.id}) ${action.label}`;
+                    }
+                }
+                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 (secondary.length > 0) {
+            const btn = this.addButton({
+                secondary: true,
+                ariaLabel: ( localize(1751, "More Actions"))
+            });
+            btn.icon = Codicon.dropDownButton;
+            btn.element.classList.add('default-colors', 'monaco-text-button');
+            btn.enabled = true;
+            this._updateStore.add(this._hoverService.setupManagedHover(hoverDelegate, btn.element, ( localize(1751, "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')
+                });
+                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));
+let MenuWorkbenchButtonBar = class MenuWorkbenchButtonBar extends WorkbenchButtonBar {
+    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);
+            super.update(actions.primary, actions.secondary);
+        };
+        this._store.add(menu.onDidChange(update));
+        update();
+    }
+    dispose() {
+        super.dispose();
+    }
+    update(_actions) {
+        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));
+
+export { MenuWorkbenchButtonBar, WorkbenchButtonBar };

package/vscode/src/vs/platform/editor/browser/editor.d.ts

@@ -0,0 +1,12 @@
+import { StandardKeyboardEvent } from "@codingame/monaco-vscode-api/vscode/vs/base/browser/keyboardEvent";
+import { StandardMouseEvent } from "@codingame/monaco-vscode-api/vscode/vs/base/browser/mouseEvent";
+import { IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IEditorOptions } from "@codingame/monaco-vscode-api/vscode/vs/platform/editor/common/editor";
+export interface IOpenEditorOptions {
+    readonly editorOptions: IEditorOptions;
+    readonly openToSide: boolean;
+}
+export declare function registerOpenEditorListeners(element: HTMLElement, onOpenEditor: (options: IOpenEditorOptions) => void): IDisposable;
+export declare function toOpenEditorOptions(event: StandardMouseEvent, isDoubleClick?: boolean): IOpenEditorOptions;
+export declare function toOpenEditorOptions(event: StandardKeyboardEvent): IOpenEditorOptions | undefined;
+export declare function toOpenEditorOptions(event: StandardMouseEvent | StandardKeyboardEvent): IOpenEditorOptions | undefined;

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

@@ -0,0 +1,51 @@
+
+import { addDisposableListener, EventType, EventHelper, getWindow } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { StandardKeyboardEvent } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/keyboardEvent';
+import { StandardMouseEvent } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/mouseEvent';
+import { KeyCode, KeyMod } from '@codingame/monaco-vscode-api/vscode/vs/base/common/keyCodes';
+import { DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { isMacintosh } from '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
+
+function registerOpenEditorListeners(element, onOpenEditor) {
+    const disposables = ( new DisposableStore());
+    disposables.add(addDisposableListener(element, EventType.CLICK, e => {
+        if (e.detail === 2) {
+            return;
+        }
+        EventHelper.stop(e, true);
+        onOpenEditor(toOpenEditorOptions(( new StandardMouseEvent(getWindow(element), e))));
+    }));
+    disposables.add(addDisposableListener(element, EventType.DBLCLICK, e => {
+        EventHelper.stop(e, true);
+        onOpenEditor(toOpenEditorOptions(( new StandardMouseEvent(getWindow(element), e)), true));
+    }));
+    disposables.add(addDisposableListener(element, EventType.KEY_DOWN, e => {
+        const options = toOpenEditorOptions(( new StandardKeyboardEvent(e)));
+        if (!options) {
+            return;
+        }
+        EventHelper.stop(e, true);
+        onOpenEditor(options);
+    }));
+    return disposables;
+}
+function toOpenEditorOptions(event, isDoubleClick) {
+    if (event instanceof StandardKeyboardEvent) {
+        let preserveFocus = undefined;
+        if (event.equals(KeyCode.Enter) || (isMacintosh && event.equals(KeyMod.CtrlCmd | KeyCode.DownArrow))) {
+            preserveFocus = false;
+        }
+        else if (event.equals(KeyCode.Space)) {
+            preserveFocus = true;
+        }
+        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 };
+    }
+}
+
+export { registerOpenEditorListeners, toOpenEditorOptions };

package/vscode/src/vs/workbench/contrib/chat/browser/actions/chatContinueInAction.d.ts

@@ -0,0 +1,41 @@
+import { Disposable, IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { ActionWidgetDropdownActionViewItem } from "../../../../../platform/actions/browser/actionWidgetDropdownActionViewItem.js";
+import { IActionViewItemService } from "@codingame/monaco-vscode-api/vscode/vs/platform/actions/browser/actionViewItemService.service";
+import { Action2, MenuItemAction } from "@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions";
+import { IActionWidgetService } from "@codingame/monaco-vscode-api/vscode/vs/platform/actionWidget/browser/actionWidget.service";
+import { IContextKeyService } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { IKeybindingService } from "@codingame/monaco-vscode-api/vscode/vs/platform/keybinding/common/keybinding.service";
+import { IOpenerService } from "@codingame/monaco-vscode-api/vscode/vs/platform/opener/common/opener.service";
+import { IWorkbenchContribution } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions";
+import { IChatSessionsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService.service";
+export declare enum ActionLocation {
+    ChatWidget = "chatWidget",
+    Editor = "editor"
+}
+export declare class ContinueChatInSessionAction extends Action2 {
+    static readonly ID = "workbench.action.chat.continueChatInSession";
+    constructor();
+    run(): Promise<void>;
+}
+export declare class ChatContinueInSessionActionItem extends ActionWidgetDropdownActionViewItem {
+    private readonly location;
+    private readonly contextKeyService;
+    constructor(action: MenuItemAction, location: ActionLocation, actionWidgetService: IActionWidgetService, contextKeyService: IContextKeyService, keybindingService: IKeybindingService, chatSessionsService: IChatSessionsService, instantiationService: IInstantiationService, openerService: IOpenerService);
+    protected static getActionBarActions(openerService: IOpenerService): {
+        id: string;
+        label: string;
+        tooltip: string;
+        class: undefined;
+        enabled: boolean;
+        run: () => Promise<void>;
+    }[];
+    private static actionProvider;
+    private static toAction;
+    private static toSetupAction;
+    protected renderLabel(element: HTMLElement): IDisposable | null;
+}
+export declare class ContinueChatInSessionActionRendering extends Disposable implements IWorkbenchContribution {
+    static readonly ID = "chat.continueChatInSessionActionRendering";
+    constructor(actionViewItemService: IActionViewItemService, instantiationService: IInstantiationService);
+}