@codingame/monaco-vscode-api 1.82.4-next.1 → 1.82.5-next.0

package/vscode/src/vs/workbench/contrib/terminal/browser/terminalEditorService.js

@@ -1,239 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
-import { Disposable, toDisposable, dispose } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
-import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
-import { EditorActivation } from 'monaco-editor/esm/vs/platform/editor/common/editor.js';
-import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
-import { TerminalLocation } from '../../../../platform/terminal/common/terminal.js';
-import { ITerminalInstanceService } from './terminal.js';
-import { TerminalEditorInput } from './terminalEditorInput.js';
-import { getInstanceFromResource } from './terminalUri.js';
-import { TerminalContextKeys } from '../common/terminalContextKey.js';
-import { IEditorGroupsService } from '../../../services/editor/common/editorGroupsService.js';
-import { ACTIVE_GROUP, SIDE_GROUP, IEditorService } from '../../../services/editor/common/editorService.js';
-import { ILifecycleService } from '../../../services/lifecycle/common/lifecycle.js';
-let TerminalEditorService = class TerminalEditorService extends Disposable {
-    constructor(_editorService, _editorGroupsService, _terminalInstanceService, _instantiationService, lifecycleService, contextKeyService) {
-        super();
-        this._editorService = _editorService;
-        this._editorGroupsService = _editorGroupsService;
-        this._terminalInstanceService = _terminalInstanceService;
-        this._instantiationService = _instantiationService;
-        this.instances = [];
-        this._activeInstanceIndex = -1;
-        this._isShuttingDown = false;
-        this._editorInputs = ( new Map());
-        this._instanceDisposables = ( new Map());
-        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._onDidChangeActiveInstance = this._register(( new Emitter()));
-        this.onDidChangeActiveInstance = this._onDidChangeActiveInstance.event;
-        this._onDidChangeInstances = this._register(( new Emitter()));
-        this.onDidChangeInstances = this._onDidChangeInstances.event;
-        this._terminalEditorActive = TerminalContextKeys.terminalEditorActive.bindTo(contextKeyService);
-        this._register(toDisposable(() => {
-            for (const d of ( this._instanceDisposables.values())) {
-                dispose(d);
-            }
-        }));
-        this._register(lifecycleService.onWillShutdown(() => this._isShuttingDown = true));
-        this._register(this._editorService.onDidActiveEditorChange(() => {
-            const activeEditor = this._editorService.activeEditor;
-            const instance = activeEditor instanceof TerminalEditorInput ? activeEditor?.terminalInstance : undefined;
-            const terminalEditorActive = !!instance && activeEditor instanceof TerminalEditorInput;
-            this._terminalEditorActive.set(terminalEditorActive);
-            if (terminalEditorActive) {
-                activeEditor?.setGroup(this._editorService.activeEditorPane?.group);
-                this.setActiveInstance(instance);
-            }
-            else {
-                for (const instance of this.instances) {
-                    instance.resetFocusContextKey();
-                }
-            }
-        }));
-        this._register(this._editorService.onDidVisibleEditorsChange(() => {
-            const knownIds = ( this.instances.map(i => i.instanceId));
-            const terminalEditors = this._getActiveTerminalEditors();
-            const unknownEditor = terminalEditors.find(input => {
-                const inputId = input instanceof TerminalEditorInput ? input.terminalInstance?.instanceId : undefined;
-                if (inputId === undefined) {
-                    return false;
-                }
-                return !knownIds.includes(inputId);
-            });
-            if (unknownEditor instanceof TerminalEditorInput && unknownEditor.terminalInstance) {
-                this._editorInputs.set(unknownEditor.terminalInstance.resource.path, unknownEditor);
-                this.instances.push(unknownEditor.terminalInstance);
-            }
-        }));
-        this._register(this._editorService.onDidCloseEditor(e => {
-            const instance = e.editor instanceof TerminalEditorInput ? e.editor.terminalInstance : undefined;
-            if (instance) {
-                const instanceIndex = this.instances.findIndex(e => e === instance);
-                if (instanceIndex !== -1) {
-                    const wasActiveInstance = this.instances[instanceIndex] === this.activeInstance;
-                    this._removeInstance(instance);
-                    if (wasActiveInstance) {
-                        this.setActiveInstance(undefined);
-                    }
-                }
-            }
-        }));
-    }
-    _getActiveTerminalEditors() {
-        return this._editorService.visibleEditors.filter(e => e instanceof TerminalEditorInput && e.terminalInstance?.instanceId);
-    }
-    get activeInstance() {
-        if (this.instances.length === 0 || this._activeInstanceIndex === -1) {
-            return undefined;
-        }
-        return this.instances[this._activeInstanceIndex];
-    }
-    setActiveInstance(instance) {
-        this._activeInstanceIndex = instance ? this.instances.findIndex(e => e === instance) : -1;
-        this._onDidChangeActiveInstance.fire(this.activeInstance);
-    }
-    async focusActiveInstance() {
-        return this.activeInstance?.focusWhenReady(true);
-    }
-    async openEditor(instance, editorOptions) {
-        const resource = this.resolveResource(instance);
-        if (resource) {
-            await this._activeOpenEditorRequest?.promise;
-            this._activeOpenEditorRequest = {
-                instanceId: instance.instanceId,
-                promise: this._editorService.openEditor({
-                    resource,
-                    description: instance.description || instance.shellLaunchConfig.type,
-                    options: {
-                        pinned: true,
-                        forceReload: true,
-                        preserveFocus: editorOptions?.preserveFocus
-                    }
-                }, editorOptions?.viewColumn ?? ACTIVE_GROUP)
-            };
-            await this._activeOpenEditorRequest?.promise;
-            this._activeOpenEditorRequest = undefined;
-        }
-    }
-    resolveResource(instance) {
-        const resource = instance.resource;
-        const inputKey = resource.path;
-        const cachedEditor = this._editorInputs.get(inputKey);
-        if (cachedEditor) {
-            return cachedEditor.resource;
-        }
-        instance.target = TerminalLocation.Editor;
-        const input = this._instantiationService.createInstance(TerminalEditorInput, resource, instance);
-        this._registerInstance(inputKey, input, instance);
-        return input.resource;
-    }
-    getInputFromResource(resource) {
-        const input = this._editorInputs.get(resource.path);
-        if (!input) {
-            throw new Error(`Could not get input from resource: ${resource.path}`);
-        }
-        return input;
-    }
-    _registerInstance(inputKey, input, instance) {
-        this._editorInputs.set(inputKey, input);
-        this._instanceDisposables.set(inputKey, [
-            instance.onDidFocus(this._onDidFocusInstance.fire, this._onDidFocusInstance),
-            instance.onDisposed(this._onDidDisposeInstance.fire, this._onDidDisposeInstance),
-            instance.capabilities.onDidAddCapabilityType(() => this._onDidChangeInstanceCapability.fire(instance)),
-            instance.capabilities.onDidRemoveCapabilityType(() => this._onDidChangeInstanceCapability.fire(instance)),
-        ]);
-        this.instances.push(instance);
-        this._onDidChangeInstances.fire();
-    }
-    _removeInstance(instance) {
-        const inputKey = instance.resource.path;
-        this._editorInputs.delete(inputKey);
-        const instanceIndex = this.instances.findIndex(e => e === instance);
-        if (instanceIndex !== -1) {
-            this.instances.splice(instanceIndex, 1);
-        }
-        const disposables = this._instanceDisposables.get(inputKey);
-        this._instanceDisposables.delete(inputKey);
-        if (disposables) {
-            dispose(disposables);
-        }
-        this._onDidChangeInstances.fire();
-    }
-    getInstanceFromResource(resource) {
-        return getInstanceFromResource(this.instances, resource);
-    }
-    splitInstance(instanceToSplit, shellLaunchConfig = {}) {
-        if (instanceToSplit.target === TerminalLocation.Editor) {
-            const group = this._editorInputs.get(instanceToSplit.resource.path)?.group;
-            if (group) {
-                this._editorGroupsService.activateGroup(group);
-            }
-        }
-        const instance = this._terminalInstanceService.createInstance(shellLaunchConfig, TerminalLocation.Editor);
-        const resource = this.resolveResource(instance);
-        if (resource) {
-            this._editorService.openEditor({
-                resource: URI.revive(resource),
-                description: instance.description,
-                options: {
-                    pinned: true,
-                    forceReload: true
-                }
-            }, SIDE_GROUP);
-        }
-        return instance;
-    }
-    reviveInput(deserializedInput) {
-        if ('pid' in deserializedInput) {
-            const newDeserializedInput = { ...deserializedInput, findRevivedId: true };
-            const instance = this._terminalInstanceService.createInstance({ attachPersistentProcess: newDeserializedInput }, TerminalLocation.Editor);
-            const input = this._instantiationService.createInstance(TerminalEditorInput, instance.resource, instance);
-            this._registerInstance(instance.resource.path, input, instance);
-            return input;
-        }
-        else {
-            throw new Error(`Could not revive terminal editor input, ${deserializedInput}`);
-        }
-    }
-    detachInstance(instance) {
-        const inputKey = instance.resource.path;
-        const editorInput = this._editorInputs.get(inputKey);
-        editorInput?.detachInstance();
-        this._removeInstance(instance);
-        if (!this._isShuttingDown) {
-            editorInput?.dispose();
-        }
-    }
-    async revealActiveEditor(preserveFocus) {
-        const instance = this.activeInstance;
-        if (!instance) {
-            return;
-        }
-        if (this._activeOpenEditorRequest?.instanceId === instance.instanceId) {
-            return;
-        }
-        const editorInput = this._editorInputs.get(instance.resource.path);
-        this._editorService.openEditor(editorInput, {
-            pinned: true,
-            forceReload: true,
-            preserveFocus,
-            activation: EditorActivation.PRESERVE
-        });
-    }
-};
-TerminalEditorService = ( __decorate([
-    ( __param(0, IEditorService)),
-    ( __param(1, IEditorGroupsService)),
-    ( __param(2, ITerminalInstanceService)),
-    ( __param(3, IInstantiationService)),
-    ( __param(4, ILifecycleService)),
-    ( __param(5, IContextKeyService))
-], TerminalEditorService));
-export { TerminalEditorService };

