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

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

@@ -0,0 +1,372 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { timeout } from 'monaco-editor/esm/vs/base/common/async.js';
+import { Emitter, Event } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { IViewsService, IViewDescriptorService } from '../../../common/views.js';
+import { TerminalGroup } from './terminalGroup.js';
+import { getInstanceFromResource } from './terminalUri.js';
+import { TERMINAL_VIEW_ID } from '../common/terminal.js';
+import { TerminalContextKeys } from '../common/terminalContextKey.js';
+let TerminalGroupService = class TerminalGroupService extends Disposable {
+    get instances() {
+        return this.groups.reduce((p, c) => p.concat(c.terminalInstances), []);
+    }
+    constructor(_contextKeyService, _instantiationService, _viewsService, _viewDescriptorService, _configurationService) {
+        super();
+        this._contextKeyService = _contextKeyService;
+        this._instantiationService = _instantiationService;
+        this._viewsService = _viewsService;
+        this._viewDescriptorService = _viewDescriptorService;
+        this._configurationService = _configurationService;
+        this.groups = [];
+        this.activeGroupIndex = -1;
+        this._onDidChangeActiveGroup = ( new Emitter());
+        this.onDidChangeActiveGroup = this._onDidChangeActiveGroup.event;
+        this._onDidDisposeGroup = ( new Emitter());
+        this.onDidDisposeGroup = this._onDidDisposeGroup.event;
+        this._onDidChangeGroups = ( new Emitter());
+        this.onDidChangeGroups = this._onDidChangeGroups.event;
+        this._onDidShow = ( new Emitter());
+        this.onDidShow = this._onDidShow.event;
+        this._onDidDisposeInstance = ( new Emitter());
+        this.onDidDisposeInstance = this._onDidDisposeInstance.event;
+        this._onDidFocusInstance = ( new Emitter());
+        this.onDidFocusInstance = this._onDidFocusInstance.event;
+        this._onDidChangeActiveInstance = ( new Emitter());
+        this.onDidChangeActiveInstance = this._onDidChangeActiveInstance.event;
+        this._onDidChangeInstances = ( new Emitter());
+        this.onDidChangeInstances = this._onDidChangeInstances.event;
+        this._onDidChangeInstanceCapability = ( new Emitter());
+        this.onDidChangeInstanceCapability = this._onDidChangeInstanceCapability.event;
+        this._onDidChangePanelOrientation = ( new Emitter());
+        this.onDidChangePanelOrientation = this._onDidChangePanelOrientation.event;
+        this.onDidDisposeGroup(group => this._removeGroup(group));
+        this._terminalGroupCountContextKey = TerminalContextKeys.groupCount.bindTo(this._contextKeyService);
+        this.onDidChangeGroups(() => this._terminalGroupCountContextKey.set(this.groups.length));
+        Event.any(this.onDidChangeActiveGroup, this.onDidChangeInstances)(() => this.updateVisibility());
+    }
+    hidePanel() {
+        const panel = this._viewDescriptorService.getViewContainerByViewId(TERMINAL_VIEW_ID);
+        if (panel && this._viewDescriptorService.getViewContainerModel(panel).activeViewDescriptors.length === 1) {
+            this._viewsService.closeView(TERMINAL_VIEW_ID);
+            TerminalContextKeys.tabsMouse.bindTo(this._contextKeyService).set(false);
+        }
+    }
+    showTabs() {
+        this._configurationService.updateValue("terminal.integrated.tabs.enabled" , true);
+    }
+    get activeGroup() {
+        if (this.activeGroupIndex < 0 || this.activeGroupIndex >= this.groups.length) {
+            return undefined;
+        }
+        return this.groups[this.activeGroupIndex];
+    }
+    set activeGroup(value) {
+        if (value === undefined) {
+            return;
+        }
+        const index = this.groups.findIndex(e => e === value);
+        this.setActiveGroupByIndex(index);
+    }
+    get activeInstance() {
+        return this.activeGroup?.activeInstance;
+    }
+    setActiveInstance(instance) {
+        this.setActiveInstanceByIndex(this._getIndexFromId(instance.instanceId));
+    }
+    _getIndexFromId(terminalId) {
+        const terminalIndex = this.instances.findIndex(e => e.instanceId === terminalId);
+        if (terminalIndex === -1) {
+            throw new Error(`Terminal with ID ${terminalId} does not exist (has it already been disposed?)`);
+        }
+        return terminalIndex;
+    }
+    setContainer(container) {
+        this._container = container;
+        this.groups.forEach(group => group.attachToElement(container));
+    }
+    async focusTabs() {
+        if (this.instances.length === 0) {
+            return;
+        }
+        await this.showPanel(true);
+        const pane = this._viewsService.getActiveViewWithId(TERMINAL_VIEW_ID);
+        pane?.terminalTabbedView?.focusTabs();
+    }
+    async focusHover() {
+        if (this.instances.length === 0) {
+            return;
+        }
+        const pane = this._viewsService.getActiveViewWithId(TERMINAL_VIEW_ID);
+        pane?.terminalTabbedView?.focusHover();
+    }
+    async focusActiveInstance() {
+        return this.showPanel(true);
+    }
+    createGroup(slcOrInstance) {
+        const group = this._instantiationService.createInstance(TerminalGroup, this._container, slcOrInstance);
+        group.onPanelOrientationChanged((orientation) => this._onDidChangePanelOrientation.fire(orientation));
+        this.groups.push(group);
+        group.addDisposable(group.onDidDisposeInstance(this._onDidDisposeInstance.fire, this._onDidDisposeInstance));
+        group.addDisposable(group.onDidFocusInstance(this._onDidFocusInstance.fire, this._onDidFocusInstance));
+        group.addDisposable(group.onDidChangeActiveInstance(e => {
+            if (group === this.activeGroup) {
+                this._onDidChangeActiveInstance.fire(e);
+            }
+        }));
+        group.addDisposable(group.onDidChangeInstanceCapability(this._onDidChangeInstanceCapability.fire, this._onDidChangeInstanceCapability));
+        group.addDisposable(group.onInstancesChanged(this._onDidChangeInstances.fire, this._onDidChangeInstances));
+        group.addDisposable(group.onDisposed(this._onDidDisposeGroup.fire, this._onDidDisposeGroup));
+        if (group.terminalInstances.length > 0) {
+            this._onDidChangeInstances.fire();
+        }
+        if (this.instances.length === 1) {
+            this.setActiveInstanceByIndex(0);
+        }
+        this._onDidChangeGroups.fire();
+        return group;
+    }
+    async showPanel(focus) {
+        const pane = this._viewsService.getActiveViewWithId(TERMINAL_VIEW_ID)
+            ?? (await this._viewsService.openView(TERMINAL_VIEW_ID, focus));
+        pane?.setExpanded(true);
+        if (focus) {
+            await timeout(0);
+            const instance = this.activeInstance;
+            if (instance) {
+                if (pane && !pane.isVisible()) {
+                    await this._viewsService.openView(TERMINAL_VIEW_ID, focus);
+                }
+                await instance.focusWhenReady(true);
+            }
+        }
+        this._onDidShow.fire();
+    }
+    getInstanceFromResource(resource) {
+        return getInstanceFromResource(this.instances, resource);
+    }
+    _removeGroup(group) {
+        const activeGroup = this.activeGroup;
+        const wasActiveGroup = group === activeGroup;
+        const index = this.groups.indexOf(group);
+        if (index !== -1) {
+            this.groups.splice(index, 1);
+            this._onDidChangeGroups.fire();
+        }
+        if (wasActiveGroup) {
+            if (this.groups.length > 0) {
+                const newIndex = index < this.groups.length ? index : this.groups.length - 1;
+                this.setActiveGroupByIndex(newIndex, true);
+                this.activeInstance?.focus(true);
+            }
+        }
+        else {
+            if (this.activeGroupIndex > index) {
+                this.setActiveGroupByIndex(this.activeGroupIndex - 1);
+            }
+        }
+        if (this.activeGroupIndex >= this.groups.length) {
+            this.setActiveGroupByIndex(this.groups.length - 1);
+        }
+        this._onDidChangeInstances.fire();
+        this._onDidChangeGroups.fire();
+        if (wasActiveGroup) {
+            this._onDidChangeActiveGroup.fire(this.activeGroup);
+            this._onDidChangeActiveInstance.fire(this.activeInstance);
+        }
+    }
+    setActiveGroupByIndex(index, force) {
+        if (index === -1 && this.groups.length === 0) {
+            if (this.activeGroupIndex !== -1) {
+                this.activeGroupIndex = -1;
+                this._onDidChangeActiveGroup.fire(this.activeGroup);
+                this._onDidChangeActiveInstance.fire(this.activeInstance);
+            }
+            return;
+        }
+        if (index < 0 || index >= this.groups.length) {
+            return;
+        }
+        const oldActiveGroup = this.activeGroup;
+        this.activeGroupIndex = index;
+        if (force || oldActiveGroup !== this.activeGroup) {
+            this._onDidChangeActiveGroup.fire(this.activeGroup);
+            this._onDidChangeActiveInstance.fire(this.activeInstance);
+        }
+    }
+    _getInstanceLocation(index) {
+        let currentGroupIndex = 0;
+        while (index >= 0 && currentGroupIndex < this.groups.length) {
+            const group = this.groups[currentGroupIndex];
+            const count = group.terminalInstances.length;
+            if (index < count) {
+                return {
+                    group,
+                    groupIndex: currentGroupIndex,
+                    instance: group.terminalInstances[index],
+                    instanceIndex: index
+                };
+            }
+            index -= count;
+            currentGroupIndex++;
+        }
+        return undefined;
+    }
+    setActiveInstanceByIndex(index) {
+        const activeInstance = this.activeInstance;
+        const instanceLocation = this._getInstanceLocation(index);
+        const newActiveInstance = instanceLocation?.group.terminalInstances[instanceLocation.instanceIndex];
+        if (!instanceLocation || activeInstance === newActiveInstance) {
+            return;
+        }
+        const activeInstanceIndex = instanceLocation.instanceIndex;
+        this.activeGroupIndex = instanceLocation.groupIndex;
+        this._onDidChangeActiveGroup.fire(this.activeGroup);
+        instanceLocation.group.setActiveInstanceByIndex(activeInstanceIndex, true);
+    }
+    setActiveGroupToNext() {
+        if (this.groups.length <= 1) {
+            return;
+        }
+        let newIndex = this.activeGroupIndex + 1;
+        if (newIndex >= this.groups.length) {
+            newIndex = 0;
+        }
+        this.setActiveGroupByIndex(newIndex);
+    }
+    setActiveGroupToPrevious() {
+        if (this.groups.length <= 1) {
+            return;
+        }
+        let newIndex = this.activeGroupIndex - 1;
+        if (newIndex < 0) {
+            newIndex = this.groups.length - 1;
+        }
+        this.setActiveGroupByIndex(newIndex);
+    }
+    moveGroup(source, target) {
+        const sourceGroup = this.getGroupForInstance(source);
+        const targetGroup = this.getGroupForInstance(target);
+        if (!sourceGroup || !targetGroup) {
+            return;
+        }
+        if (sourceGroup === targetGroup) {
+            const index = sourceGroup.terminalInstances.indexOf(target);
+            if (index !== -1) {
+                sourceGroup.moveInstance(source, index);
+            }
+            return;
+        }
+        const sourceGroupIndex = this.groups.indexOf(sourceGroup);
+        const targetGroupIndex = this.groups.indexOf(targetGroup);
+        this.groups.splice(sourceGroupIndex, 1);
+        this.groups.splice(targetGroupIndex, 0, sourceGroup);
+        this._onDidChangeInstances.fire();
+    }
+    moveGroupToEnd(source) {
+        const sourceGroup = this.getGroupForInstance(source);
+        if (!sourceGroup) {
+            return;
+        }
+        const sourceGroupIndex = this.groups.indexOf(sourceGroup);
+        this.groups.splice(sourceGroupIndex, 1);
+        this.groups.push(sourceGroup);
+        this._onDidChangeInstances.fire();
+    }
+    moveInstance(source, target, side) {
+        const sourceGroup = this.getGroupForInstance(source);
+        const targetGroup = this.getGroupForInstance(target);
+        if (!sourceGroup || !targetGroup) {
+            return;
+        }
+        if (sourceGroup !== targetGroup) {
+            sourceGroup.removeInstance(source);
+            targetGroup.addInstance(source);
+        }
+        const index = targetGroup.terminalInstances.indexOf(target) + (side === 'after' ? 1 : 0);
+        targetGroup.moveInstance(source, index);
+    }
+    unsplitInstance(instance) {
+        const oldGroup = this.getGroupForInstance(instance);
+        if (!oldGroup || oldGroup.terminalInstances.length < 2) {
+            return;
+        }
+        oldGroup.removeInstance(instance);
+        this.createGroup(instance);
+    }
+    joinInstances(instances) {
+        const group = this.getGroupForInstance(instances[0]);
+        if (group) {
+            let differentGroups = true;
+            for (let i = 1; i < group.terminalInstances.length; i++) {
+                if (group.terminalInstances.includes(instances[i])) {
+                    differentGroups = false;
+                    break;
+                }
+            }
+            if (!differentGroups) {
+                return;
+            }
+        }
+        let candidateInstance = undefined;
+        let candidateGroup = undefined;
+        for (const instance of instances) {
+            const group = this.getGroupForInstance(instance);
+            if (group?.terminalInstances.length === 1) {
+                candidateInstance = instance;
+                candidateGroup = group;
+                break;
+            }
+        }
+        if (!candidateGroup) {
+            candidateGroup = this.createGroup();
+        }
+        const wasActiveGroup = this.activeGroup === candidateGroup;
+        for (const instance of instances) {
+            if (instance === candidateInstance) {
+                continue;
+            }
+            const oldGroup = this.getGroupForInstance(instance);
+            if (!oldGroup) {
+                continue;
+            }
+            oldGroup.removeInstance(instance);
+            candidateGroup.addInstance(instance);
+        }
+        this.setActiveInstance(instances[0]);
+        this._onDidChangeInstances.fire();
+        if (!wasActiveGroup) {
+            this._onDidChangeActiveGroup.fire(this.activeGroup);
+        }
+    }
+    instanceIsSplit(instance) {
+        const group = this.getGroupForInstance(instance);
+        if (!group) {
+            return false;
+        }
+        return group.terminalInstances.length > 1;
+    }
+    getGroupForInstance(instance) {
+        return this.groups.find(group => group.terminalInstances.includes(instance));
+    }
+    getGroupLabels() {
+        return ( this.groups.filter(group => group.terminalInstances.length > 0).map((group, index) => {
+            return `${index + 1}: ${group.title ? group.title : ''}`;
+        }));
+    }
+    updateVisibility() {
+        const visible = this._viewsService.isViewVisible(TERMINAL_VIEW_ID);
+        this.groups.forEach((g, i) => g.setVisible(visible && i === this.activeGroupIndex));
+    }
+};
+TerminalGroupService = ( __decorate([
+    ( __param(0, IContextKeyService)),
+    ( __param(1, IInstantiationService)),
+    ( __param(2, IViewsService)),
+    ( __param(3, IViewDescriptorService)),
+    ( __param(4, IConfigurationService))
+], TerminalGroupService));
+export { TerminalGroupService };

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

