@codingame/monaco-vscode-view-common-service-override 4.5.0-improve-code-splitting.1

package/vscode/src/vs/workbench/browser/parts/compositePart.js

@@ -0,0 +1,346 @@
+import './media/compositepart.css.js';
+import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { defaultGenerator } from 'vscode/vscode/vs/base/common/idGenerator';
+import { MutableDisposable, DisposableStore, dispose } from 'vscode/vscode/vs/base/common/lifecycle';
+import { Emitter } from 'vscode/vscode/vs/base/common/event';
+import { isCancellationError } from 'vscode/vscode/vs/base/common/errors';
+import { prepareActions } from 'vscode/vscode/vs/base/browser/ui/actionbar/actionbar';
+import { ProgressBar } from 'vscode/vscode/vs/base/browser/ui/progressbar/progressbar';
+import { Part } from 'vscode/vscode/vs/workbench/browser/part';
+import { ServiceCollection } from 'vscode/vscode/vs/platform/instantiation/common/serviceCollection';
+import { IEditorProgressService } from 'vscode/vscode/vs/platform/progress/common/progress.service';
+import { $, show, hide, append, Dimension } from 'vscode/vscode/vs/base/browser/dom';
+import { assertIsDefined } from 'vscode/vscode/vs/base/common/types';
+import { createActionViewItem } from 'vscode/vscode/vs/platform/actions/browser/menuEntryActionViewItem';
+import { ScopedProgressIndicator, AbstractProgressScope } from 'vscode/vscode/vs/workbench/services/progress/browser/progressIndicator';
+import { WorkbenchToolBar } from 'vscode/vscode/vs/platform/actions/browser/toolbar';
+import { defaultProgressBarStyles } from 'vscode/vscode/vs/platform/theme/browser/defaultStyles';
+import { createInstantHoverDelegate, getDefaultHoverDelegate } from 'vscode/vscode/vs/base/browser/ui/hover/hoverDelegateFactory';
+import { setupCustomHover } from 'vscode/vscode/vs/base/browser/ui/hover/updatableHoverWidget';
+
+class CompositePart extends Part {
+    constructor(notificationService, storageService, contextMenuService, layoutService, keybindingService, instantiationService, themeService, registry, activeCompositeSettingsKey, defaultCompositeId, nameForTelemetry, compositeCSSClass, titleForegroundColor, id, options) {
+        super(id, options, themeService, storageService, layoutService);
+        this.notificationService = notificationService;
+        this.storageService = storageService;
+        this.contextMenuService = contextMenuService;
+        this.keybindingService = keybindingService;
+        this.instantiationService = instantiationService;
+        this.registry = registry;
+        this.activeCompositeSettingsKey = activeCompositeSettingsKey;
+        this.defaultCompositeId = defaultCompositeId;
+        this.nameForTelemetry = nameForTelemetry;
+        this.compositeCSSClass = compositeCSSClass;
+        this.titleForegroundColor = titleForegroundColor;
+        this.onDidCompositeOpen = this._register(( new Emitter()));
+        this.onDidCompositeClose = this._register(( new Emitter()));
+        this.mapCompositeToCompositeContainer = ( new Map());
+        this.mapActionsBindingToComposite = ( new Map());
+        this.instantiatedCompositeItems = ( new Map());
+        this.actionsListener = this._register(( new MutableDisposable()));
+        this.lastActiveCompositeId = storageService.get(activeCompositeSettingsKey, 1 , this.defaultCompositeId);
+        this.toolbarHoverDelegate = this._register(createInstantHoverDelegate());
+    }
+    openComposite(id, focus) {
+        if (this.activeComposite?.getId() === id) {
+            if (focus) {
+                this.activeComposite.focus();
+            }
+            return this.activeComposite;
+        }
+        if (!this.element) {
+            return;
+        }
+        return this.doOpenComposite(id, focus);
+    }
+    doOpenComposite(id, focus = false) {
+        const currentCompositeOpenToken = defaultGenerator.nextId();
+        this.currentCompositeOpenToken = currentCompositeOpenToken;
+        if (this.activeComposite) {
+            this.hideActiveComposite();
+        }
+        this.updateTitle(id);
+        const composite = this.createComposite(id, true);
+        if ((this.currentCompositeOpenToken !== currentCompositeOpenToken) || (this.activeComposite && this.activeComposite.getId() !== composite.getId())) {
+            return undefined;
+        }
+        if (this.activeComposite?.getId() === composite.getId()) {
+            if (focus) {
+                composite.focus();
+            }
+            this.onDidCompositeOpen.fire({ composite, focus });
+            return composite;
+        }
+        this.showComposite(composite);
+        if (focus) {
+            composite.focus();
+        }
+        if (composite) {
+            this.onDidCompositeOpen.fire({ composite, focus });
+        }
+        return composite;
+    }
+    createComposite(id, isActive) {
+        const compositeItem = this.instantiatedCompositeItems.get(id);
+        if (compositeItem) {
+            return compositeItem.composite;
+        }
+        const compositeDescriptor = this.registry.getComposite(id);
+        if (compositeDescriptor) {
+            const that = this;
+            const compositeProgressIndicator = ( new ScopedProgressIndicator(
+                assertIsDefined(this.progressBar),
+                new (class extends AbstractProgressScope {
+                    constructor() {
+                        super(compositeDescriptor.id, !!isActive);
+                        this._register(that.onDidCompositeOpen.event(e => this.onScopeOpened(e.composite.getId())));
+                        this._register(that.onDidCompositeClose.event(e => this.onScopeClosed(e.getId())));
+                    }
+                })()
+            ));
+            const compositeInstantiationService = this.instantiationService.createChild(( new ServiceCollection(
+                [IEditorProgressService, compositeProgressIndicator]
+            )));
+            const composite = compositeDescriptor.instantiate(compositeInstantiationService);
+            const disposable = ( new DisposableStore());
+            this.instantiatedCompositeItems.set(id, { composite, disposable, progress: compositeProgressIndicator });
+            disposable.add(composite.onTitleAreaUpdate(() => this.onTitleAreaUpdate(composite.getId()), this));
+            return composite;
+        }
+        throw new Error(`Unable to find composite with id ${id}`);
+    }
+    showComposite(composite) {
+        this.activeComposite = composite;
+        const id = this.activeComposite.getId();
+        if (id !== this.defaultCompositeId) {
+            this.storageService.store(this.activeCompositeSettingsKey, id, 1 , 1 );
+        }
+        else {
+            this.storageService.remove(this.activeCompositeSettingsKey, 1 );
+        }
+        this.lastActiveCompositeId = this.activeComposite.getId();
+        let compositeContainer = this.mapCompositeToCompositeContainer.get(composite.getId());
+        if (!compositeContainer) {
+            compositeContainer = $('.composite');
+            compositeContainer.classList.add(...this.compositeCSSClass.split(' '));
+            compositeContainer.id = composite.getId();
+            composite.create(compositeContainer);
+            composite.updateStyles();
+            this.mapCompositeToCompositeContainer.set(composite.getId(), compositeContainer);
+        }
+        if (!this.activeComposite || composite.getId() !== this.activeComposite.getId()) {
+            return undefined;
+        }
+        const contentArea = this.getContentArea();
+        contentArea?.appendChild(compositeContainer);
+        show(compositeContainer);
+        const toolBar = assertIsDefined(this.toolBar);
+        toolBar.actionRunner = composite.getActionRunner();
+        const descriptor = this.registry.getComposite(composite.getId());
+        if (descriptor && descriptor.name !== composite.getTitle()) {
+            this.updateTitle(composite.getId(), composite.getTitle());
+        }
+        let actionsBinding = this.mapActionsBindingToComposite.get(composite.getId());
+        if (!actionsBinding) {
+            actionsBinding = this.collectCompositeActions(composite);
+            this.mapActionsBindingToComposite.set(composite.getId(), actionsBinding);
+        }
+        actionsBinding();
+        this.actionsListener.value = toolBar.actionRunner.onDidRun(e => {
+            if (e.error && !isCancellationError(e.error)) {
+                this.notificationService.error(e.error);
+            }
+        });
+        composite.setVisible(true);
+        if (!this.activeComposite || composite.getId() !== this.activeComposite.getId()) {
+            return;
+        }
+        if (this.contentAreaSize) {
+            composite.layout(this.contentAreaSize);
+        }
+        if (this.boundarySashes) {
+            composite.setBoundarySashes(this.boundarySashes);
+        }
+    }
+    onTitleAreaUpdate(compositeId) {
+        const composite = this.instantiatedCompositeItems.get(compositeId);
+        if (composite) {
+            this.updateTitle(compositeId, composite.composite.getTitle());
+        }
+        if (this.activeComposite?.getId() === compositeId) {
+            const actionsBinding = this.collectCompositeActions(this.activeComposite);
+            this.mapActionsBindingToComposite.set(this.activeComposite.getId(), actionsBinding);
+            actionsBinding();
+        }
+        else {
+            this.mapActionsBindingToComposite.delete(compositeId);
+        }
+    }
+    updateTitle(compositeId, compositeTitle) {
+        const compositeDescriptor = this.registry.getComposite(compositeId);
+        if (!compositeDescriptor || !this.titleLabel) {
+            return;
+        }
+        if (!compositeTitle) {
+            compositeTitle = compositeDescriptor.name;
+        }
+        const keybinding = this.keybindingService.lookupKeybinding(compositeId);
+        this.titleLabel.updateTitle(compositeId, compositeTitle, keybinding?.getLabel() ?? undefined);
+        const toolBar = assertIsDefined(this.toolBar);
+        toolBar.setAriaLabel(( localizeWithPath(
+            'vs/workbench/browser/parts/compositePart',
+            'ariaCompositeToolbarLabel',
+            "{0} actions",
+            compositeTitle
+        )));
+    }
+    collectCompositeActions(composite) {
+        const menuIds = composite?.getMenuIds();
+        const primaryActions = composite?.getActions().slice(0) || [];
+        const secondaryActions = composite?.getSecondaryActions().slice(0) || [];
+        const toolBar = assertIsDefined(this.toolBar);
+        toolBar.context = this.actionsContextProvider();
+        return () => toolBar.setActions(prepareActions(primaryActions), prepareActions(secondaryActions), menuIds);
+    }
+    getActiveComposite() {
+        return this.activeComposite;
+    }
+    getLastActiveCompositeId() {
+        return this.lastActiveCompositeId;
+    }
+    hideActiveComposite() {
+        if (!this.activeComposite) {
+            return undefined;
+        }
+        const composite = this.activeComposite;
+        this.activeComposite = undefined;
+        const compositeContainer = this.mapCompositeToCompositeContainer.get(composite.getId());
+        composite.setVisible(false);
+        if (compositeContainer) {
+            compositeContainer.remove();
+            hide(compositeContainer);
+        }
+        this.progressBar?.stop().hide();
+        if (this.toolBar) {
+            this.collectCompositeActions()();
+        }
+        this.onDidCompositeClose.fire(composite);
+        return composite;
+    }
+    createTitleArea(parent) {
+        const titleArea = append(parent, $('.composite'));
+        titleArea.classList.add('title');
+        this.titleLabel = this.createTitleLabel(titleArea);
+        const titleActionsContainer = append(titleArea, $('.title-actions'));
+        this.toolBar = this._register(this.instantiationService.createInstance(WorkbenchToolBar, titleActionsContainer, {
+            actionViewItemProvider: (action, options) => this.actionViewItemProvider(action, options),
+            orientation: 0 ,
+            getKeyBinding: action => this.keybindingService.lookupKeybinding(action.id),
+            anchorAlignmentProvider: () => this.getTitleAreaDropDownAnchorAlignment(),
+            toggleMenuTitle: ( localizeWithPath(
+                'vs/workbench/browser/parts/compositePart',
+                'viewsAndMoreActions',
+                "Views and More Actions..."
+            )),
+            telemetrySource: this.nameForTelemetry,
+            hoverDelegate: this.toolbarHoverDelegate
+        }));
+        this.collectCompositeActions()();
+        return titleArea;
+    }
+    createTitleLabel(parent) {
+        const titleContainer = append(parent, $('.title-label'));
+        const titleLabel = append(titleContainer, $('h2'));
+        this.titleLabelElement = titleLabel;
+        const hover = this._register(setupCustomHover(getDefaultHoverDelegate('mouse'), titleLabel, ''));
+        const $this = this;
+        return {
+            updateTitle: (id, title, keybinding) => {
+                if (!this.activeComposite || this.activeComposite.getId() === id) {
+                    titleLabel.innerText = title;
+                    hover.update(keybinding ? ( localizeWithPath(
+                        'vs/workbench/browser/parts/compositePart',
+                        'titleTooltip',
+                        "{0} ({1})",
+                        title,
+                        keybinding
+                    )) : title);
+                }
+            },
+            updateStyles: () => {
+                titleLabel.style.color = $this.titleForegroundColor ? $this.getColor($this.titleForegroundColor) || '' : '';
+            }
+        };
+    }
+    createHeaderArea() {
+        return $('.composite');
+    }
+    createFooterArea() {
+        return $('.composite');
+    }
+    updateStyles() {
+        super.updateStyles();
+        const titleLabel = assertIsDefined(this.titleLabel);
+        titleLabel.updateStyles();
+    }
+    actionViewItemProvider(action, options) {
+        if (this.activeComposite) {
+            return this.activeComposite.getActionViewItem(action, options);
+        }
+        return createActionViewItem(this.instantiationService, action, options);
+    }
+    actionsContextProvider() {
+        if (this.activeComposite) {
+            return this.activeComposite.getActionsContext();
+        }
+        return null;
+    }
+    createContentArea(parent) {
+        const contentContainer = append(parent, $('.content'));
+        this.progressBar = this._register(( new ProgressBar(contentContainer, defaultProgressBarStyles)));
+        this.progressBar.hide();
+        return contentContainer;
+    }
+    getProgressIndicator(id) {
+        const compositeItem = this.instantiatedCompositeItems.get(id);
+        return compositeItem ? compositeItem.progress : undefined;
+    }
+    getTitleAreaDropDownAnchorAlignment() {
+        return 1 ;
+    }
+    layout(width, height, top, left) {
+        super.layout(width, height, top, left);
+        this.contentAreaSize = Dimension.lift(super.layoutContents(width, height).contentSize);
+        this.activeComposite?.layout(this.contentAreaSize);
+    }
+    setBoundarySashes(sashes) {
+        this.boundarySashes = sashes;
+        this.activeComposite?.setBoundarySashes(sashes);
+    }
+    removeComposite(compositeId) {
+        if (this.activeComposite?.getId() === compositeId) {
+            return false;
+        }
+        this.mapCompositeToCompositeContainer.delete(compositeId);
+        this.mapActionsBindingToComposite.delete(compositeId);
+        const compositeItem = this.instantiatedCompositeItems.get(compositeId);
+        if (compositeItem) {
+            compositeItem.composite.dispose();
+            dispose(compositeItem.disposable);
+            this.instantiatedCompositeItems.delete(compositeId);
+        }
+        return true;
+    }
+    dispose() {
+        this.mapCompositeToCompositeContainer.clear();
+        this.mapActionsBindingToComposite.clear();
+        this.instantiatedCompositeItems.forEach(compositeItem => {
+            compositeItem.composite.dispose();
+            dispose(compositeItem.disposable);
+        });
+        this.instantiatedCompositeItems.clear();
+        super.dispose();
+    }
+}
+
+export { CompositePart };

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

