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

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

@@ -0,0 +1,239 @@
+import { __decorate, __param } from '../../../../../../node_modules/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 = ( new Emitter());
+        this.onDidDisposeInstance = this._onDidDisposeInstance.event;
+        this._onDidFocusInstance = ( new Emitter());
+        this.onDidFocusInstance = this._onDidFocusInstance.event;
+        this._onDidChangeInstanceCapability = ( new Emitter());
+        this.onDidChangeInstanceCapability = this._onDidChangeInstanceCapability.event;
+        this._onDidChangeActiveInstance = ( new Emitter());
+        this.onDidChangeActiveInstance = this._onDidChangeActiveInstance.event;
+        this._onDidChangeInstances = ( 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.onDidAddCapability(() => this._onDidChangeInstanceCapability.fire(instance)),
+            instance.capabilities.onDidRemoveCapability(() => 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/dist/vscode/vs/workbench/contrib/terminal/browser/terminalExtensions.js

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