@@ -0,0 +1,103 @@
+import { hash } from 'monaco-editor/esm/vs/base/common/hash.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { getIconRegistry } from 'monaco-editor/esm/vs/platform/theme/common/iconRegistry.js';
+import { ColorScheme } from 'monaco-editor/esm/vs/platform/theme/common/theme.js';
+import { ThemeIcon } from 'monaco-editor/esm/vs/base/common/themables.js';
+import { ITerminalProfileResolverService } from '../common/terminal.js';
+import { ansiColorMap } from '../common/terminalColorRegistry.js';
+function getColorClass(terminalOrColorKey) {
+    let color = undefined;
+    if (typeof terminalOrColorKey === 'string') {
+        color = terminalOrColorKey;
+    }
+    else if (terminalOrColorKey.color) {
+        color = terminalOrColorKey.color.replace(/\./g, '_');
+    }
+    else if (ThemeIcon.isThemeIcon(terminalOrColorKey.icon) && terminalOrColorKey.icon.color) {
+        color = terminalOrColorKey.icon.color.id.replace(/\./g, '_');
+    }
+    if (color) {
+        return `terminal-icon-${color.replace(/\./g, '_')}`;
+    }
+    return undefined;
+}
+function getStandardColors(colorTheme) {
+    const standardColors = [];
+    for (const colorKey in ansiColorMap) {
+        const color = colorTheme.getColor(colorKey);
+        if (color && !colorKey.toLowerCase().includes('bright')) {
+            standardColors.push(colorKey);
+        }
+    }
+    return standardColors;
+}
+function getColorStyleElement(colorTheme) {
+    const standardColors = getStandardColors(colorTheme);
+    const styleElement = document.createElement('style');
+    let css = '';
+    for (const colorKey of standardColors) {
+        const colorClass = getColorClass(colorKey);
+        const color = colorTheme.getColor(colorKey);
+        if (color) {
+            css += (`.monaco-workbench .${colorClass} .codicon:first-child:not(.codicon-split-horizontal):not(.codicon-trashcan):not(.file-icon)` +
+                `{ color: ${color} !important; }`);
+        }
+    }
+    styleElement.textContent = css;
+    return styleElement;
+}
+function getColorStyleContent(colorTheme, editor) {
+    const standardColors = getStandardColors(colorTheme);
+    let css = '';
+    for (const colorKey of standardColors) {
+        const colorClass = getColorClass(colorKey);
+        const color = colorTheme.getColor(colorKey);
+        if (color) {
+            if (editor) {
+                css += (`.monaco-workbench .show-file-icons .file-icon.terminal-tab.${colorClass}::before` +
+                    `{ color: ${color} !important; }`);
+            }
+            else {
+                css += (`.monaco-workbench .${colorClass} .codicon:first-child:not(.codicon-split-horizontal):not(.codicon-trashcan):not(.file-icon)` +
+                    `{ color: ${color} !important; }`);
+            }
+        }
+    }
+    return css;
+}
+function getUriClasses(terminal, colorScheme, extensionContributed) {
+    const icon = terminal.icon;
+    if (!icon) {
+        return undefined;
+    }
+    const iconClasses = [];
+    let uri = undefined;
+    if (extensionContributed) {
+        if (typeof icon === 'string' && (icon.startsWith('$(') || getIconRegistry().getIcon(icon))) {
+            return iconClasses;
+        }
+        else if (typeof icon === 'string') {
+            uri = ( URI.parse(icon));
+        }
+    }
+    if (icon instanceof URI) {
+        uri = icon;
+    }
+    else if (icon instanceof Object && 'light' in icon && 'dark' in icon) {
+        uri = colorScheme === ColorScheme.LIGHT ? icon.light : icon.dark;
+    }
+    if (uri instanceof URI) {
+        const uriIconKey = ( hash(uri.path).toString(36));
+        const className = `terminal-uri-icon-${uriIconKey}`;
+        iconClasses.push(className);
+        iconClasses.push(`terminal-uri-icon`);
+    }
+    return iconClasses;
+}
+function getIconId(accessor, terminal) {
+    if (!terminal.icon || (terminal.icon instanceof Object && !('id' in terminal.icon))) {
+        return accessor.get(ITerminalProfileResolverService).getDefaultIcon().id;
+    }
+    return typeof terminal.icon === 'string' ? terminal.icon : terminal.icon.id;
+}
+export { getColorClass, getColorStyleContent, getColorStyleElement, getIconId, getStandardColors, getUriClasses };

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

