@codingame/monaco-vscode-api 1.78.8 → 1.79.0

package/dist/vscode/vs/workbench/browser/parts/panel/panelActions.js

@@ -0,0 +1,381 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import "../../../../../../assets/panelpart.css";
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { registerAction2, Action2, MenuRegistry, MenuId } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { Categories } from 'monaco-editor/esm/vs/platform/action/common/actionCommonCategories.js';
+import { IWorkbenchLayoutService, positionToString } from '../../../services/layout/browser/layoutService.js';
+import { ActivityAction, ToggleCompositePinnedAction } from '../compositeBarActions.js';
+import { AuxiliaryBarVisibleContext, PanelVisibleContext, PanelPositionContext, PanelAlignmentContext } from '../../../common/contextkeys.js';
+import { ContextKeyExpr } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
+import { registerIcon } from 'monaco-editor/esm/vs/platform/theme/common/iconRegistry.js';
+import { ViewContainerLocationToString, IViewDescriptorService, IViewsService } from '../../../common/views.js';
+import { IPaneCompositePartService } from '../../../services/panecomposite/browser/panecomposite.js';
+var _a;
+const closeIcon = ( registerIcon('panel-close', Codicon.close, ( localize('closeIcon', 'Icon to close a panel.'))));
+const panelIcon = ( registerIcon('panel-layout-icon', Codicon.layoutPanel, ( localize('togglePanelOffIcon', 'Icon to toggle the panel off when it is on.'))));
+const panelOffIcon = ( registerIcon('panel-layout-icon-off', Codicon.layoutPanelOff, ( localize('togglePanelOnIcon', 'Icon to toggle the panel on when it is off.'))));
+class TogglePanelAction extends Action2 {
+    constructor() {
+        super({
+            id: TogglePanelAction.ID,
+            title: { value: TogglePanelAction.LABEL, original: 'Toggle Panel Visibility' },
+            toggled: {
+                condition: PanelVisibleContext,
+                title: ( localize('toggle panel', "Panel")),
+                mnemonicTitle: ( localize(
+                    { key: 'toggle panel mnemonic', comment: ['&& denotes a mnemonic'] },
+                    "&&Panel"
+                )),
+            },
+            f1: true,
+            category: Categories.View,
+            keybinding: { primary: 2048  | 40 , weight: 200  },
+            menu: [
+                {
+                    id: MenuId.MenubarAppearanceMenu,
+                    group: '2_workbench_layout',
+                    order: 5
+                }, {
+                    id: MenuId.LayoutControlMenuSubmenu,
+                    group: '0_workbench_layout',
+                    order: 4
+                },
+            ]
+        });
+    }
+    async run(accessor) {
+        const layoutService = accessor.get(IWorkbenchLayoutService);
+        layoutService.setPartHidden(layoutService.isVisible("workbench.parts.panel" ), "workbench.parts.panel" );
+    }
+}
+TogglePanelAction.ID = 'workbench.action.togglePanel';
+TogglePanelAction.LABEL = ( localize('togglePanelVisibility', "Toggle Panel Visibility"));
+registerAction2(TogglePanelAction);
+registerAction2((_a = class extends Action2 {
+        constructor() {
+            super({
+                id: 'workbench.action.focusPanel',
+                title: { value: ( localize('focusPanel', "Focus into Panel")), original: 'Focus into Panel' },
+                category: Categories.View,
+                f1: true,
+            });
+        }
+        async run(accessor) {
+            const layoutService = accessor.get(IWorkbenchLayoutService);
+            const paneCompositeService = accessor.get(IPaneCompositePartService);
+            if (!layoutService.isVisible("workbench.parts.panel" )) {
+                layoutService.setPartHidden(false, "workbench.parts.panel" );
+            }
+            const panel = paneCompositeService.getActivePaneComposite(1 );
+            panel?.focus();
+        }
+    },
+    _a.ID = 'workbench.action.focusPanel',
+    _a.LABEL = ( localize('focusPanel', "Focus into Panel")),
+    _a));
+const PositionPanelActionId = {
+    LEFT: 'workbench.action.positionPanelLeft',
+    RIGHT: 'workbench.action.positionPanelRight',
+    BOTTOM: 'workbench.action.positionPanelBottom',
+};
+const AlignPanelActionId = {
+    LEFT: 'workbench.action.alignPanelLeft',
+    RIGHT: 'workbench.action.alignPanelRight',
+    CENTER: 'workbench.action.alignPanelCenter',
+    JUSTIFY: 'workbench.action.alignPanelJustify',
+};
+function createPanelActionConfig(id, title, shortLabel, value, when) {
+    return {
+        id,
+        title,
+        shortLabel,
+        value,
+        when,
+    };
+}
+function createPositionPanelActionConfig(id, title, shortLabel, position) {
+    return createPanelActionConfig(id, title, shortLabel, position, ( PanelPositionContext.notEqualsTo(positionToString(position))));
+}
+function createAlignmentPanelActionConfig(id, title, shortLabel, alignment) {
+    return createPanelActionConfig(id, title, shortLabel, alignment, ( PanelAlignmentContext.notEqualsTo(alignment)));
+}
+const PositionPanelActionConfigs = [
+    createPositionPanelActionConfig(PositionPanelActionId.LEFT, { value: ( localize('positionPanelLeft', 'Move Panel Left')), original: 'Move Panel Left' }, ( localize('positionPanelLeftShort', "Left")), 0 ),
+    createPositionPanelActionConfig(PositionPanelActionId.RIGHT, { value: ( localize('positionPanelRight', 'Move Panel Right')), original: 'Move Panel Right' }, ( localize('positionPanelRightShort', "Right")), 1 ),
+    createPositionPanelActionConfig(PositionPanelActionId.BOTTOM, { value: ( localize('positionPanelBottom', 'Move Panel To Bottom')), original: 'Move Panel To Bottom' }, ( localize('positionPanelBottomShort', "Bottom")), 2 ),
+];
+const AlignPanelActionConfigs = [
+    createAlignmentPanelActionConfig(AlignPanelActionId.LEFT, { value: ( localize('alignPanelLeft', 'Set Panel Alignment to Left')), original: 'Set Panel Alignment to Left' }, ( localize('alignPanelLeftShort', "Left")), 'left'),
+    createAlignmentPanelActionConfig(AlignPanelActionId.RIGHT, { value: ( localize('alignPanelRight', 'Set Panel Alignment to Right')), original: 'Set Panel Alignment to Right' }, ( localize('alignPanelRightShort', "Right")), 'right'),
+    createAlignmentPanelActionConfig(AlignPanelActionId.CENTER, { value: ( localize('alignPanelCenter', 'Set Panel Alignment to Center')), original: 'Set Panel Alignment to Center' }, ( localize('alignPanelCenterShort', "Center")), 'center'),
+    createAlignmentPanelActionConfig(AlignPanelActionId.JUSTIFY, { value: ( localize('alignPanelJustify', 'Set Panel Alignment to Justify')), original: 'Set Panel Alignment to Justify' }, ( localize('alignPanelJustifyShort', "Justify")), 'justify'),
+];
+PositionPanelActionConfigs.forEach(positionPanelAction => {
+    const { id, title, shortLabel, value, when } = positionPanelAction;
+    registerAction2(class extends Action2 {
+        constructor() {
+            super({
+                id,
+                title,
+                category: Categories.View,
+                f1: true
+            });
+        }
+        run(accessor) {
+            const layoutService = accessor.get(IWorkbenchLayoutService);
+            layoutService.setPanelPosition(value === undefined ? 2  : value);
+        }
+    });
+    MenuRegistry.appendMenuItem(MenuId.PanelPositionMenu, {
+        command: {
+            id,
+            title: shortLabel,
+            toggled: ( when.negate())
+        },
+        order: 5
+    });
+});
+AlignPanelActionConfigs.forEach(alignPanelAction => {
+    const { id, title, shortLabel, value, when } = alignPanelAction;
+    registerAction2(class extends Action2 {
+        constructor() {
+            super({
+                id,
+                title: title,
+                category: Categories.View,
+                toggled: ( when.negate()),
+                f1: true
+            });
+        }
+        run(accessor) {
+            const layoutService = accessor.get(IWorkbenchLayoutService);
+            layoutService.setPanelAlignment(value === undefined ? 'center' : value);
+        }
+    });
+    MenuRegistry.appendMenuItem(MenuId.PanelAlignmentMenu, {
+        command: {
+            id,
+            title: shortLabel,
+            toggled: ( when.negate())
+        },
+        order: 5
+    });
+});
+let PanelActivityAction = class PanelActivityAction extends ActivityAction {
+    constructor(activity, viewContainerLocation, paneCompositeService) {
+        super(activity);
+        this.viewContainerLocation = viewContainerLocation;
+        this.paneCompositeService = paneCompositeService;
+    }
+    async run() {
+        await this.paneCompositeService.openPaneComposite(this.activity.id, this.viewContainerLocation, true);
+        this.activate();
+    }
+    setActivity(activity) {
+        this.activity = activity;
+    }
+};
+PanelActivityAction = ( __decorate([
+    ( __param(2, IPaneCompositePartService))
+], PanelActivityAction));
+let PlaceHolderPanelActivityAction = class PlaceHolderPanelActivityAction extends PanelActivityAction {
+    constructor(id, viewContainerLocation, paneCompositeService) {
+        super({ id, name: id }, viewContainerLocation, paneCompositeService);
+    }
+};
+PlaceHolderPanelActivityAction = ( __decorate([
+    ( __param(2, IPaneCompositePartService))
+], PlaceHolderPanelActivityAction));
+class PlaceHolderToggleCompositePinnedAction extends ToggleCompositePinnedAction {
+    constructor(id, compositeBar) {
+        super({ id, name: id, classNames: undefined }, compositeBar);
+    }
+    setActivity(activity) {
+        this.label = activity.name;
+    }
+}
+class SwitchPanelViewAction extends Action2 {
+    constructor(id, title) {
+        super({
+            id,
+            title,
+            category: Categories.View,
+            f1: true,
+        });
+    }
+    async run(accessor, offset) {
+        const paneCompositeService = accessor.get(IPaneCompositePartService);
+        const pinnedPanels = paneCompositeService.getPinnedPaneCompositeIds(1 );
+        const activePanel = paneCompositeService.getActivePaneComposite(1 );
+        if (!activePanel) {
+            return;
+        }
+        let targetPanelId;
+        for (let i = 0; i < pinnedPanels.length; i++) {
+            if (pinnedPanels[i] === activePanel.getId()) {
+                targetPanelId = pinnedPanels[(i + pinnedPanels.length + offset) % pinnedPanels.length];
+                break;
+            }
+        }
+        if (typeof targetPanelId === 'string') {
+            await paneCompositeService.openPaneComposite(targetPanelId, 1 , true);
+        }
+    }
+}
+registerAction2(class extends SwitchPanelViewAction {
+    constructor() {
+        super('workbench.action.previousPanelView', {
+            value: ( localize('previousPanelView', 'Previous Panel View')),
+            original: 'Previous Panel View'
+        });
+    }
+    run(accessor) {
+        return super.run(accessor, -1);
+    }
+});
+registerAction2(class extends SwitchPanelViewAction {
+    constructor() {
+        super('workbench.action.nextPanelView', {
+            value: ( localize('nextPanelView', 'Next Panel View')),
+            original: 'Next Panel View'
+        });
+    }
+    run(accessor) {
+        return super.run(accessor, 1);
+    }
+});
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: 'workbench.action.closeAuxiliaryBar',
+            title: { value: ( localize('closeSecondarySideBar', "Close Secondary Side Bar")), original: 'Close Secondary Side Bar' },
+            category: Categories.View,
+            icon: closeIcon,
+            menu: [{
+                    id: MenuId.CommandPalette,
+                    when: AuxiliaryBarVisibleContext,
+                }, {
+                    id: MenuId.AuxiliaryBarTitle,
+                    group: 'navigation',
+                    order: 2
+                }]
+        });
+    }
+    run(accessor) {
+        accessor.get(IWorkbenchLayoutService).setPartHidden(true, "workbench.parts.auxiliarybar" );
+    }
+});
+MenuRegistry.appendMenuItems([
+    {
+        id: MenuId.LayoutControlMenu,
+        item: {
+            group: '0_workbench_toggles',
+            command: {
+                id: TogglePanelAction.ID,
+                title: ( localize('togglePanel', "Toggle Panel")),
+                icon: panelOffIcon,
+                toggled: { condition: PanelVisibleContext, icon: panelIcon }
+            },
+            when: ( ContextKeyExpr.or(( ContextKeyExpr.equals('config.workbench.layoutControl.type', 'toggles')), ( ContextKeyExpr.equals('config.workbench.layoutControl.type', 'both')))),
+            order: 1
+        }
+    }, {
+        id: MenuId.ViewTitleContext,
+        item: {
+            group: '3_workbench_layout_move',
+            command: {
+                id: TogglePanelAction.ID,
+                title: { value: ( localize('hidePanel', "Hide Panel")), original: 'Hide Panel' },
+            },
+            when: ( ContextKeyExpr.and(PanelVisibleContext, ( ContextKeyExpr.equals(
+                'viewLocation',
+                ViewContainerLocationToString(1 )
+            )))),
+            order: 2
+        }
+    }
+]);
+class MoveViewsBetweenPanelsAction extends Action2 {
+    constructor(source, destination, desc) {
+        super(desc);
+        this.source = source;
+        this.destination = destination;
+    }
+    run(accessor, ...args) {
+        const viewDescriptorService = accessor.get(IViewDescriptorService);
+        const layoutService = accessor.get(IWorkbenchLayoutService);
+        const viewsService = accessor.get(IViewsService);
+        const srcContainers = viewDescriptorService.getViewContainersByLocation(this.source);
+        const destContainers = viewDescriptorService.getViewContainersByLocation(this.destination);
+        if (srcContainers.length) {
+            const activeViewContainer = viewsService.getVisibleViewContainer(this.source);
+            srcContainers.forEach(viewContainer => viewDescriptorService.moveViewContainerToLocation(viewContainer, this.destination));
+            layoutService.setPartHidden(false, this.destination === 1  ? "workbench.parts.panel"  : "workbench.parts.auxiliarybar" );
+            if (activeViewContainer && destContainers.length === 0) {
+                viewsService.openViewContainer(activeViewContainer.id, true);
+            }
+        }
+    }
+}
+class MovePanelToSidePanelAction extends MoveViewsBetweenPanelsAction {
+    constructor() {
+        super(1 , 2 , {
+            id: MovePanelToSidePanelAction.ID,
+            title: {
+                value: ( localize('movePanelToSecondarySideBar', "Move Panel Views To Secondary Side Bar")),
+                original: 'Move Panel Views To Secondary Side Bar'
+            },
+            category: Categories.View,
+            f1: false
+        });
+    }
+}
+MovePanelToSidePanelAction.ID = 'workbench.action.movePanelToSidePanel';
+class MovePanelToSecondarySideBarAction extends MoveViewsBetweenPanelsAction {
+    constructor() {
+        super(1 , 2 , {
+            id: MovePanelToSecondarySideBarAction.ID,
+            title: {
+                value: ( localize('movePanelToSecondarySideBar', "Move Panel Views To Secondary Side Bar")),
+                original: 'Move Panel Views To Secondary Side Bar'
+            },
+            category: Categories.View,
+            f1: true
+        });
+    }
+}
+MovePanelToSecondarySideBarAction.ID = 'workbench.action.movePanelToSecondarySideBar';
+registerAction2(MovePanelToSidePanelAction);
+registerAction2(MovePanelToSecondarySideBarAction);
+class MoveSidePanelToPanelAction extends MoveViewsBetweenPanelsAction {
+    constructor() {
+        super(2 , 1 , {
+            id: MoveSidePanelToPanelAction.ID,
+            title: {
+                value: ( localize('moveSidePanelToPanel', "Move Secondary Side Bar Views To Panel")),
+                original: 'Move Secondary Side Bar Views To Panel'
+            },
+            category: Categories.View,
+            f1: false
+        });
+    }
+}
+MoveSidePanelToPanelAction.ID = 'workbench.action.moveSidePanelToPanel';
+class MoveSecondarySideBarToPanelAction extends MoveViewsBetweenPanelsAction {
+    constructor() {
+        super(2 , 1 , {
+            id: MoveSecondarySideBarToPanelAction.ID,
+            title: {
+                value: ( localize('moveSidePanelToPanel', "Move Secondary Side Bar Views To Panel")),
+                original: 'Move Secondary Side Bar Views To Panel'
+            },
+            category: Categories.View,
+            f1: true
+        });
+    }
+}
+MoveSecondarySideBarToPanelAction.ID = 'workbench.action.moveSecondarySideBarToPanel';
+registerAction2(MoveSidePanelToPanelAction);
+registerAction2(MoveSecondarySideBarToPanelAction);
+export { MovePanelToSecondarySideBarAction, MoveSecondarySideBarToPanelAction, PanelActivityAction, PlaceHolderPanelActivityAction, PlaceHolderToggleCompositePinnedAction, TogglePanelAction };