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

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

@@ -0,0 +1,79 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { TerminalInstance } from './terminalInstance.js';
+import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { TerminalConfigHelper } from './terminalConfigHelper.js';
+import { TerminalExtensions } from '../common/terminal.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { TerminalContextKeys } from '../common/terminalContextKey.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { IWorkbenchEnvironmentService } from '../../../services/environment/common/environmentService.js';
+let TerminalInstanceService = class TerminalInstanceService extends Disposable {
+    get onDidCreateInstance() { return this._onDidCreateInstance.event; }
+    constructor(_instantiationService, _contextKeyService, _environmentService) {
+        super();
+        this._instantiationService = _instantiationService;
+        this._contextKeyService = _contextKeyService;
+        this._environmentService = _environmentService;
+        this._backendRegistration = ( new Map());
+        this._onDidCreateInstance = ( new Emitter());
+        this._terminalShellTypeContextKey = TerminalContextKeys.shellType.bindTo(this._contextKeyService);
+        this._terminalInRunCommandPicker = TerminalContextKeys.inTerminalRunCommandPicker.bindTo(this._contextKeyService);
+        this._terminalSuggestWidgetVisibleContextKey = TerminalContextKeys.suggestWidgetVisible.bindTo(this._contextKeyService);
+        this._configHelper = _instantiationService.createInstance(TerminalConfigHelper);
+        for (const remoteAuthority of [undefined, _environmentService.remoteAuthority]) {
+            let resolve;
+            const p = ( new Promise(r => resolve = r));
+            this._backendRegistration.set(remoteAuthority, { promise: p, resolve: resolve });
+        }
+    }
+    createInstance(config, target) {
+        const shellLaunchConfig = this.convertProfileToShellLaunchConfig(config);
+        const instance = this._instantiationService.createInstance(TerminalInstance, this._terminalShellTypeContextKey, this._terminalInRunCommandPicker, this._terminalSuggestWidgetVisibleContextKey, this._configHelper, shellLaunchConfig);
+        instance.target = target;
+        this._onDidCreateInstance.fire(instance);
+        return instance;
+    }
+    convertProfileToShellLaunchConfig(shellLaunchConfigOrProfile, cwd) {
+        if (shellLaunchConfigOrProfile && 'profileName' in shellLaunchConfigOrProfile) {
+            const profile = shellLaunchConfigOrProfile;
+            if (!profile.path) {
+                return shellLaunchConfigOrProfile;
+            }
+            return {
+                executable: profile.path,
+                args: profile.args,
+                env: profile.env,
+                icon: profile.icon,
+                color: profile.color,
+                name: profile.overrideName ? profile.profileName : undefined,
+                cwd
+            };
+        }
+        if (shellLaunchConfigOrProfile) {
+            if (cwd) {
+                shellLaunchConfigOrProfile.cwd = cwd;
+            }
+            return shellLaunchConfigOrProfile;
+        }
+        return {};
+    }
+    async getBackend(remoteAuthority) {
+        let backend = ( Registry.as(TerminalExtensions.Backend)).getTerminalBackend(remoteAuthority);
+        if (!backend) {
+            await this._backendRegistration.get(remoteAuthority)?.promise;
+            backend = ( Registry.as(TerminalExtensions.Backend)).getTerminalBackend(remoteAuthority);
+        }
+        return backend;
+    }
+    didRegisterBackend(remoteAuthority) {
+        this._backendRegistration.get(remoteAuthority)?.resolve();
+    }
+};
+TerminalInstanceService = ( __decorate([
+    ( __param(0, IInstantiationService)),
+    ( __param(1, IContextKeyService)),
+    ( __param(2, IWorkbenchEnvironmentService))
+], TerminalInstanceService));
+export { TerminalInstanceService };

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

@@ -0,0 +1,82 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+import { ILabelService } from 'monaco-editor/esm/vs/platform/label/common/label.js';
+import { TerminalLocation } from '../../../../platform/terminal/common/terminal.js';
+import { terminalEditorId, ITerminalService, ITerminalEditorService, ITerminalGroupService, ITerminalInstanceService } from './terminal.js';
+import { parseTerminalUri } from './terminalUri.js';
+import { terminalStrings } from '../common/terminalStrings.js';
+import { RegisteredEditorPriority, IEditorResolverService } from '../../../services/editor/common/editorResolverService.js';
+import { IEmbedderTerminalService } from '../../../services/terminal/common/embedderTerminalService.js';
+let TerminalMainContribution = class TerminalMainContribution extends Disposable {
+    constructor(editorResolverService, embedderTerminalService, labelService, terminalService, terminalEditorService, terminalGroupService, terminalInstanceService) {
+        super();
+        editorResolverService.registerEditor(`${Schemas.vscodeTerminal}:/**`, {
+            id: terminalEditorId,
+            label: terminalStrings.terminal,
+            priority: RegisteredEditorPriority.exclusive
+        }, {
+            canSupportResource: uri => uri.scheme === Schemas.vscodeTerminal,
+            singlePerResource: true
+        }, {
+            createEditorInput: async ({ resource, options }) => {
+                let instance = terminalService.getInstanceFromResource(resource);
+                if (instance) {
+                    const sourceGroup = terminalGroupService.getGroupForInstance(instance);
+                    sourceGroup?.removeInstance(instance);
+                }
+                else {
+                    const terminalIdentifier = parseTerminalUri(resource);
+                    if (!terminalIdentifier.instanceId) {
+                        throw new Error('Terminal identifier without instanceId');
+                    }
+                    const primaryBackend = terminalService.getPrimaryBackend();
+                    if (!primaryBackend) {
+                        throw new Error('No terminal primary backend');
+                    }
+                    const attachPersistentProcess = await primaryBackend.requestDetachInstance(terminalIdentifier.workspaceId, terminalIdentifier.instanceId);
+                    if (!attachPersistentProcess) {
+                        throw new Error('No terminal persistent process to attach');
+                    }
+                    instance = terminalInstanceService.createInstance({ attachPersistentProcess }, TerminalLocation.Editor);
+                }
+                const resolvedResource = terminalEditorService.resolveResource(instance);
+                const editor = terminalEditorService.getInputFromResource(resolvedResource);
+                return {
+                    editor,
+                    options: {
+                        ...options,
+                        pinned: true,
+                        forceReload: true,
+                        override: terminalEditorId
+                    }
+                };
+            }
+        });
+        labelService.registerFormatter({
+            scheme: Schemas.vscodeTerminal,
+            formatting: {
+                label: '${path}',
+                separator: ''
+            }
+        });
+        embedderTerminalService.onDidCreateTerminal(async (embedderTerminal) => {
+            const terminal = await terminalService.createTerminal({
+                config: embedderTerminal,
+                location: TerminalLocation.Panel
+            });
+            terminalService.setActiveInstance(terminal);
+            await terminalService.revealActiveTerminal();
+        });
+    }
+};
+TerminalMainContribution = ( __decorate([
+    ( __param(0, IEditorResolverService)),
+    ( __param(1, IEmbedderTerminalService)),
+    ( __param(2, ILabelService)),
+    ( __param(3, ITerminalService)),
+    ( __param(4, ITerminalEditorService)),
+    ( __param(5, ITerminalGroupService)),
+    ( __param(6, ITerminalInstanceService))
+], TerminalMainContribution));
+export { TerminalMainContribution };