@@ -0,0 +1,246 @@
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+import { onDidChangeFullscreen } from 'vscode/vscode/vs/base/browser/browser';
+import { show, hide } from 'vscode/vscode/vs/base/browser/dom';
+import { Event, Emitter } from 'vscode/vscode/vs/base/common/event';
+import { DisposableStore } from 'vscode/vscode/vs/base/common/lifecycle';
+import { isNative } from 'vscode/vscode/vs/base/common/platform';
+import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration.service';
+import { IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/contextkey.service';
+import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+import { ServiceCollection } from 'vscode/vscode/vs/platform/instantiation/common/serviceCollection';
+import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage.service';
+import { IThemeService } from 'vscode/vscode/vs/platform/theme/common/themeService.service';
+import { hasCustomTitlebar } from 'vscode/vscode/vs/platform/window/common/window';
+import { EditorPart } from './editorPart.js';
+import { WindowTitle } from 'vscode/vscode/vs/workbench/browser/parts/titlebar/windowTitle';
+import { IAuxiliaryWindowService } from 'vscode/vscode/vs/workbench/services/auxiliaryWindow/browser/auxiliaryWindowService.service';
+import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService.service';
+import { IHostService } from 'vscode/vscode/vs/workbench/services/host/browser/host.service';
+import { shouldShowCustomTitleBar } from 'vscode/vscode/vs/workbench/services/layout/browser/layoutService';
+import { IWorkbenchLayoutService } from 'vscode/vscode/vs/workbench/services/layout/browser/layoutService.service';
+import { ILifecycleService } from 'vscode/vscode/vs/workbench/services/lifecycle/common/lifecycle.service';
+import { IStatusbarService } from 'vscode/vscode/vs/workbench/services/statusbar/browser/statusbar.service';
+import { ITitleService } from 'vscode/vscode/vs/workbench/services/title/browser/titleService.service';
+
+var AuxiliaryEditorPart_1, AuxiliaryEditorPartImpl_1;
+let AuxiliaryEditorPart = class AuxiliaryEditorPart {
+    static { AuxiliaryEditorPart_1 = this; }
+    static { this.STATUS_BAR_VISIBILITY = 'workbench.statusBar.visible'; }
+    constructor(editorPartsView, instantiationService, auxiliaryWindowService, lifecycleService, configurationService, statusbarService, titleService, editorService, layoutService) {
+        this.editorPartsView = editorPartsView;
+        this.instantiationService = instantiationService;
+        this.auxiliaryWindowService = auxiliaryWindowService;
+        this.lifecycleService = lifecycleService;
+        this.configurationService = configurationService;
+        this.statusbarService = statusbarService;
+        this.titleService = titleService;
+        this.editorService = editorService;
+        this.layoutService = layoutService;
+    }
+    async create(label, options) {
+        function computeEditorPartHeightOffset() {
+            let editorPartHeightOffset = 0;
+            if (statusbarVisible) {
+                editorPartHeightOffset += statusbarPart.height;
+            }
+            if (titlebarPart && titlebarVisible) {
+                editorPartHeightOffset += titlebarPart.height;
+            }
+            return editorPartHeightOffset;
+        }
+        function updateStatusbarVisibility(fromEvent) {
+            if (statusbarVisible) {
+                show(statusbarPart.container);
+            }
+            else {
+                hide(statusbarPart.container);
+            }
+            if (fromEvent) {
+                auxiliaryWindow.layout();
+            }
+        }
+        function updateTitlebarVisibility(fromEvent) {
+            if (!titlebarPart) {
+                return;
+            }
+            if (titlebarVisible) {
+                show(titlebarPart.container);
+            }
+            else {
+                hide(titlebarPart.container);
+            }
+            if (fromEvent) {
+                auxiliaryWindow.layout();
+            }
+        }
+        const disposables = ( new DisposableStore());
+        const auxiliaryWindow = disposables.add(await this.auxiliaryWindowService.open(options));
+        const editorPartContainer = document.createElement('div');
+        editorPartContainer.classList.add('part', 'editor');
+        editorPartContainer.setAttribute('role', 'main');
+        editorPartContainer.style.position = 'relative';
+        auxiliaryWindow.container.appendChild(editorPartContainer);
+        const editorPart = disposables.add(this.instantiationService.createInstance(AuxiliaryEditorPartImpl, auxiliaryWindow.window.vscodeWindowId, this.editorPartsView, options?.state, label));
+        disposables.add(this.editorPartsView.registerPart(editorPart));
+        editorPart.create(editorPartContainer);
+        let titlebarPart = undefined;
+        let titlebarVisible = false;
+        const useCustomTitle = isNative && hasCustomTitlebar();
+        if (useCustomTitle) {
+            titlebarPart = disposables.add(this.titleService.createAuxiliaryTitlebarPart(auxiliaryWindow.container, editorPart));
+            titlebarVisible = shouldShowCustomTitleBar(this.configurationService, auxiliaryWindow.window);
+            const handleTitleBarVisibilityEvent = () => {
+                const oldTitlebarPartVisible = titlebarVisible;
+                titlebarVisible = shouldShowCustomTitleBar(this.configurationService, auxiliaryWindow.window);
+                if (oldTitlebarPartVisible !== titlebarVisible) {
+                    updateTitlebarVisibility(true);
+                }
+            };
+            disposables.add(titlebarPart.onDidChange(() => auxiliaryWindow.layout()));
+            disposables.add(this.layoutService.onDidChangePartVisibility(() => handleTitleBarVisibilityEvent()));
+            disposables.add(onDidChangeFullscreen(windowId => {
+                if (windowId !== auxiliaryWindow.window.vscodeWindowId) {
+                    return;
+                }
+                handleTitleBarVisibilityEvent();
+            }));
+            updateTitlebarVisibility(false);
+        }
+        else {
+            disposables.add(this.instantiationService.createInstance(WindowTitle, auxiliaryWindow.window, editorPart));
+        }
+        const statusbarPart = disposables.add(this.statusbarService.createAuxiliaryStatusbarPart(auxiliaryWindow.container));
+        let statusbarVisible = this.configurationService.getValue(AuxiliaryEditorPart_1.STATUS_BAR_VISIBILITY) !== false;
+        disposables.add(this.configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration(AuxiliaryEditorPart_1.STATUS_BAR_VISIBILITY)) {
+                statusbarVisible = this.configurationService.getValue(AuxiliaryEditorPart_1.STATUS_BAR_VISIBILITY) !== false;
+                updateStatusbarVisibility(true);
+            }
+        }));
+        updateStatusbarVisibility(false);
+        const editorCloseListener = disposables.add(Event.once(editorPart.onWillClose)(() => auxiliaryWindow.window.close()));
+        disposables.add(Event.once(auxiliaryWindow.onUnload)(() => {
+            if (disposables.isDisposed) {
+                return;
+            }
+            editorCloseListener.dispose();
+            editorPart.close();
+            disposables.dispose();
+        }));
+        disposables.add(Event.once(this.lifecycleService.onDidShutdown)(() => disposables.dispose()));
+        disposables.add(auxiliaryWindow.onBeforeUnload(event => {
+            for (const group of editorPart.groups) {
+                for (const editor of group.editors) {
+                    const canMoveVeto = editor.canMove(group.id, this.editorPartsView.mainPart.activeGroup.id);
+                    if (typeof canMoveVeto === 'string') {
+                        group.openEditor(editor);
+                        event.veto(canMoveVeto);
+                        break;
+                    }
+                }
+            }
+        }));
+        disposables.add(auxiliaryWindow.onWillLayout(dimension => {
+            const titlebarPartHeight = titlebarPart?.height ?? 0;
+            titlebarPart?.layout(dimension.width, titlebarPartHeight, 0, 0);
+            const editorPartHeight = dimension.height - computeEditorPartHeightOffset();
+            editorPart.layout(dimension.width, editorPartHeight, titlebarPartHeight, 0);
+            statusbarPart.layout(dimension.width, statusbarPart.height, dimension.height - statusbarPart.height, 0);
+        }));
+        auxiliaryWindow.layout();
+        const instantiationService = this.instantiationService.createChild(( new ServiceCollection(
+            [IStatusbarService, this.statusbarService.createScoped(statusbarPart, disposables)],
+            [IEditorService, this.editorService.createScoped(editorPart, disposables)]
+        )));
+        return {
+            part: editorPart,
+            instantiationService,
+            disposables
+        };
+    }
+};
+AuxiliaryEditorPart = AuxiliaryEditorPart_1 = ( __decorate([
+    ( __param(1, IInstantiationService)),
+    ( __param(2, IAuxiliaryWindowService)),
+    ( __param(3, ILifecycleService)),
+    ( __param(4, IConfigurationService)),
+    ( __param(5, IStatusbarService)),
+    ( __param(6, ITitleService)),
+    ( __param(7, IEditorService)),
+    ( __param(8, IWorkbenchLayoutService))
+], AuxiliaryEditorPart));
+let AuxiliaryEditorPartImpl = class AuxiliaryEditorPartImpl extends EditorPart {
+    static { AuxiliaryEditorPartImpl_1 = this; }
+    static { this.COUNTER = 1; }
+    constructor(windowId, editorPartsView, state, groupsLabel, instantiationService, themeService, configurationService, storageService, layoutService, hostService, contextKeyService) {
+        const id = AuxiliaryEditorPartImpl_1.COUNTER++;
+        super(editorPartsView, `workbench.parts.auxiliaryEditor.${id}`, groupsLabel, windowId, instantiationService, themeService, configurationService, storageService, layoutService, hostService, contextKeyService);
+        this.state = state;
+        this._onWillClose = this._register(( new Emitter()));
+        this.onWillClose = this._onWillClose.event;
+    }
+    removeGroup(group, preserveFocus) {
+        const groupView = this.assertGroupView(group);
+        if (this.count === 1 && this.activeGroup === groupView) {
+            this.doRemoveLastGroup(preserveFocus);
+        }
+        else {
+            super.removeGroup(group, preserveFocus);
+        }
+    }
+    doRemoveLastGroup(preserveFocus) {
+        const restoreFocus = !preserveFocus && this.shouldRestoreFocus(this.container);
+        const mostRecentlyActiveGroups = this.editorPartsView.getGroups(1 );
+        const nextActiveGroup = mostRecentlyActiveGroups[1];
+        if (nextActiveGroup) {
+            nextActiveGroup.groupsView.activateGroup(nextActiveGroup);
+            if (restoreFocus) {
+                nextActiveGroup.focus();
+            }
+        }
+        this.doClose(false );
+    }
+    loadState() {
+        return this.state;
+    }
+    saveState() {
+        return;
+    }
+    close() {
+        this.doClose(true );
+    }
+    doClose(mergeGroupsToMainPart) {
+        if (mergeGroupsToMainPart) {
+            this.mergeGroupsToMainPart();
+        }
+        this._onWillClose.fire();
+    }
+    mergeGroupsToMainPart() {
+        if (!( this.groups.some(group => group.count > 0))) {
+            return;
+        }
+        let targetGroup = undefined;
+        for (const group of this.editorPartsView.mainPart.getGroups(1 )) {
+            if (!group.isLocked) {
+                targetGroup = group;
+                break;
+            }
+        }
+        if (!targetGroup) {
+            targetGroup = this.editorPartsView.mainPart.addGroup(this.editorPartsView.mainPart.activeGroup, this.partOptions.openSideBySideDirection === 'right' ? 3  : 1 );
+        }
+        this.mergeAllGroups(targetGroup);
+        targetGroup.focus();
+    }
+};
+AuxiliaryEditorPartImpl = AuxiliaryEditorPartImpl_1 = ( __decorate([
+    ( __param(4, IInstantiationService)),
+    ( __param(5, IThemeService)),
+    ( __param(6, IConfigurationService)),
+    ( __param(7, IStorageService)),
+    ( __param(8, IWorkbenchLayoutService)),
+    ( __param(9, IHostService)),
+    ( __param(10, IContextKeyService))
+], AuxiliaryEditorPartImpl));
+
+export { AuxiliaryEditorPart };