package/vscode/src/vs/workbench/contrib/terminal/browser/terminalEvents.js

@@ -1,47 +0,0 @@
-import { EventMultiplexer, Event, DynamicListEventMultiplexer } from 'monaco-editor/esm/vs/base/common/event.js';
-import { DisposableMap, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-function createInstanceCapabilityEventMultiplexer(currentInstances, onAddInstance, onRemoveInstance, capabilityId, getEvent) {
-    const store = ( new DisposableStore());
-    const multiplexer = store.add(( new EventMultiplexer()));
-    const capabilityListeners = store.add(( new DisposableMap()));
-    function addCapability(instance, capability) {
-        const listener = multiplexer.add(( Event.map(getEvent(capability), data => ({ instance, data }))));
-        capabilityListeners.set(capability, listener);
-    }
-    for (const instance of currentInstances) {
-        const capability = instance.capabilities.get(capabilityId);
-        if (capability) {
-            addCapability(instance, capability);
-        }
-    }
-    const addCapabilityMultiplexer = ( new DynamicListEventMultiplexer(
-        currentInstances,
-        onAddInstance,
-        onRemoveInstance,
-        instance => ( Event.map(
-            instance.capabilities.onDidAddCapability,
-            changeEvent => ({ instance, changeEvent })
-        ))
-    ));
-    addCapabilityMultiplexer.event(e => {
-        if (e.changeEvent.id === capabilityId) {
-            addCapability(e.instance, e.changeEvent.capability);
-        }
-    });
-    const removeCapabilityMultiplexer = ( new DynamicListEventMultiplexer(
-        currentInstances,
-        onAddInstance,
-        onRemoveInstance,
-        instance => instance.capabilities.onDidRemoveCapability
-    ));
-    removeCapabilityMultiplexer.event(e => {
-        if (e.id === capabilityId) {
-            capabilityListeners.deleteAndDispose(e.capability);
-        }
-    });
-    return {
-        dispose: () => store.dispose(),
-        event: multiplexer.event
-    };
-}
-export { createInstanceCapabilityEventMultiplexer };

package/vscode/src/vs/workbench/contrib/terminal/browser/terminalExtensions.js

@@ -1,25 +0,0 @@
-import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
-function registerTerminalContribution(id, ctor, canRunInDetachedTerminals = false) {
-    TerminalContributionRegistry.INSTANCE.registerTerminalContribution({ id, ctor, canRunInDetachedTerminals });
-}
-var TerminalExtensionsRegistry;
-( (function(TerminalExtensionsRegistry) {
-    function getTerminalContributions() {
-        return TerminalContributionRegistry.INSTANCE.getTerminalContributions();
-    }
-    TerminalExtensionsRegistry.getTerminalContributions = getTerminalContributions;
-})(TerminalExtensionsRegistry || (TerminalExtensionsRegistry = {})));
-class TerminalContributionRegistry {
-    static { this.INSTANCE = ( new TerminalContributionRegistry()); }
-    constructor() {
-        this._terminalContributions = [];
-    }
-    registerTerminalContribution(description) {
-        this._terminalContributions.push(description);
-    }
-    getTerminalContributions() {
-        return this._terminalContributions.slice(0);
-    }
-}
-Registry.add("terminal.contributions" , TerminalContributionRegistry.INSTANCE);
-export { TerminalExtensionsRegistry, registerTerminalContribution };