@@ -0,0 +1,37 @@
+import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { registerIcon } from 'monaco-editor/esm/vs/platform/theme/common/iconRegistry.js';
+const terminalViewIcon = registerIcon('terminal-view-icon', Codicon.terminal, ( localize('terminalViewIcon', 'View icon of the terminal view.')));
+const renameTerminalIcon = registerIcon('terminal-rename', Codicon.gear, ( localize('renameTerminalIcon', 'Icon for rename in the terminal quick menu.')));
+const killTerminalIcon = registerIcon('terminal-kill', Codicon.trash, ( localize('killTerminalIcon', 'Icon for killing a terminal instance.')));
+const newTerminalIcon = registerIcon('terminal-new', Codicon.add, ( localize('newTerminalIcon', 'Icon for creating a new terminal instance.')));
+const configureTerminalProfileIcon = registerIcon('terminal-configure-profile', Codicon.gear, ( localize(
+ 'configureTerminalProfileIcon',
+ 'Icon for creating a new terminal profile.'
+)));
+const terminalDecorationMark = registerIcon('terminal-decoration-mark', Codicon.circleSmallFilled, ( localize('terminalDecorationMark', 'Icon for a terminal decoration mark.')));
+const terminalDecorationIncomplete = registerIcon('terminal-decoration-incomplete', Codicon.circle, ( localize(
+ 'terminalDecorationIncomplete',
+ 'Icon for a terminal decoration of a command that was incomplete.'
+)));
+const terminalDecorationError = registerIcon('terminal-decoration-error', Codicon.errorSmall, ( localize(
+ 'terminalDecorationError',
+ 'Icon for a terminal decoration of a command that errored.'
+)));
+const terminalDecorationSuccess = registerIcon('terminal-decoration-success', Codicon.circleFilled, ( localize(
+ 'terminalDecorationSuccess',
+ 'Icon for a terminal decoration of a command that was successful.'
+)));
+const commandHistoryRemoveIcon = registerIcon('terminal-command-history-remove', Codicon.close, ( localize(
+ 'terminalCommandHistoryRemove',
+ 'Icon for removing a terminal command from command history.'
+)));
+const commandHistoryOutputIcon = registerIcon('terminal-command-history-output', Codicon.output, ( localize(
+ 'terminalCommandHistoryOutput',
+ 'Icon for viewing output of a terminal command.'
+)));
+const commandHistoryFuzzySearchIcon = registerIcon('terminal-command-history-fuzzy-search', Codicon.searchFuzzy, ( localize(
+ 'terminalCommandHistoryFuzzySearch',
+ 'Icon for toggling fuzzy search of command history.'
+)));
+export { commandHistoryFuzzySearchIcon, commandHistoryOutputIcon, commandHistoryRemoveIcon, configureTerminalProfileIcon, killTerminalIcon, newTerminalIcon, renameTerminalIcon, terminalDecorationError, terminalDecorationIncomplete, terminalDecorationMark, terminalDecorationSuccess, terminalViewIcon };