@codingame/monaco-vscode-api 1.79.1 → 1.79.2-next.0

package/dist/vscode/vs/workbench/contrib/terminal/browser/terminalGroup.js

@@ -0,0 +1,482 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { TERMINAL_VIEW_ID } from '../common/terminal.js';
+import { Emitter, Event } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Disposable, dispose, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { SplitView, Sizing } from 'monaco-editor/esm/vs/base/browser/ui/splitview/splitview.js';
+import { IWorkbenchLayoutService } from '../../../services/layout/browser/layoutService.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { ITerminalService, ITerminalInstanceService } from './terminal.js';
+import { IViewDescriptorService } from '../../../common/views.js';
+import { TerminalLocation } from '../../../../platform/terminal/common/terminal.js';
+import { getPartByLocation } from '../../../browser/parts/views/viewsService.js';
+let SplitPaneContainer = class SplitPaneContainer extends Disposable {
+    get onDidChange() { return this._onDidChange; }
+    constructor(_container, orientation, _layoutService) {
+        super();
+        this._container = _container;
+        this.orientation = orientation;
+        this._layoutService = _layoutService;
+        this._splitViewDisposables = this._register(( new DisposableStore()));
+        this._children = [];
+        this._terminalToPane = ( new Map());
+        this._onDidChange = Event.None;
+        this._width = this._container.offsetWidth;
+        this._height = this._container.offsetHeight;
+        this._createSplitView();
+        this._splitView.layout(this.orientation === 1  ? this._width : this._height);
+    }
+    _createSplitView() {
+        this._splitView = ( new SplitView(this._container, { orientation: this.orientation }));
+        this._splitViewDisposables.clear();
+        this._splitViewDisposables.add(this._splitView.onDidSashReset(() => this._splitView.distributeViewSizes()));
+    }
+    split(instance, index) {
+        this._addChild(instance, index);
+    }
+    resizePane(index, direction, amount, part) {
+        const isHorizontal = ((direction === 0) ) || ((direction === 1) );
+        if (((isHorizontal && this.orientation !== 1) ) ||
+            ((!isHorizontal && this.orientation !== 0) )) {
+            if (((this.orientation === 1  && direction === 3) ) ||
+                ((this.orientation === 0  && direction === 1) )) {
+                amount *= -1;
+            }
+            this._layoutService.resizePart(part, amount, amount);
+            return;
+        }
+        if (this._children.length <= 1) {
+            return;
+        }
+        const sizes = [];
+        for (let i = 0; i < this._splitView.length; i++) {
+            sizes.push(this._splitView.getViewSize(i));
+        }
+        const isSizingEndPane = index !== this._children.length - 1;
+        const indexToChange = isSizingEndPane ? index + 1 : index - 1;
+        if (isSizingEndPane && direction === 0 ) {
+            amount *= -1;
+        }
+        else if (!isSizingEndPane && direction === 1 ) {
+            amount *= -1;
+        }
+        else if (isSizingEndPane && direction === 2 ) {
+            amount *= -1;
+        }
+        else if (!isSizingEndPane && direction === 3 ) {
+            amount *= -1;
+        }
+        if (sizes[index] + amount < 80 ) {
+            amount = 80  - sizes[index];
+        }
+        else if (sizes[indexToChange] - amount < 80 ) {
+            amount = sizes[indexToChange] - 80 ;
+        }
+        sizes[index] += amount;
+        sizes[indexToChange] -= amount;
+        for (let i = 0; i < this._splitView.length - 1; i++) {
+            this._splitView.resizeView(i, sizes[i]);
+        }
+    }
+    resizePanes(relativeSizes) {
+        if (this._children.length <= 1) {
+            return;
+        }
+        relativeSizes[relativeSizes.length - 1] += 1 - relativeSizes.reduce((totalValue, currentValue) => totalValue + currentValue, 0);
+        let totalSize = 0;
+        for (let i = 0; i < this._splitView.length; i++) {
+            totalSize += this._splitView.getViewSize(i);
+        }
+        for (let i = 0; i < this._splitView.length; i++) {
+            this._splitView.resizeView(i, totalSize * relativeSizes[i]);
+        }
+    }
+    getPaneSize(instance) {
+        const paneForInstance = this._terminalToPane.get(instance);
+        if (!paneForInstance) {
+            return 0;
+        }
+        const index = this._children.indexOf(paneForInstance);
+        return this._splitView.getViewSize(index);
+    }
+    _addChild(instance, index) {
+        const child = ( new SplitPane(
+            instance,
+            this.orientation === 1  ? this._height : this._width
+        ));
+        child.orientation = this.orientation;
+        if (typeof index === 'number') {
+            this._children.splice(index, 0, child);
+        }
+        else {
+            this._children.push(child);
+        }
+        this._terminalToPane.set(instance, this._children[this._children.indexOf(child)]);
+        this._withDisabledLayout(() => this._splitView.addView(child, Sizing.Distribute, index));
+        this.layout(this._width, this._height);
+        this._onDidChange = Event.any(...( this._children.map(c => c.onDidChange)));
+    }
+    remove(instance) {
+        let index = null;
+        for (let i = 0; i < this._children.length; i++) {
+            if (this._children[i].instance === instance) {
+                index = i;
+            }
+        }
+        if (index !== null) {
+            this._children.splice(index, 1);
+            this._terminalToPane.delete(instance);
+            this._splitView.removeView(index, Sizing.Distribute);
+            instance.detachFromElement();
+        }
+    }
+    layout(width, height) {
+        this._width = width;
+        this._height = height;
+        if (this.orientation === 1 ) {
+            this._children.forEach(c => c.orthogonalLayout(height));
+            this._splitView.layout(width);
+        }
+        else {
+            this._children.forEach(c => c.orthogonalLayout(width));
+            this._splitView.layout(height);
+        }
+    }
+    setOrientation(orientation) {
+        if (this.orientation === orientation) {
+            return;
+        }
+        this.orientation = orientation;
+        while (this._container.children.length > 0) {
+            this._container.removeChild(this._container.children[0]);
+        }
+        this._splitViewDisposables.clear();
+        this._splitView.dispose();
+        this._createSplitView();
+        this._withDisabledLayout(() => {
+            this._children.forEach(child => {
+                child.orientation = orientation;
+                this._splitView.addView(child, 1);
+            });
+        });
+    }
+    _withDisabledLayout(innerFunction) {
+        this._children.forEach(c => c.instance.disableLayout = true);
+        innerFunction();
+        this._children.forEach(c => c.instance.disableLayout = false);
+    }
+};
+SplitPaneContainer = ( __decorate([
+    ( __param(2, IWorkbenchLayoutService))
+], SplitPaneContainer));
+class SplitPane {
+    get onDidChange() { return this._onDidChange; }
+    constructor(instance, orthogonalSize) {
+        this.instance = instance;
+        this.orthogonalSize = orthogonalSize;
+        this.minimumSize = 80 ;
+        this.maximumSize = Number.MAX_VALUE;
+        this._onDidChange = Event.None;
+        this.element = document.createElement('div');
+        this.element.className = 'terminal-split-pane';
+        this.instance.attachToElement(this.element);
+    }
+    layout(size) {
+        if (!size || !this.orthogonalSize) {
+            return;
+        }
+        if (this.orientation === 0 ) {
+            this.instance.layout({ width: this.orthogonalSize, height: size });
+        }
+        else {
+            this.instance.layout({ width: size, height: this.orthogonalSize });
+        }
+    }
+    orthogonalLayout(size) {
+        this.orthogonalSize = size;
+    }
+}
+let TerminalGroup = class TerminalGroup extends Disposable {
+    get terminalInstances() { return this._terminalInstances; }
+    constructor(_container, shellLaunchConfigOrInstance, _terminalService, _terminalInstanceService, _layoutService, _viewDescriptorService, _instantiationService) {
+        super();
+        this._container = _container;
+        this._terminalService = _terminalService;
+        this._terminalInstanceService = _terminalInstanceService;
+        this._layoutService = _layoutService;
+        this._viewDescriptorService = _viewDescriptorService;
+        this._instantiationService = _instantiationService;
+        this._terminalInstances = [];
+        this._panelPosition = 2 ;
+        this._terminalLocation = 1 ;
+        this._instanceDisposables = ( new Map());
+        this._activeInstanceIndex = -1;
+        this._onDidDisposeInstance = this._register(( new Emitter()));
+        this.onDidDisposeInstance = this._onDidDisposeInstance.event;
+        this._onDidFocusInstance = this._register(( new Emitter()));
+        this.onDidFocusInstance = this._onDidFocusInstance.event;
+        this._onDidChangeInstanceCapability = this._register(( new Emitter()));
+        this.onDidChangeInstanceCapability = this._onDidChangeInstanceCapability.event;
+        this._onDisposed = this._register(( new Emitter()));
+        this.onDisposed = this._onDisposed.event;
+        this._onInstancesChanged = this._register(( new Emitter()));
+        this.onInstancesChanged = this._onInstancesChanged.event;
+        this._onDidChangeActiveInstance = ( new Emitter());
+        this.onDidChangeActiveInstance = this._onDidChangeActiveInstance.event;
+        this._onPanelOrientationChanged = ( new Emitter());
+        this.onPanelOrientationChanged = this._onPanelOrientationChanged.event;
+        if (shellLaunchConfigOrInstance) {
+            this.addInstance(shellLaunchConfigOrInstance);
+        }
+        if (this._container) {
+            this.attachToElement(this._container);
+        }
+        this._onPanelOrientationChanged.fire(this._terminalLocation === 1  && this._panelPosition === 2  ? 1  : 0 );
+    }
+    addInstance(shellLaunchConfigOrInstance, parentTerminalId) {
+        let instance;
+        const parentIndex = parentTerminalId ? this._terminalInstances.findIndex(t => t.instanceId === parentTerminalId) : this._activeInstanceIndex;
+        if ('instanceId' in shellLaunchConfigOrInstance) {
+            instance = shellLaunchConfigOrInstance;
+        }
+        else {
+            instance = this._terminalInstanceService.createInstance(shellLaunchConfigOrInstance, TerminalLocation.Panel);
+        }
+        if (this._terminalInstances.length === 0) {
+            this._terminalInstances.push(instance);
+            this._activeInstanceIndex = 0;
+        }
+        else {
+            this._terminalInstances.splice(parentIndex + 1, 0, instance);
+        }
+        this._initInstanceListeners(instance);
+        if (this._splitPaneContainer) {
+            this._splitPaneContainer.split(instance, parentIndex + 1);
+        }
+        this._onInstancesChanged.fire();
+    }
+    dispose() {
+        super.dispose();
+        if (this._container && this._groupElement) {
+            this._container.removeChild(this._groupElement);
+            this._groupElement = undefined;
+        }
+        this._terminalInstances = [];
+        this._onInstancesChanged.fire();
+    }
+    get activeInstance() {
+        if (this._terminalInstances.length === 0) {
+            return undefined;
+        }
+        return this._terminalInstances[this._activeInstanceIndex];
+    }
+    getLayoutInfo(isActive) {
+        const instances = this.terminalInstances.filter(instance => typeof instance.persistentProcessId === 'number' && instance.shouldPersist);
+        const totalSize = ( instances.map(t => this._splitPaneContainer?.getPaneSize(t) || 0)).reduce((total, size) => total += size, 0);
+        return {
+            isActive: isActive,
+            activePersistentProcessId: this.activeInstance ? this.activeInstance.persistentProcessId : undefined,
+            terminals: ( instances.map(t => {
+                return {
+                    relativeSize: totalSize > 0 ? this._splitPaneContainer.getPaneSize(t) / totalSize : 0,
+                    terminal: t.persistentProcessId || 0
+                };
+            }))
+        };
+    }
+    _initInstanceListeners(instance) {
+        this._instanceDisposables.set(instance.instanceId, [
+            instance.onDisposed(instance => {
+                this._onDidDisposeInstance.fire(instance);
+                this._handleOnDidDisposeInstance(instance);
+            }),
+            instance.onDidFocus(instance => {
+                this._setActiveInstance(instance);
+                this._onDidFocusInstance.fire(instance);
+            }),
+            instance.capabilities.onDidAddCapability(() => this._onDidChangeInstanceCapability.fire(instance)),
+            instance.capabilities.onDidRemoveCapability(() => this._onDidChangeInstanceCapability.fire(instance)),
+        ]);
+    }
+    _handleOnDidDisposeInstance(instance) {
+        this._removeInstance(instance);
+    }
+    removeInstance(instance) {
+        this._removeInstance(instance);
+        const disposables = this._instanceDisposables.get(instance.instanceId);
+        if (disposables) {
+            dispose(disposables);
+            this._instanceDisposables.delete(instance.instanceId);
+        }
+    }
+    _removeInstance(instance) {
+        const index = this._terminalInstances.indexOf(instance);
+        if (index === -1) {
+            return;
+        }
+        const wasActiveInstance = instance === this.activeInstance;
+        this._terminalInstances.splice(index, 1);
+        if (wasActiveInstance && this._terminalInstances.length > 0) {
+            const newIndex = index < this._terminalInstances.length ? index : this._terminalInstances.length - 1;
+            this.setActiveInstanceByIndex(newIndex);
+            this.activeInstance?.focus(true);
+        }
+        else if (index < this._activeInstanceIndex) {
+            this._activeInstanceIndex--;
+        }
+        this._splitPaneContainer?.remove(instance);
+        if (this._terminalInstances.length === 0) {
+            this._onDisposed.fire(this);
+            this.dispose();
+        }
+        else {
+            this._onInstancesChanged.fire();
+        }
+    }
+    moveInstance(instance, index) {
+        const sourceIndex = this.terminalInstances.indexOf(instance);
+        if (sourceIndex === -1) {
+            return;
+        }
+        this._terminalInstances.splice(sourceIndex, 1);
+        this._terminalInstances.splice(index, 0, instance);
+        if (this._splitPaneContainer) {
+            this._splitPaneContainer.remove(instance);
+            this._splitPaneContainer.split(instance, index);
+        }
+        this._onInstancesChanged.fire();
+    }
+    _setActiveInstance(instance) {
+        this.setActiveInstanceByIndex(this._getIndexFromId(instance.instanceId));
+    }
+    _getIndexFromId(terminalId) {
+        let terminalIndex = -1;
+        this.terminalInstances.forEach((terminalInstance, i) => {
+            if (terminalInstance.instanceId === terminalId) {
+                terminalIndex = i;
+            }
+        });
+        if (terminalIndex === -1) {
+            throw new Error(`Terminal with ID ${terminalId} does not exist (has it already been disposed?)`);
+        }
+        return terminalIndex;
+    }
+    setActiveInstanceByIndex(index, force) {
+        if (index < 0 || index >= this._terminalInstances.length) {
+            return;
+        }
+        const oldActiveInstance = this.activeInstance;
+        this._activeInstanceIndex = index;
+        if (oldActiveInstance !== this.activeInstance || force) {
+            this._onInstancesChanged.fire();
+            this._onDidChangeActiveInstance.fire(this.activeInstance);
+        }
+    }
+    attachToElement(element) {
+        this._container = element;
+        if (!this._groupElement) {
+            this._groupElement = document.createElement('div');
+            this._groupElement.classList.add('terminal-group');
+        }
+        this._container.appendChild(this._groupElement);
+        if (!this._splitPaneContainer) {
+            this._panelPosition = this._layoutService.getPanelPosition();
+            this._terminalLocation = this._viewDescriptorService.getViewLocationById(TERMINAL_VIEW_ID);
+            const orientation = this._terminalLocation === 1  && this._panelPosition === 2  ? 1  : 0 ;
+            this._splitPaneContainer = this._instantiationService.createInstance(SplitPaneContainer, this._groupElement, orientation);
+            this.terminalInstances.forEach(instance => this._splitPaneContainer.split(instance, this._activeInstanceIndex + 1));
+            if (this._initialRelativeSizes) {
+                this.resizePanes(this._initialRelativeSizes);
+                this._initialRelativeSizes = undefined;
+            }
+        }
+    }
+    get title() {
+        if (this._terminalInstances.length === 0) {
+            return '';
+        }
+        let title = this.terminalInstances[0].title + this._getBellTitle(this.terminalInstances[0]);
+        if (this.terminalInstances[0].description) {
+            title += ` (${this.terminalInstances[0].description})`;
+        }
+        for (let i = 1; i < this.terminalInstances.length; i++) {
+            const instance = this.terminalInstances[i];
+            if (instance.title) {
+                title += `, ${instance.title + this._getBellTitle(instance)}`;
+                if (instance.description) {
+                    title += ` (${instance.description})`;
+                }
+            }
+        }
+        return title;
+    }
+    _getBellTitle(instance) {
+        if (this._terminalService.configHelper.config.enableBell && ( instance.statusList.statuses.some(e => e.id === "bell" ))) {
+            return '*';
+        }
+        return '';
+    }
+    setVisible(visible) {
+        if (this._groupElement) {
+            this._groupElement.style.display = visible ? '' : 'none';
+        }
+        this.terminalInstances.forEach(i => i.setVisible(visible));
+    }
+    split(shellLaunchConfig) {
+        const instance = this._terminalInstanceService.createInstance(shellLaunchConfig, TerminalLocation.Panel);
+        this.addInstance(instance, shellLaunchConfig.parentTerminalId);
+        this._setActiveInstance(instance);
+        return instance;
+    }
+    addDisposable(disposable) {
+        this._register(disposable);
+    }
+    layout(width, height) {
+        if (this._splitPaneContainer) {
+            const newPanelPosition = this._layoutService.getPanelPosition();
+            const newTerminalLocation = this._viewDescriptorService.getViewLocationById(TERMINAL_VIEW_ID);
+            const terminalPositionChanged = newPanelPosition !== this._panelPosition || newTerminalLocation !== this._terminalLocation;
+            if (terminalPositionChanged) {
+                const newOrientation = newTerminalLocation === 1  && newPanelPosition === 2  ? 1  : 0 ;
+                this._splitPaneContainer.setOrientation(newOrientation);
+                this._panelPosition = newPanelPosition;
+                this._terminalLocation = newTerminalLocation;
+                this._onPanelOrientationChanged.fire(this._splitPaneContainer.orientation);
+            }
+            this._splitPaneContainer.layout(width, height);
+        }
+    }
+    focusPreviousPane() {
+        const newIndex = this._activeInstanceIndex === 0 ? this._terminalInstances.length - 1 : this._activeInstanceIndex - 1;
+        this.setActiveInstanceByIndex(newIndex);
+    }
+    focusNextPane() {
+        const newIndex = this._activeInstanceIndex === this._terminalInstances.length - 1 ? 0 : this._activeInstanceIndex + 1;
+        this.setActiveInstanceByIndex(newIndex);
+    }
+    resizePane(direction) {
+        if (!this._splitPaneContainer) {
+            return;
+        }
+        const isHorizontal = ((direction === 0  || direction === 1) );
+        const font = this._terminalService.configHelper.getFont();
+        const charSize = (isHorizontal ? font.charWidth : font.charHeight);
+        if (charSize) {
+            this._splitPaneContainer.resizePane(this._activeInstanceIndex, direction, charSize * 4 , getPartByLocation(this._terminalLocation));
+        }
+    }
+    resizePanes(relativeSizes) {
+        if (!this._splitPaneContainer) {
+            this._initialRelativeSizes = relativeSizes;
+            return;
+        }
+        this._splitPaneContainer.resizePanes(relativeSizes);
+    }
+};
+TerminalGroup = ( __decorate([
+    ( __param(2, ITerminalService)),
+    ( __param(3, ITerminalInstanceService)),
+    ( __param(4, IWorkbenchLayoutService)),
+    ( __param(5, IViewDescriptorService)),
+    ( __param(6, IInstantiationService))
+], TerminalGroup));
+export { TerminalGroup };