@codingame/monaco-vscode-views-service-override 2.0.3 → 2.1.0

package/vscode/src/vs/workbench/browser/parts/editor/editorGroupWatermark.js

@@ -1,186 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { localizeWithPath } from 'vscode/vscode/vs/nls';
-import { Disposable, DisposableStore } from 'vscode/vscode/vs/base/common/lifecycle';
-import { isMacintosh, isWeb, OS } from 'vscode/vscode/vs/base/common/platform';
-import { IKeybindingService } from 'vscode/vscode/vs/platform/keybinding/common/keybinding';
-import { IWorkspaceContextService } from 'vscode/vscode/vs/platform/workspace/common/workspace';
-import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration';
-import { h, append, $, clearNode } from 'vscode/vscode/vs/base/browser/dom';
-import { KeybindingLabel } from 'vscode/vscode/vs/base/browser/ui/keybindingLabel/keybindingLabel';
-import { CommandsRegistry } from 'vscode/vscode/vs/platform/commands/common/commands';
-import { ContextKeyExpr, IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
-import { defaultKeybindingLabelStyles } from 'vscode/vscode/vs/platform/theme/browser/defaultStyles';
-
-const showCommands = { text: ( localizeWithPath(
-    'vs/workbench/browser/parts/editor/editorGroupWatermark',
-    'watermark.showCommands',
-    "Show All Commands"
-)), id: 'workbench.action.showCommands' };
-const quickAccess = { text: ( localizeWithPath(
-    'vs/workbench/browser/parts/editor/editorGroupWatermark',
-    'watermark.quickAccess',
-    "Go to File"
-)), id: 'workbench.action.quickOpen' };
-const openFileNonMacOnly = { text: ( localizeWithPath(
-    'vs/workbench/browser/parts/editor/editorGroupWatermark',
-    'watermark.openFile',
-    "Open File"
-)), id: 'workbench.action.files.openFile', mac: false };
-const openFolderNonMacOnly = { text: ( localizeWithPath(
-    'vs/workbench/browser/parts/editor/editorGroupWatermark',
-    'watermark.openFolder',
-    "Open Folder"
-)), id: 'workbench.action.files.openFolder', mac: false };
-const openFileOrFolderMacOnly = { text: ( localizeWithPath(
-    'vs/workbench/browser/parts/editor/editorGroupWatermark',
-    'watermark.openFileFolder',
-    "Open File or Folder"
-)), id: 'workbench.action.files.openFileFolder', mac: true };
-const openRecent = { text: ( localizeWithPath(
-    'vs/workbench/browser/parts/editor/editorGroupWatermark',
-    'watermark.openRecent',
-    "Open Recent"
-)), id: 'workbench.action.openRecent' };
-const newUntitledFileMacOnly = { text: ( localizeWithPath(
-    'vs/workbench/browser/parts/editor/editorGroupWatermark',
-    'watermark.newUntitledFile',
-    "New Untitled Text File"
-)), id: 'workbench.action.files.newUntitledFile', mac: true };
-const findInFiles = { text: ( localizeWithPath(
-    'vs/workbench/browser/parts/editor/editorGroupWatermark',
-    'watermark.findInFiles',
-    "Find in Files"
-)), id: 'workbench.action.findInFiles' };
-const toggleTerminal = { text: ( localizeWithPath(
-    'vs/workbench/browser/parts/editor/editorGroupWatermark',
-    { key: 'watermark.toggleTerminal', comment: ['toggle is a verb here'] },
-    "Toggle Terminal"
-)), id: 'workbench.action.terminal.toggleTerminal', when: ( ContextKeyExpr.equals('terminalProcessSupported', true)) };
-const startDebugging = { text: ( localizeWithPath(
-    'vs/workbench/browser/parts/editor/editorGroupWatermark',
-    'watermark.startDebugging',
-    "Start Debugging"
-)), id: 'workbench.action.debug.start', when: ( ContextKeyExpr.equals('terminalProcessSupported', true)) };
-const toggleFullscreen = { text: ( localizeWithPath(
-    'vs/workbench/browser/parts/editor/editorGroupWatermark',
-    { key: 'watermark.toggleFullscreen', comment: ['toggle is a verb here'] },
-    "Toggle Full Screen"
-)), id: 'workbench.action.toggleFullScreen', when: ( ( ContextKeyExpr.equals('terminalProcessSupported', true)).negate()) };
-const showSettings = { text: ( localizeWithPath(
-    'vs/workbench/browser/parts/editor/editorGroupWatermark',
-    'watermark.showSettings',
-    "Show Settings"
-)), id: 'workbench.action.openSettings', when: ( ( ContextKeyExpr.equals('terminalProcessSupported', true)).negate()) };
-const noFolderEntries = [
-    showCommands,
-    openFileNonMacOnly,
-    openFolderNonMacOnly,
-    openFileOrFolderMacOnly,
-    openRecent,
-    newUntitledFileMacOnly
-];
-const folderEntries = [
-    showCommands,
-    quickAccess,
-    findInFiles,
-    startDebugging,
-    toggleTerminal,
-    toggleFullscreen,
-    showSettings
-];
-let EditorGroupWatermark = class EditorGroupWatermark extends Disposable {
-    constructor(container, keybindingService, contextService, contextKeyService, configurationService) {
-        super();
-        this.keybindingService = keybindingService;
-        this.contextService = contextService;
-        this.contextKeyService = contextKeyService;
-        this.configurationService = configurationService;
-        this.transientDisposables = this._register(( new DisposableStore()));
-        this.enabled = false;
-        const elements = h('.editor-group-watermark', [
-            h('.letterpress'),
-            h('.shortcuts@shortcuts'),
-        ]);
-        append(container, elements.root);
-        this.shortcuts = elements.shortcuts;
-        this.registerListeners();
-        this.workbenchState = contextService.getWorkbenchState();
-        this.render();
-    }
-    registerListeners() {
-        this._register(this.configurationService.onDidChangeConfiguration(e => {
-            if (e.affectsConfiguration('workbench.tips.enabled')) {
-                this.render();
-            }
-        }));
-        this._register(this.contextService.onDidChangeWorkbenchState(workbenchState => {
-            if (this.workbenchState === workbenchState) {
-                return;
-            }
-            this.workbenchState = workbenchState;
-            this.render();
-        }));
-        const allEntriesWhenClauses = ( [...noFolderEntries, ...folderEntries].filter(entry => entry.when !== undefined).map(entry => entry.when));
-        const allKeys = ( new Set());
-        allEntriesWhenClauses.forEach(when => ( when.keys()).forEach(key => allKeys.add(key)));
-        this._register(this.contextKeyService.onDidChangeContext(e => {
-            if (e.affectsSome(allKeys)) {
-                this.render();
-            }
-        }));
-    }
-    render() {
-        const enabled = this.configurationService.getValue('workbench.tips.enabled');
-        if (enabled === this.enabled) {
-            return;
-        }
-        this.enabled = enabled;
-        this.clear();
-        if (!enabled) {
-            return;
-        }
-        const box = append(this.shortcuts, $('.watermark-box'));
-        const folder = this.workbenchState !== 1 ;
-        const selected = (folder ? folderEntries : noFolderEntries)
-            .filter(entry => !('when' in entry) || this.contextKeyService.contextMatchesRules(entry.when))
-            .filter(entry => !('mac' in entry) || entry.mac === (isMacintosh && !isWeb))
-            .filter(entry => !!CommandsRegistry.getCommand(entry.id));
-        const update = () => {
-            clearNode(box);
-            selected.forEach(entry => {
-                const keys = this.keybindingService.lookupKeybinding(entry.id);
-                if (!keys) {
-                    return;
-                }
-                const dl = append(box, $('dl'));
-                const dt = append(dl, $('dt'));
-                dt.textContent = entry.text;
-                const dd = append(dl, $('dd'));
-                const keybinding = ( new KeybindingLabel(
-                    dd,
-                    OS,
-                    { renderUnboundKeybindings: true, ...defaultKeybindingLabelStyles }
-                ));
-                keybinding.set(keys);
-            });
-        };
-        update();
-        this.transientDisposables.add(this.keybindingService.onDidUpdateKeybindings(update));
-    }
-    clear() {
-        clearNode(this.shortcuts);
-        this.transientDisposables.clear();
-    }
-    dispose() {
-        super.dispose();
-        this.clear();
-    }
-};
-EditorGroupWatermark = ( __decorate([
-    ( __param(1, IKeybindingService)),
-    ( __param(2, IWorkspaceContextService)),
-    ( __param(3, IContextKeyService)),
-    ( __param(4, IConfigurationService))
-], EditorGroupWatermark));
-
-export { EditorGroupWatermark };

package/vscode/src/vs/workbench/browser/parts/editor/editorPanes.js

@@ -1,346 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { localizeWithPath } from 'vscode/vscode/vs/nls';
-import { toAction } from 'vscode/vscode/vs/base/common/actions';
-import { Emitter } from 'vscode/vscode/vs/base/common/event';
-import Severity from 'vscode/vscode/vs/base/common/severity';
-import { Disposable, DisposableStore } from 'vscode/vscode/vs/base/common/lifecycle';
-import { EditorExtensions, createEditorOpenError, isEditorOpenError } from 'vscode/vscode/vs/workbench/common/editor';
-import { getWindow, isAncestor, show, Dimension, hide } from 'vscode/vscode/vs/base/browser/dom';
-import { Registry } from 'vscode/vscode/vs/platform/registry/common/platform';
-import { IWorkbenchLayoutService } from 'vscode/vscode/vs/workbench/services/layout/browser/layoutService';
-import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
-import { LongRunningOperation, IEditorProgressService } from 'vscode/vscode/vs/platform/progress/common/progress';
-import { DEFAULT_EDITOR_MIN_DIMENSIONS, DEFAULT_EDITOR_MAX_DIMENSIONS } from 'vscode/vscode/vs/workbench/browser/parts/editor/editor';
-import { assertIsDefined } from 'vscode/vscode/vs/base/common/types';
-import { IWorkspaceTrustManagementService } from 'vscode/vscode/vs/platform/workspace/common/workspaceTrust';
-import { ErrorPlaceholderEditor, WorkspaceTrustRequiredPlaceholderEditor } from 'vscode/vscode/vs/workbench/browser/parts/editor/editorPlaceholder';
-import { EditorOpenSource } from 'vscode/vscode/vs/platform/editor/common/editor';
-import { isCancellationError } from 'vscode/vscode/vs/base/common/errors';
-import { toErrorMessage } from 'vscode/vscode/vs/base/common/errorMessage';
-import { ILogService } from 'vscode/vscode/vs/platform/log/common/log';
-import '../../../../../../../override/vs/platform/dialogs/common/dialogs.js';
-import { IHostService } from 'vscode/vscode/vs/workbench/services/host/browser/host';
-import { mainWindow } from 'vscode/vscode/vs/base/browser/window';
-import { IDialogService } from 'vscode/vscode/vs/platform/dialogs/common/dialogs';
-
-let EditorPanes = class EditorPanes extends Disposable {
-    get minimumWidth() { return this._activeEditorPane?.minimumWidth ?? DEFAULT_EDITOR_MIN_DIMENSIONS.width; }
-    get minimumHeight() { return this._activeEditorPane?.minimumHeight ?? DEFAULT_EDITOR_MIN_DIMENSIONS.height; }
-    get maximumWidth() { return this._activeEditorPane?.maximumWidth ?? DEFAULT_EDITOR_MAX_DIMENSIONS.width; }
-    get maximumHeight() { return this._activeEditorPane?.maximumHeight ?? DEFAULT_EDITOR_MAX_DIMENSIONS.height; }
-    get activeEditorPane() { return this._activeEditorPane; }
-    constructor(editorGroupParent, editorPanesParent, groupView, layoutService, instantiationService, editorProgressService, workspaceTrustService, logService, dialogService, hostService) {
-        super();
-        this.editorGroupParent = editorGroupParent;
-        this.editorPanesParent = editorPanesParent;
-        this.groupView = groupView;
-        this.layoutService = layoutService;
-        this.instantiationService = instantiationService;
-        this.editorProgressService = editorProgressService;
-        this.workspaceTrustService = workspaceTrustService;
-        this.logService = logService;
-        this.dialogService = dialogService;
-        this.hostService = hostService;
-        this._onDidFocus = this._register(( new Emitter()));
-        this.onDidFocus = this._onDidFocus.event;
-        this._onDidChangeSizeConstraints = this._register(( new Emitter()));
-        this.onDidChangeSizeConstraints = this._onDidChangeSizeConstraints.event;
-        this._activeEditorPane = null;
-        this.editorPanes = [];
-        this.activeEditorPaneDisposables = this._register(( new DisposableStore()));
-        this.editorOperation = this._register(( new LongRunningOperation(this.editorProgressService)));
-        this.editorPanesRegistry = ( Registry.as(EditorExtensions.EditorPane));
-        this.registerListeners();
-    }
-    registerListeners() {
-        this._register(this.workspaceTrustService.onDidChangeTrust(() => this.onDidChangeWorkspaceTrust()));
-    }
-    onDidChangeWorkspaceTrust() {
-        const editor = this._activeEditorPane?.input;
-        const options = this._activeEditorPane?.options;
-        if (editor?.hasCapability(16 )) {
-            this.groupView.openEditor(editor, options);
-        }
-    }
-    async openEditor(editor, options, internalOptions, context = Object.create(null)) {
-        try {
-            if (getWindow(this.editorGroupParent) !== mainWindow && editor.hasCapability(1024 )) {
-                return await this.doShowError(createEditorOpenError(( localizeWithPath(
-                    'vs/workbench/browser/parts/editor/editorPanes',
-                    'editorUnsupportedInAuxWindow',
-                    "This type of editor cannot be opened in other windows yet."
-                )), [
-                    toAction({
-                        id: 'workbench.editor.action.closeEditor', label: ( localizeWithPath(
-                        'vs/workbench/browser/parts/editor/editorPanes',
-                        'openFolder',
-                        "Close Editor"
-                    )), run: async () => {
-                            return this.groupView.closeEditor(editor);
-                        }
-                    })
-                ], { forceMessage: true, forceSeverity: Severity.Warning }), editor, options, internalOptions, context);
-            }
-            else {
-                return await this.doOpenEditor(this.getEditorPaneDescriptor(editor), editor, options, internalOptions, context);
-            }
-        }
-        catch (error) {
-            if (options?.ignoreError) {
-                return { error };
-            }
-            return this.doShowError(error, editor, options, internalOptions, context);
-        }
-    }
-    async doShowError(error, editor, options, internalOptions, context) {
-        this.logService.error(error);
-        let errorHandled = false;
-        if (options?.source === EditorOpenSource.USER && (!isEditorOpenError(error) || error.allowDialog)) {
-            errorHandled = await this.doShowErrorDialog(error, editor);
-        }
-        if (errorHandled) {
-            return { error };
-        }
-        const editorPlaceholderOptions = { ...options };
-        if (!isCancellationError(error)) {
-            editorPlaceholderOptions.error = error;
-        }
-        return {
-            ...(await this.doOpenEditor(ErrorPlaceholderEditor.DESCRIPTOR, editor, editorPlaceholderOptions, internalOptions, context)),
-            error
-        };
-    }
-    async doShowErrorDialog(error, editor) {
-        let severity = Severity.Error;
-        let message = undefined;
-        let detail = toErrorMessage(error);
-        let errorActions = undefined;
-        if (isEditorOpenError(error)) {
-            errorActions = error.actions;
-            severity = error.forceSeverity ?? Severity.Error;
-            if (error.forceMessage) {
-                message = error.message;
-                detail = undefined;
-            }
-        }
-        if (!message) {
-            message = ( localizeWithPath(
-                'vs/workbench/browser/parts/editor/editorPanes',
-                'editorOpenErrorDialog',
-                "Unable to open '{0}'",
-                editor.getName()
-            ));
-        }
-        const buttons = [];
-        if (errorActions && errorActions.length > 0) {
-            for (const errorAction of errorActions) {
-                buttons.push({
-                    label: errorAction.label,
-                    run: () => errorAction
-                });
-            }
-        }
-        else {
-            buttons.push({
-                label: ( localizeWithPath(
-                    'vs/workbench/browser/parts/editor/editorPanes',
-                    { key: 'ok', comment: ['&& denotes a mnemonic'] },
-                    "&&OK"
-                )),
-                run: () => undefined
-            });
-        }
-        let cancelButton = undefined;
-        if (buttons.length === 1) {
-            cancelButton = {
-                run: () => {
-                    errorHandled = true;
-                    return undefined;
-                }
-            };
-        }
-        let errorHandled = false;
-        const { result } = await this.dialogService.prompt({
-            type: severity,
-            message,
-            detail,
-            buttons,
-            cancelButton
-        });
-        if (result) {
-            const errorActionResult = result.run();
-            if (errorActionResult instanceof Promise) {
-                errorActionResult.catch(error => this.dialogService.error(toErrorMessage(error)));
-            }
-            errorHandled = true;
-        }
-        return errorHandled;
-    }
-    async doOpenEditor(descriptor, editor, options, internalOptions, context = Object.create(null)) {
-        const pane = this.doShowEditorPane(descriptor);
-        const activeElement = this.editorPanesParent.ownerDocument.activeElement;
-        const { changed, cancelled } = await this.doSetInput(pane, editor, options, context);
-        if (!cancelled) {
-            const focus = !options || !options.preserveFocus;
-            if (focus && this.shouldRestoreFocus(activeElement)) {
-                pane.focus();
-            }
-            else if (!internalOptions?.preserveWindowOrder) {
-                this.hostService.moveTop(getWindow(this.editorGroupParent));
-            }
-        }
-        return { pane, changed, cancelled };
-    }
-    shouldRestoreFocus(expectedActiveElement) {
-        if (!this.layoutService.isRestored()) {
-            return true;
-        }
-        if (!expectedActiveElement) {
-            return true;
-        }
-        const activeElement = expectedActiveElement.ownerDocument.activeElement;
-        if (!activeElement || activeElement === expectedActiveElement.ownerDocument.body) {
-            return true;
-        }
-        const same = expectedActiveElement === activeElement;
-        if (same) {
-            return true;
-        }
-        if (activeElement.tagName !== 'INPUT' && activeElement.tagName !== 'TEXTAREA') {
-            return true;
-        }
-        if (isAncestor(activeElement, this.editorGroupParent)) {
-            return true;
-        }
-        return false;
-    }
-    getEditorPaneDescriptor(editor) {
-        if (editor.hasCapability(16 ) && !this.workspaceTrustService.isWorkspaceTrusted()) {
-            return WorkspaceTrustRequiredPlaceholderEditor.DESCRIPTOR;
-        }
-        return assertIsDefined(this.editorPanesRegistry.getEditorPane(editor));
-    }
-    doShowEditorPane(descriptor) {
-        if (this._activeEditorPane && descriptor.describes(this._activeEditorPane)) {
-            return this._activeEditorPane;
-        }
-        this.doHideActiveEditorPane();
-        const editorPane = this.doCreateEditorPane(descriptor);
-        this.doSetActiveEditorPane(editorPane);
-        const container = assertIsDefined(editorPane.getContainer());
-        this.editorPanesParent.appendChild(container);
-        show(container);
-        editorPane.setVisible(true, this.groupView);
-        if (this.pagePosition) {
-            editorPane.layout(( new Dimension(this.pagePosition.width, this.pagePosition.height)), { top: this.pagePosition.top, left: this.pagePosition.left });
-        }
-        if (this.boundarySashes) {
-            editorPane.setBoundarySashes(this.boundarySashes);
-        }
-        return editorPane;
-    }
-    doCreateEditorPane(descriptor) {
-        const editorPane = this.doInstantiateEditorPane(descriptor);
-        if (!editorPane.getContainer()) {
-            const editorPaneContainer = document.createElement('div');
-            editorPaneContainer.classList.add('editor-instance');
-            editorPane.create(editorPaneContainer);
-        }
-        return editorPane;
-    }
-    doInstantiateEditorPane(descriptor) {
-        const existingEditorPane = this.editorPanes.find(editorPane => descriptor.describes(editorPane));
-        if (existingEditorPane) {
-            return existingEditorPane;
-        }
-        const editorPane = this._register(descriptor.instantiate(this.instantiationService));
-        this.editorPanes.push(editorPane);
-        return editorPane;
-    }
-    doSetActiveEditorPane(editorPane) {
-        this._activeEditorPane = editorPane;
-        this.activeEditorPaneDisposables.clear();
-        if (editorPane) {
-            this.activeEditorPaneDisposables.add(editorPane.onDidChangeSizeConstraints(e => this._onDidChangeSizeConstraints.fire(e)));
-            this.activeEditorPaneDisposables.add(editorPane.onDidFocus(() => this._onDidFocus.fire()));
-        }
-        this._onDidChangeSizeConstraints.fire(undefined);
-    }
-    async doSetInput(editorPane, editor, options, context) {
-        const inputMatches = editorPane.input?.matches(editor);
-        if (inputMatches && !options?.forceReload) {
-            editorPane.setOptions(options);
-            return { changed: false, cancelled: false };
-        }
-        const operation = this.editorOperation.start(this.layoutService.isRestored() ? 800 : 3200);
-        let cancelled = false;
-        try {
-            editorPane.clearInput();
-            await editorPane.setInput(editor, options, context, operation.token);
-            if (!operation.isCurrent()) {
-                cancelled = true;
-            }
-        }
-        catch (error) {
-            if (!operation.isCurrent()) {
-                cancelled = true;
-            }
-            else {
-                throw error;
-            }
-        }
-        finally {
-            operation.stop();
-        }
-        return { changed: !inputMatches, cancelled };
-    }
-    doHideActiveEditorPane() {
-        if (!this._activeEditorPane) {
-            return;
-        }
-        this.editorOperation.stop();
-        this.safeRun(() => this._activeEditorPane?.clearInput());
-        this.safeRun(() => this._activeEditorPane?.setVisible(false, this.groupView));
-        const editorPaneContainer = this._activeEditorPane.getContainer();
-        if (editorPaneContainer) {
-            this.editorPanesParent.removeChild(editorPaneContainer);
-            hide(editorPaneContainer);
-        }
-        this.doSetActiveEditorPane(null);
-    }
-    closeEditor(editor) {
-        if (this._activeEditorPane?.input && editor.matches(this._activeEditorPane.input)) {
-            this.doHideActiveEditorPane();
-        }
-    }
-    setVisible(visible) {
-        this.safeRun(() => this._activeEditorPane?.setVisible(visible, this.groupView));
-    }
-    layout(pagePosition) {
-        this.pagePosition = pagePosition;
-        this.safeRun(() => this._activeEditorPane?.layout(( new Dimension(pagePosition.width, pagePosition.height)), pagePosition));
-    }
-    setBoundarySashes(sashes) {
-        this.boundarySashes = sashes;
-        this.safeRun(() => this._activeEditorPane?.setBoundarySashes(sashes));
-    }
-    safeRun(fn) {
-        try {
-            fn();
-        }
-        catch (error) {
-            this.logService.error(error);
-        }
-    }
-};
-EditorPanes = ( __decorate([
-    ( __param(3, IWorkbenchLayoutService)),
-    ( __param(4, IInstantiationService)),
-    ( __param(5, IEditorProgressService)),
-    ( __param(6, IWorkspaceTrustManagementService)),
-    ( __param(7, ILogService)),
-    ( __param(8, IDialogService)),
-    ( __param(9, IHostService))
-], EditorPanes));
-
-export { EditorPanes };

package/vscode/src/vs/workbench/browser/parts/editor/editorTitleControl.js

@@ -1,154 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import './media/editortitlecontrol.css.js';
-import { clearNode, Dimension } from 'vscode/vscode/vs/base/browser/dom';
-import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
-import { Themable, IThemeService } from 'vscode/vscode/vs/platform/theme/common/themeService';
-import { BreadcrumbsControlFactory, BreadcrumbsControl } from './breadcrumbsControl.js';
-import { MultiEditorTabsControl } from './multiEditorTabsControl.js';
-import { SingleEditorTabsControl } from './singleEditorTabsControl.js';
-import { DisposableStore } from 'vscode/vscode/vs/base/common/lifecycle';
-import { MultiRowEditorControl } from './multiRowEditorTabsControl.js';
-import { NoEditorTabsControl } from './noEditorTabsControl.js';
-
-let EditorTitleControl = class EditorTitleControl extends Themable {
-    get breadcrumbsControl() { return this.breadcrumbsControlFactory?.control; }
-    constructor(parent, editorPartsView, groupsView, groupView, model, instantiationService, themeService) {
-        super(themeService);
-        this.parent = parent;
-        this.editorPartsView = editorPartsView;
-        this.groupsView = groupsView;
-        this.groupView = groupView;
-        this.model = model;
-        this.instantiationService = instantiationService;
-        this.editorTabsControlDisposable = this._register(( new DisposableStore()));
-        this.breadcrumbsControlDisposables = this._register(( new DisposableStore()));
-        this.editorTabsControl = this.createEditorTabsControl();
-        this.breadcrumbsControlFactory = this.createBreadcrumbsControl();
-    }
-    createEditorTabsControl() {
-        let tabsControlType;
-        switch (this.groupsView.partOptions.showTabs) {
-            case 'none':
-                tabsControlType = NoEditorTabsControl;
-                break;
-            case 'single':
-                tabsControlType = SingleEditorTabsControl;
-                break;
-            case 'multiple':
-            default:
-                tabsControlType = this.groupsView.partOptions.pinnedTabsOnSeparateRow ? MultiRowEditorControl : MultiEditorTabsControl;
-                break;
-        }
-        const control = this.instantiationService.createInstance(tabsControlType, this.parent, this.editorPartsView, this.groupsView, this.groupView, this.model);
-        return this.editorTabsControlDisposable.add(control);
-    }
-    createBreadcrumbsControl() {
-        if (this.groupsView.partOptions.showTabs === 'single') {
-            return undefined;
-        }
-        const breadcrumbsContainer = document.createElement('div');
-        breadcrumbsContainer.classList.add('breadcrumbs-below-tabs');
-        this.parent.appendChild(breadcrumbsContainer);
-        const breadcrumbsControlFactory = this.breadcrumbsControlDisposables.add(this.instantiationService.createInstance(BreadcrumbsControlFactory, breadcrumbsContainer, this.groupView, {
-            showFileIcons: true,
-            showSymbolIcons: true,
-            showDecorationColors: false,
-            showPlaceholder: true
-        }));
-        this.breadcrumbsControlDisposables.add(breadcrumbsControlFactory.onDidEnablementChange(() => this.groupView.relayout()));
-        this.breadcrumbsControlDisposables.add(breadcrumbsControlFactory.onDidVisibilityChange(() => this.groupView.relayout()));
-        return breadcrumbsControlFactory;
-    }
-    openEditor(editor, options) {
-        const didChange = this.editorTabsControl.openEditor(editor, options);
-        this.handleOpenedEditors(didChange);
-    }
-    openEditors(editors) {
-        const didChange = this.editorTabsControl.openEditors(editors);
-        this.handleOpenedEditors(didChange);
-    }
-    handleOpenedEditors(didChange) {
-        if (didChange) {
-            this.breadcrumbsControl?.update();
-        }
-        else {
-            this.breadcrumbsControl?.revealLast();
-        }
-    }
-    beforeCloseEditor(editor) {
-        return this.editorTabsControl.beforeCloseEditor(editor);
-    }
-    closeEditor(editor) {
-        this.editorTabsControl.closeEditor(editor);
-        this.handleClosedEditors();
-    }
-    closeEditors(editors) {
-        this.editorTabsControl.closeEditors(editors);
-        this.handleClosedEditors();
-    }
-    handleClosedEditors() {
-        if (!this.groupView.activeEditor) {
-            this.breadcrumbsControl?.update();
-        }
-    }
-    moveEditor(editor, fromIndex, targetIndex, stickyStateChange) {
-        return this.editorTabsControl.moveEditor(editor, fromIndex, targetIndex, stickyStateChange);
-    }
-    pinEditor(editor) {
-        return this.editorTabsControl.pinEditor(editor);
-    }
-    stickEditor(editor) {
-        return this.editorTabsControl.stickEditor(editor);
-    }
-    unstickEditor(editor) {
-        return this.editorTabsControl.unstickEditor(editor);
-    }
-    setActive(isActive) {
-        return this.editorTabsControl.setActive(isActive);
-    }
-    updateEditorLabel(editor) {
-        return this.editorTabsControl.updateEditorLabel(editor);
-    }
-    updateEditorDirty(editor) {
-        return this.editorTabsControl.updateEditorDirty(editor);
-    }
-    updateOptions(oldOptions, newOptions) {
-        if (oldOptions.showTabs !== newOptions.showTabs ||
-            (newOptions.showTabs !== 'single' && oldOptions.pinnedTabsOnSeparateRow !== newOptions.pinnedTabsOnSeparateRow)) {
-            this.editorTabsControlDisposable.clear();
-            this.breadcrumbsControlDisposables.clear();
-            clearNode(this.parent);
-            this.editorTabsControl = this.createEditorTabsControl();
-            this.breadcrumbsControlFactory = this.createBreadcrumbsControl();
-        }
-        else {
-            this.editorTabsControl.updateOptions(oldOptions, newOptions);
-        }
-    }
-    layout(dimensions) {
-        const tabsControlDimension = this.editorTabsControl.layout(dimensions);
-        let breadcrumbsControlDimension = undefined;
-        if (this.breadcrumbsControl?.isHidden() === false) {
-            breadcrumbsControlDimension = ( new Dimension(dimensions.container.width, BreadcrumbsControl.HEIGHT));
-            this.breadcrumbsControl.layout(breadcrumbsControlDimension);
-        }
-        return ( new Dimension(
-            dimensions.container.width,
-            tabsControlDimension.height + (breadcrumbsControlDimension ? breadcrumbsControlDimension.height : 0)
-        ));
-    }
-    getHeight() {
-        const tabsControlHeight = this.editorTabsControl.getHeight();
-        const breadcrumbsControlHeight = this.breadcrumbsControl?.isHidden() === false ? BreadcrumbsControl.HEIGHT : 0;
-        return {
-            total: tabsControlHeight + breadcrumbsControlHeight,
-            offset: tabsControlHeight
-        };
-    }
-};
-EditorTitleControl = ( __decorate([
-    ( __param(5, IInstantiationService)),
-    ( __param(6, IThemeService))
-], EditorTitleControl));
-
-export { EditorTitleControl };