@codingame/monaco-vscode-api 1.78.6-next.0 → 1.78.7

package/dist/vscode/vs/workbench/browser/parts/titlebar/menubarControl.js

@@ -1,600 +0,0 @@
-import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
-import "../../../../../../assets/menubarControl.css";
-import { localize } from 'monaco-editor/esm/vs/nls.js';
-import { MenuId, SubmenuItemAction, registerAction2, Action2, MenuItemAction, IMenuService } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
-import { getMenuBarVisibility, getTitleBarStyle } from '../../../../platform/window/common/window.js';
-import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
-import { Separator, Action, ActionRunner, SubmenuAction } from 'monaco-editor/esm/vs/base/common/actions.js';
-import { addDisposableListener, EventType, Dimension } from 'monaco-editor/esm/vs/base/browser/dom.js';
-import { IKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/common/keybinding.js';
-import { isMacintosh, isNative, isWeb, isIOS } from 'monaco-editor/esm/vs/base/common/platform.js';
-import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
-import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
-import { Disposable, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { isRecentFolder, isRecentWorkspace, IWorkspacesService } from '../../../../platform/workspaces/common/workspaces.js';
-import { RunOnceScheduler } from 'monaco-editor/esm/vs/base/common/async.js';
-import { ILabelService } from 'monaco-editor/esm/vs/platform/label/common/label.js';
-import { IUpdateService } from '../../../../platform/update/common/update.js';
-import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
-import { Severity, INotificationService } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
-import { IPreferencesService } from '../../../services/preferences/common/preferences.js';
-import { IWorkbenchEnvironmentService } from '../../../services/environment/common/environmentService.js';
-import { MenuBar } from '../../../../base/browser/ui/menu/menubar.js';
-import { Direction } from 'monaco-editor/esm/vs/base/browser/ui/menu/menu.js';
-import { unmnemonicLabel, mnemonicMenuLabel } from 'monaco-editor/esm/vs/base/common/labels.js';
-import { IAccessibilityService } from 'monaco-editor/esm/vs/platform/accessibility/common/accessibility.js';
-import { IWorkbenchLayoutService } from '../../../services/layout/browser/layoutService.js';
-import { isFullscreen } from 'monaco-editor/esm/vs/base/browser/browser.js';
-import { IHostService } from '../../../services/host/browser/host.js';
-import { BrowserFeatures } from 'monaco-editor/esm/vs/base/browser/canIUse.js';
-import { IsWebContext } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkeys.js';
-import { ICommandService } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
-import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
-import { OpenRecentAction } from '../../actions/windowActions.js';
-import { isICommandActionToggleInfo } from 'monaco-editor/esm/vs/platform/action/common/action.js';
-import { createAndFillInContextMenuActions } from 'monaco-editor/esm/vs/platform/actions/browser/menuEntryActionViewItem.js';
-import { defaultMenuStyles } from 'monaco-editor/esm/vs/platform/theme/browser/defaultStyles.js';
-class MenubarControl extends Disposable {
-    constructor(menuService, workspacesService, contextKeyService, keybindingService, configurationService, labelService, updateService, storageService, notificationService, preferencesService, environmentService, accessibilityService, hostService, commandService) {
-        super();
-        this.menuService = menuService;
-        this.workspacesService = workspacesService;
-        this.contextKeyService = contextKeyService;
-        this.keybindingService = keybindingService;
-        this.configurationService = configurationService;
-        this.labelService = labelService;
-        this.updateService = updateService;
-        this.storageService = storageService;
-        this.notificationService = notificationService;
-        this.preferencesService = preferencesService;
-        this.environmentService = environmentService;
-        this.accessibilityService = accessibilityService;
-        this.hostService = hostService;
-        this.commandService = commandService;
-        this.keys = [
-            'window.menuBarVisibility',
-            'window.enableMenuBarMnemonics',
-            'window.customMenuBarAltFocus',
-            'workbench.sideBar.location',
-            'window.nativeTabs'
-        ];
-        this.menus = {};
-        this.topLevelTitles = {};
-        this.recentlyOpened = { files: [], workspaces: [] };
-        this.mainMenu = this._register(this.menuService.createMenu(MenuId.MenubarMainMenu, this.contextKeyService));
-        this.mainMenuDisposables = this._register(( new DisposableStore()));
-        this.setupMainMenu();
-        this.menuUpdater = this._register(( new RunOnceScheduler(() => this.doUpdateMenubar(false), 200)));
-        this.notifyUserOfCustomMenubarAccessibility();
-    }
-    registerListeners() {
-        this._register(this.hostService.onDidChangeFocus(e => this.onDidChangeWindowFocus(e)));
-        this._register(this.configurationService.onDidChangeConfiguration(e => this.onConfigurationUpdated(e)));
-        this.updateService.onStateChange(() => this.onUpdateStateChange());
-        this._register(this.workspacesService.onDidChangeRecentlyOpened(() => { this.onDidChangeRecentlyOpened(); }));
-        this._register(this.keybindingService.onDidUpdateKeybindings(() => this.updateMenubar()));
-        this._register(this.labelService.onDidChangeFormatters(() => { this.onDidChangeRecentlyOpened(); }));
-        this._register(this.mainMenu.onDidChange(() => { this.setupMainMenu(); this.doUpdateMenubar(true); }));
-    }
-    setupMainMenu() {
-        this.mainMenuDisposables.clear();
-        this.menus = {};
-        this.topLevelTitles = {};
-        const [, mainMenuActions] = this.mainMenu.getActions()[0];
-        for (const mainMenuAction of mainMenuActions) {
-            if (mainMenuAction instanceof SubmenuItemAction && typeof mainMenuAction.item.title !== 'string') {
-                this.menus[mainMenuAction.item.title.original] = this.mainMenuDisposables.add(this.menuService.createMenu(mainMenuAction.item.submenu, this.contextKeyService, { emitEventsForSubmenuChanges: true }));
-                this.topLevelTitles[mainMenuAction.item.title.original] = mainMenuAction.item.title.mnemonicTitle ?? mainMenuAction.item.title.value;
-            }
-        }
-    }
-    updateMenubar() {
-        this.menuUpdater.schedule();
-    }
-    calculateActionLabel(action) {
-        const label = action.label;
-        return label;
-    }
-    onUpdateStateChange() {
-        this.updateMenubar();
-    }
-    onUpdateKeybindings() {
-        this.updateMenubar();
-    }
-    getOpenRecentActions() {
-        if (!this.recentlyOpened) {
-            return [];
-        }
-        const { workspaces, files } = this.recentlyOpened;
-        const result = [];
-        if (workspaces.length > 0) {
-            for (let i = 0; i < MenubarControl.MAX_MENU_RECENT_ENTRIES && i < workspaces.length; i++) {
-                result.push(this.createOpenRecentMenuAction(workspaces[i]));
-            }
-            result.push(( new Separator()));
-        }
-        if (files.length > 0) {
-            for (let i = 0; i < MenubarControl.MAX_MENU_RECENT_ENTRIES && i < files.length; i++) {
-                result.push(this.createOpenRecentMenuAction(files[i]));
-            }
-            result.push(( new Separator()));
-        }
-        return result;
-    }
-    onDidChangeWindowFocus(hasFocus) {
-        if (hasFocus) {
-            this.onDidChangeRecentlyOpened();
-        }
-    }
-    onConfigurationUpdated(event) {
-        if (( this.keys.some(key => event.affectsConfiguration(key)))) {
-            this.updateMenubar();
-        }
-        if (event.affectsConfiguration('editor.accessibilitySupport')) {
-            this.notifyUserOfCustomMenubarAccessibility();
-        }
-        if (event.affectsConfiguration('window.menuBarVisibility')) {
-            this.onDidChangeRecentlyOpened();
-        }
-    }
-    get menubarHidden() {
-        return isMacintosh && isNative ? false : getMenuBarVisibility(this.configurationService) === 'hidden';
-    }
-    onDidChangeRecentlyOpened() {
-        if (!this.menubarHidden) {
-            this.workspacesService.getRecentlyOpened().then(recentlyOpened => {
-                this.recentlyOpened = recentlyOpened;
-                this.updateMenubar();
-            });
-        }
-    }
-    createOpenRecentMenuAction(recent) {
-        let label;
-        let uri;
-        let commandId;
-        let openable;
-        const remoteAuthority = recent.remoteAuthority;
-        if (isRecentFolder(recent)) {
-            uri = recent.folderUri;
-            label = recent.label || this.labelService.getWorkspaceLabel(uri, { verbose: 2  });
-            commandId = 'openRecentFolder';
-            openable = { folderUri: uri };
-        }
-        else if (isRecentWorkspace(recent)) {
-            uri = recent.workspace.configPath;
-            label = recent.label || this.labelService.getWorkspaceLabel(recent.workspace, { verbose: 2  });
-            commandId = 'openRecentWorkspace';
-            openable = { workspaceUri: uri };
-        }
-        else {
-            uri = recent.fileUri;
-            label = recent.label || this.labelService.getUriLabel(uri);
-            commandId = 'openRecentFile';
-            openable = { fileUri: uri };
-        }
-        const ret = ( new Action(commandId, unmnemonicLabel(label), undefined, undefined, event => {
-            const browserEvent = event;
-            const openInNewWindow = event && ((!isMacintosh && (browserEvent.ctrlKey || browserEvent.shiftKey)) || (isMacintosh && (browserEvent.metaKey || browserEvent.altKey)));
-            return this.hostService.openWindow([openable], {
-                forceNewWindow: !!openInNewWindow,
-                remoteAuthority: remoteAuthority || null
-            });
-        }));
-        return Object.assign(ret, { uri, remoteAuthority });
-    }
-    notifyUserOfCustomMenubarAccessibility() {
-        if (isWeb || isMacintosh) {
-            return;
-        }
-        const hasBeenNotified = this.storageService.getBoolean('menubar/accessibleMenubarNotified', -1 , false);
-        const usingCustomMenubar = getTitleBarStyle(this.configurationService) === 'custom';
-        if (hasBeenNotified || usingCustomMenubar || !this.accessibilityService.isScreenReaderOptimized()) {
-            return;
-        }
-        const message = ( localize(
-            'menubar.customTitlebarAccessibilityNotification',
-            "Accessibility support is enabled for you. For the most accessible experience, we recommend the custom title bar style."
-        ));
-        this.notificationService.prompt(Severity.Info, message, [
-            {
-                label: ( localize('goToSetting', "Open Settings")),
-                run: () => {
-                    return this.preferencesService.openUserSettings({ query: 'window.titleBarStyle' });
-                }
-            }
-        ]);
-        this.storageService.store('menubar/accessibleMenubarNotified', true, -1 , 0 );
-    }
-}
-MenubarControl.MAX_MENU_RECENT_ENTRIES = 10;
-let CustomMenubarControl = class CustomMenubarControl extends MenubarControl {
-    constructor(menuService, workspacesService, contextKeyService, keybindingService, configurationService, labelService, updateService, storageService, notificationService, preferencesService, environmentService, accessibilityService, layoutService, telemetryService, hostService, commandService) {
-        super(menuService, workspacesService, contextKeyService, keybindingService, configurationService, labelService, updateService, storageService, notificationService, preferencesService, environmentService, accessibilityService, hostService, commandService);
-        this.layoutService = layoutService;
-        this.telemetryService = telemetryService;
-        this.alwaysOnMnemonics = false;
-        this.focusInsideMenubar = false;
-        this.pendingFirstTimeUpdate = false;
-        this.visible = true;
-        this.webNavigationMenu = this._register(this.menuService.createMenu(MenuId.MenubarHomeMenu, this.contextKeyService));
-        this.reinstallDisposables = this._register(( new DisposableStore()));
-        this._onVisibilityChange = this._register(( new Emitter()));
-        this._onFocusStateChange = this._register(( new Emitter()));
-        this.actionRunner = this._register(( new ActionRunner()));
-        this.actionRunner.onDidRun(e => {
-            this.telemetryService.publicLog2('workbenchActionExecuted', { id: e.action.id, from: 'menu' });
-        });
-        this.workspacesService.getRecentlyOpened().then((recentlyOpened) => {
-            this.recentlyOpened = recentlyOpened;
-        });
-        this.registerListeners();
-        this.registerActions();
-    }
-    doUpdateMenubar(firstTime) {
-        if (!this.focusInsideMenubar) {
-            this.setupCustomMenubar(firstTime);
-        }
-        if (firstTime) {
-            this.pendingFirstTimeUpdate = true;
-        }
-    }
-    registerActions() {
-        const that = this;
-        if (isWeb) {
-            this._register(registerAction2(class extends Action2 {
-                constructor() {
-                    super({
-                        id: `workbench.actions.menubar.focus`,
-                        title: { value: ( localize('focusMenu', "Focus Application Menu")), original: 'Focus Application Menu' },
-                        keybinding: {
-                            primary: 68 ,
-                            weight: 200 ,
-                            when: IsWebContext
-                        },
-                        f1: true
-                    });
-                }
-                async run() {
-                    that.menubar?.toggleFocus();
-                }
-            }));
-        }
-    }
-    getUpdateAction() {
-        const state = this.updateService.state;
-        switch (state.type) {
-            case "uninitialized" :
-                return null;
-            case "idle" :
-                return ( new Action('update.check', ( localize(
-                    { key: 'checkForUpdates', comment: ['&& denotes a mnemonic'] },
-                    "Check for &&Updates..."
-                )), undefined, true, () => this.updateService.checkForUpdates(true)));
-            case "checking for updates" :
-                return ( new Action('update.checking', ( localize('checkingForUpdates', "Checking for Updates...")), undefined, false));
-            case "available for download" :
-                return ( new Action('update.downloadNow', ( localize(
-                    { key: 'download now', comment: ['&& denotes a mnemonic'] },
-                    "D&&ownload Update"
-                )), undefined, true, () => this.updateService.downloadUpdate()));
-            case "downloading" :
-                return ( new Action('update.downloading', ( localize('DownloadingUpdate', "Downloading Update...")), undefined, false));
-            case "downloaded" :
-                return ( new Action('update.install', ( localize(
-                    { key: 'installUpdate...', comment: ['&& denotes a mnemonic'] },
-                    "Install &&Update..."
-                )), undefined, true, () => this.updateService.applyUpdate()));
-            case "updating" :
-                return ( new Action('update.updating', ( localize('installingUpdate', "Installing Update...")), undefined, false));
-            case "ready" :
-                return ( new Action('update.restart', ( localize(
-                    { key: 'restartToUpdate', comment: ['&& denotes a mnemonic'] },
-                    "Restart to &&Update"
-                )), undefined, true, () => this.updateService.quitAndInstall()));
-        }
-    }
-    get currentMenubarVisibility() {
-        return getMenuBarVisibility(this.configurationService);
-    }
-    get currentDisableMenuBarAltFocus() {
-        const settingValue = this.configurationService.getValue('window.customMenuBarAltFocus');
-        let disableMenuBarAltBehavior = false;
-        if (typeof settingValue === 'boolean') {
-            disableMenuBarAltBehavior = !settingValue;
-        }
-        return disableMenuBarAltBehavior;
-    }
-    insertActionsBefore(nextAction, target) {
-        switch (nextAction.id) {
-            case OpenRecentAction.ID:
-                target.push(...this.getOpenRecentActions());
-                break;
-            case 'workbench.action.showAboutDialog':
-                if (!isMacintosh && !isWeb) {
-                    const updateAction = this.getUpdateAction();
-                    if (updateAction) {
-                        updateAction.label = mnemonicMenuLabel(updateAction.label);
-                        target.push(updateAction);
-                        target.push(( new Separator()));
-                    }
-                }
-                break;
-        }
-    }
-    get currentEnableMenuBarMnemonics() {
-        let enableMenuBarMnemonics = this.configurationService.getValue('window.enableMenuBarMnemonics');
-        if (typeof enableMenuBarMnemonics !== 'boolean') {
-            enableMenuBarMnemonics = true;
-        }
-        return enableMenuBarMnemonics && (!isWeb || isFullscreen());
-    }
-    get currentCompactMenuMode() {
-        if (this.currentMenubarVisibility !== 'compact') {
-            return undefined;
-        }
-        const currentSidebarLocation = this.configurationService.getValue('workbench.sideBar.location');
-        return currentSidebarLocation === 'right' ? Direction.Left : Direction.Right;
-    }
-    onDidVisibilityChange(visible) {
-        this.visible = visible;
-        this.onDidChangeRecentlyOpened();
-        this._onVisibilityChange.fire(visible);
-    }
-    toActionsArray(menu) {
-        const result = [];
-        createAndFillInContextMenuActions(menu, { shouldForwardArgs: true }, result);
-        return result;
-    }
-    setupCustomMenubar(firstTime) {
-        if (!this.container) {
-            return;
-        }
-        if (firstTime) {
-            if (this.menubar) {
-                this.reinstallDisposables.clear();
-            }
-            this.menubar = this.reinstallDisposables.add(( new MenuBar(this.container, this.getMenuBarOptions(), defaultMenuStyles)));
-            this.accessibilityService.alwaysUnderlineAccessKeys().then(val => {
-                this.alwaysOnMnemonics = val;
-                this.menubar?.update(this.getMenuBarOptions());
-            });
-            this.reinstallDisposables.add(this.menubar.onFocusStateChange(focused => {
-                this._onFocusStateChange.fire(focused);
-                if (!focused) {
-                    if (this.pendingFirstTimeUpdate) {
-                        this.setupCustomMenubar(true);
-                        this.pendingFirstTimeUpdate = false;
-                    }
-                    else {
-                        this.updateMenubar();
-                    }
-                    this.focusInsideMenubar = false;
-                }
-            }));
-            this.reinstallDisposables.add(this.menubar.onVisibilityChange(e => this.onDidVisibilityChange(e)));
-            this.reinstallDisposables.add(addDisposableListener(this.container, EventType.FOCUS_IN, () => {
-                this.focusInsideMenubar = true;
-            }));
-            this.reinstallDisposables.add(addDisposableListener(this.container, EventType.FOCUS_OUT, () => {
-                this.focusInsideMenubar = false;
-            }));
-            if (this.menubar.isVisible) {
-                this.onDidVisibilityChange(true);
-            }
-        }
-        else {
-            this.menubar?.update(this.getMenuBarOptions());
-        }
-        const updateActions = (menuActions, target, topLevelTitle) => {
-            target.splice(0);
-            for (const menuItem of menuActions) {
-                this.insertActionsBefore(menuItem, target);
-                if (menuItem instanceof Separator) {
-                    target.push(menuItem);
-                }
-                else if (menuItem instanceof SubmenuItemAction || menuItem instanceof MenuItemAction) {
-                    let title = typeof menuItem.item.title === 'string'
-                        ? menuItem.item.title
-                        : menuItem.item.title.mnemonicTitle ?? menuItem.item.title.value;
-                    if (menuItem instanceof SubmenuItemAction) {
-                        const submenuActions = [];
-                        updateActions(menuItem.actions, submenuActions, topLevelTitle);
-                        if (submenuActions.length > 0) {
-                            target.push(( new SubmenuAction(menuItem.id, mnemonicMenuLabel(title), submenuActions)));
-                        }
-                    }
-                    else {
-                        if (isICommandActionToggleInfo(menuItem.item.toggled)) {
-                            title = menuItem.item.toggled.mnemonicTitle ?? menuItem.item.toggled.title ?? title;
-                        }
-                        const newAction = ( new Action(
-                            menuItem.id,
-                            mnemonicMenuLabel(title),
-                            menuItem.class,
-                            menuItem.enabled,
-                            () => this.commandService.executeCommand(menuItem.id)
-                        ));
-                        newAction.tooltip = menuItem.tooltip;
-                        newAction.checked = menuItem.checked;
-                        target.push(newAction);
-                    }
-                }
-            }
-            if (topLevelTitle === 'File' && this.currentCompactMenuMode === undefined) {
-                const webActions = this.getWebNavigationActions();
-                if (webActions.length) {
-                    target.push(...webActions);
-                }
-            }
-        };
-        for (const title of ( Object.keys(this.topLevelTitles))) {
-            const menu = this.menus[title];
-            if (firstTime && menu) {
-                this.reinstallDisposables.add(menu.onDidChange(() => {
-                    if (!this.focusInsideMenubar) {
-                        const actions = [];
-                        updateActions(this.toActionsArray(menu), actions, title);
-                        this.menubar?.updateMenu({ actions: actions, label: mnemonicMenuLabel(this.topLevelTitles[title]) });
-                    }
-                }));
-                if (menu === this.menus.File) {
-                    this.reinstallDisposables.add(this.webNavigationMenu.onDidChange(() => {
-                        if (!this.focusInsideMenubar) {
-                            const actions = [];
-                            updateActions(this.toActionsArray(menu), actions, title);
-                            this.menubar?.updateMenu({ actions: actions, label: mnemonicMenuLabel(this.topLevelTitles[title]) });
-                        }
-                    }));
-                }
-            }
-            const actions = [];
-            if (menu) {
-                updateActions(this.toActionsArray(menu), actions, title);
-            }
-            if (this.menubar) {
-                if (!firstTime) {
-                    this.menubar.updateMenu({ actions: actions, label: mnemonicMenuLabel(this.topLevelTitles[title]) });
-                }
-                else {
-                    this.menubar.push({ actions: actions, label: mnemonicMenuLabel(this.topLevelTitles[title]) });
-                }
-            }
-        }
-    }
-    getWebNavigationActions() {
-        if (!isWeb) {
-            return [];
-        }
-        const webNavigationActions = [];
-        for (const groups of this.webNavigationMenu.getActions()) {
-            const [, actions] = groups;
-            for (const action of actions) {
-                if (action instanceof MenuItemAction) {
-                    const title = typeof action.item.title === 'string'
-                        ? action.item.title
-                        : action.item.title.mnemonicTitle ?? action.item.title.value;
-                    webNavigationActions.push(( new Action(
-                        action.id,
-                        mnemonicMenuLabel(title),
-                        action.class,
-                        action.enabled,
-                        async (event) => {
-                            this.commandService.executeCommand(action.id, event);
-                        }
-                    )));
-                }
-            }
-            webNavigationActions.push(( new Separator()));
-        }
-        if (webNavigationActions.length) {
-            webNavigationActions.pop();
-        }
-        return webNavigationActions;
-    }
-    getMenuBarOptions() {
-        return {
-            enableMnemonics: this.currentEnableMenuBarMnemonics,
-            disableAltFocus: this.currentDisableMenuBarAltFocus,
-            visibility: this.currentMenubarVisibility,
-            actionRunner: this.actionRunner,
-            getKeybinding: (action) => this.keybindingService.lookupKeybinding(action.id),
-            alwaysOnMnemonics: this.alwaysOnMnemonics,
-            compactMode: this.currentCompactMenuMode,
-            getCompactMenuActions: () => {
-                if (!isWeb) {
-                    return [];
-                }
-                return this.getWebNavigationActions();
-            }
-        };
-    }
-    onDidChangeWindowFocus(hasFocus) {
-        if (!this.visible) {
-            return;
-        }
-        super.onDidChangeWindowFocus(hasFocus);
-        if (this.container) {
-            if (hasFocus) {
-                this.container.classList.remove('inactive');
-            }
-            else {
-                this.container.classList.add('inactive');
-                this.menubar?.blur();
-            }
-        }
-    }
-    onUpdateStateChange() {
-        if (!this.visible) {
-            return;
-        }
-        super.onUpdateStateChange();
-    }
-    onDidChangeRecentlyOpened() {
-        if (!this.visible) {
-            return;
-        }
-        super.onDidChangeRecentlyOpened();
-    }
-    onUpdateKeybindings() {
-        if (!this.visible) {
-            return;
-        }
-        super.onUpdateKeybindings();
-    }
-    registerListeners() {
-        super.registerListeners();
-        this._register(addDisposableListener(window, EventType.RESIZE, () => {
-            if (this.menubar && !(isIOS && BrowserFeatures.pointerEvents)) {
-                this.menubar.blur();
-            }
-        }));
-        if (isWeb) {
-            this._register(this.layoutService.onDidChangeFullscreen(e => this.updateMenubar()));
-            this._register(this.webNavigationMenu.onDidChange(() => this.updateMenubar()));
-        }
-    }
-    get onVisibilityChange() {
-        return this._onVisibilityChange.event;
-    }
-    get onFocusStateChange() {
-        return this._onFocusStateChange.event;
-    }
-    getMenubarItemsDimensions() {
-        if (this.menubar) {
-            return ( new Dimension(this.menubar.getWidth(), this.menubar.getHeight()));
-        }
-        return ( new Dimension(0, 0));
-    }
-    create(parent) {
-        this.container = parent;
-        if (this.container) {
-            this.doUpdateMenubar(true);
-        }
-        return this.container;
-    }
-    layout(dimension) {
-        this.menubar?.update(this.getMenuBarOptions());
-    }
-    toggleFocus() {
-        this.menubar?.toggleFocus();
-    }
-};
-CustomMenubarControl = ( __decorate([
-    ( __param(0, IMenuService)),
-    ( __param(1, IWorkspacesService)),
-    ( __param(2, IContextKeyService)),
-    ( __param(3, IKeybindingService)),
-    ( __param(4, IConfigurationService)),
-    ( __param(5, ILabelService)),
-    ( __param(6, IUpdateService)),
-    ( __param(7, IStorageService)),
-    ( __param(8, INotificationService)),
-    ( __param(9, IPreferencesService)),
-    ( __param(10, IWorkbenchEnvironmentService)),
-    ( __param(11, IAccessibilityService)),
-    ( __param(12, IWorkbenchLayoutService)),
-    ( __param(13, ITelemetryService)),
-    ( __param(14, IHostService)),
-    ( __param(15, ICommandService))
-], CustomMenubarControl));
-export { CustomMenubarControl, MenubarControl };

package/dist/vscode/vs/workbench/browser/parts/views/checkbox.js

@@ -1,80 +0,0 @@
-import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
-import { Toggle } from 'monaco-editor/esm/vs/base/browser/ui/toggle/toggle.js';
-import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
-import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
-import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { localize } from 'monaco-editor/esm/vs/nls.js';
-import { defaultToggleStyles } from 'monaco-editor/esm/vs/platform/theme/browser/defaultStyles.js';
-class CheckboxStateHandler extends Disposable {
-    constructor() {
-        super(...arguments);
-        this._onDidChangeCheckboxState = this._register(( new Emitter()));
-        this.onDidChangeCheckboxState = this._onDidChangeCheckboxState.event;
-    }
-    setCheckboxState(node) {
-        this._onDidChangeCheckboxState.fire([node]);
-    }
-}
-class TreeItemCheckbox extends Disposable {
-    constructor(container, checkboxStateHandler) {
-        super();
-        this.checkboxStateHandler = checkboxStateHandler;
-        this.isDisposed = false;
-        this._onDidChangeState = ( new Emitter());
-        this.onDidChangeState = this._onDidChangeState.event;
-        this.checkboxContainer = container;
-    }
-    render(node) {
-        if (node.checkbox) {
-            if (!this.toggle) {
-                this.createCheckbox(node);
-            }
-            else {
-                this.toggle.checked = node.checkbox.isChecked;
-                this.toggle.setIcon(this.toggle.checked ? Codicon.check : undefined);
-            }
-        }
-    }
-    createCheckbox(node) {
-        if (node.checkbox) {
-            this.toggle = ( new Toggle({
-                isChecked: node.checkbox.isChecked,
-                title: this.createCheckboxTitle(node.checkbox),
-                icon: node.checkbox.isChecked ? Codicon.check : undefined,
-                ...defaultToggleStyles
-            }));
-            this.toggle.domNode.classList.add(TreeItemCheckbox.checkboxClass);
-            dom.append(this.checkboxContainer, this.toggle.domNode);
-            this.registerListener(node);
-        }
-    }
-    registerListener(node) {
-        if (this.toggle) {
-            this._register({ dispose: () => this.removeCheckbox() });
-            this._register(this.toggle);
-            this._register(this.toggle.onChange(() => {
-                this.setCheckbox(node);
-            }));
-        }
-    }
-    setCheckbox(node) {
-        if (this.toggle && node.checkbox) {
-            node.checkbox.isChecked = this.toggle.checked;
-            this.toggle.setIcon(this.toggle.checked ? Codicon.check : undefined);
-            this.toggle.setTitle(this.createCheckboxTitle(node.checkbox));
-            this.checkboxStateHandler.setCheckboxState(node);
-        }
-    }
-    createCheckboxTitle(checkbox) {
-        return checkbox.tooltip ? checkbox.tooltip :
-            checkbox.isChecked ? ( localize('checked', 'Checked')) : ( localize('unchecked', 'Unchecked'));
-    }
-    removeCheckbox() {
-        const children = this.checkboxContainer.children;
-        for (const child of children) {
-            this.checkboxContainer.removeChild(child);
-        }
-    }
-}
-TreeItemCheckbox.checkboxClass = 'custom-view-tree-node-item-checkbox';
-export { CheckboxStateHandler, TreeItemCheckbox };