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

package/vscode/src/vs/workbench/contrib/snippets/browser/commands/insertSnippet.js

@@ -1,126 +0,0 @@
-import { EditorContextKeys } from 'monaco-editor/esm/vs/editor/common/editorContextKeys.js';
-import { ILanguageService } from 'monaco-editor/esm/vs/editor/common/languages/language.js';
-import { SnippetController2 } from 'monaco-editor/esm/vs/editor/contrib/snippet/browser/snippetController2.js';
-import * as nls from 'monaco-editor/esm/vs/nls.js';
-import { IClipboardService } from 'monaco-editor/esm/vs/platform/clipboard/common/clipboardService.js';
-import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
-import { SnippetEditorAction } from './abstractSnippetsActions.js';
-import { pickSnippet } from '../snippetPicker.js';
-import { ISnippetsService } from '../snippets.js';
-import { Snippet } from '../snippetsFile.js';
-class Args {
-    static fromUser(arg) {
-        if (!arg || typeof arg !== 'object') {
-            return Args._empty;
-        }
-        let { snippet, name, langId } = arg;
-        if (typeof snippet !== 'string') {
-            snippet = undefined;
-        }
-        if (typeof name !== 'string') {
-            name = undefined;
-        }
-        if (typeof langId !== 'string') {
-            langId = undefined;
-        }
-        return ( new Args(snippet, name, langId));
-    }
-    static { this._empty = ( new Args(undefined, undefined, undefined)); }
-    constructor(snippet, name, langId) {
-        this.snippet = snippet;
-        this.name = name;
-        this.langId = langId;
-    }
-}
-class InsertSnippetAction extends SnippetEditorAction {
-    constructor() {
-        super({
-            id: 'editor.action.insertSnippet',
-            title: {
-                value: ( nls.localize('snippet.suggestions.label', "Insert Snippet")),
-                original: 'Insert Snippet'
-            },
-            f1: true,
-            precondition: EditorContextKeys.writable,
-            description: {
-                description: `Insert Snippet`,
-                args: [{
-                        name: 'args',
-                        schema: {
-                            'type': 'object',
-                            'properties': {
-                                'snippet': {
-                                    'type': 'string'
-                                },
-                                'langId': {
-                                    'type': 'string',
-                                },
-                                'name': {
-                                    'type': 'string'
-                                }
-                            },
-                        }
-                    }]
-            }
-        });
-    }
-    async runEditorCommand(accessor, editor, arg) {
-        const languageService = accessor.get(ILanguageService);
-        const snippetService = accessor.get(ISnippetsService);
-        if (!editor.hasModel()) {
-            return;
-        }
-        const clipboardService = accessor.get(IClipboardService);
-        const instaService = accessor.get(IInstantiationService);
-        const snippet = await ( new Promise((resolve, reject) => {
-            const { lineNumber, column } = editor.getPosition();
-            const { snippet, name, langId } = Args.fromUser(arg);
-            if (snippet) {
-                return resolve(( new Snippet(
-                    false,
-                    [],
-                    '',
-                    '',
-                    '',
-                    snippet,
-                    '',
-                    1 ,
-                    `random/${Math.random()}`
-                )));
-            }
-            let languageId;
-            if (langId) {
-                if (!languageService.isRegisteredLanguageId(langId)) {
-                    return resolve(undefined);
-                }
-                languageId = langId;
-            }
-            else {
-                editor.getModel().tokenization.tokenizeIfCheap(lineNumber);
-                languageId = editor.getModel().getLanguageIdAtPosition(lineNumber, column);
-                if (!languageService.getLanguageName(languageId)) {
-                    languageId = editor.getModel().getLanguageId();
-                }
-            }
-            if (name) {
-                snippetService.getSnippets(languageId, { includeNoPrefixSnippets: true })
-                    .then(snippets => snippets.find(snippet => snippet.name === name))
-                    .then(resolve, reject);
-            }
-            else {
-                resolve(instaService.invokeFunction(pickSnippet, languageId));
-            }
-        }));
-        if (!snippet) {
-            return;
-        }
-        let clipboardText;
-        if (snippet.needsClipboard) {
-            clipboardText = await clipboardService.readText();
-        }
-        editor.focus();
-        SnippetController2.get(editor)?.insert(snippet.codeSnippet, { clipboardText });
-        snippetService.updateUsageTimestamp(snippet);
-    }
-}
-export { InsertSnippetAction };

package/vscode/src/vs/workbench/contrib/snippets/browser/commands/surroundWithSnippet.js

@@ -1,56 +0,0 @@
-import { EditorContextKeys } from 'monaco-editor/esm/vs/editor/common/editorContextKeys.js';
-import { SnippetController2 } from 'monaco-editor/esm/vs/editor/contrib/snippet/browser/snippetController2.js';
-import { localize } from 'monaco-editor/esm/vs/nls.js';
-import { IClipboardService } from 'monaco-editor/esm/vs/platform/clipboard/common/clipboardService.js';
-import { ContextKeyExpr } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
-import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
-import { SnippetEditorAction } from './abstractSnippetsActions.js';
-import { pickSnippet } from '../snippetPicker.js';
-import { ISnippetsService } from '../snippets.js';
-async function getSurroundableSnippets(snippetsService, model, position, includeDisabledSnippets) {
-    const { lineNumber, column } = position;
-    model.tokenization.tokenizeIfCheap(lineNumber);
-    const languageId = model.getLanguageIdAtPosition(lineNumber, column);
-    const allSnippets = await snippetsService.getSnippets(languageId, { includeNoPrefixSnippets: true, includeDisabledSnippets });
-    return allSnippets.filter(snippet => snippet.usesSelection);
-}
-class SurroundWithSnippetEditorAction extends SnippetEditorAction {
-    static { this.options = {
-        id: 'editor.action.surroundWithSnippet',
-        title: {
-            value: ( localize('label', 'Surround With Snippet...')),
-            original: 'Surround With Snippet...'
-        }
-    }; }
-    constructor() {
-        super({
-            ...SurroundWithSnippetEditorAction.options,
-            precondition: ( ContextKeyExpr.and(EditorContextKeys.writable, EditorContextKeys.hasNonEmptySelection)),
-            f1: true,
-        });
-    }
-    async runEditorCommand(accessor, editor) {
-        if (!editor.hasModel()) {
-            return;
-        }
-        const instaService = accessor.get(IInstantiationService);
-        const snippetsService = accessor.get(ISnippetsService);
-        const clipboardService = accessor.get(IClipboardService);
-        const snippets = await getSurroundableSnippets(snippetsService, editor.getModel(), editor.getPosition(), true);
-        if (!snippets.length) {
-            return;
-        }
-        const snippet = await instaService.invokeFunction(pickSnippet, snippets);
-        if (!snippet) {
-            return;
-        }
-        let clipboardText;
-        if (snippet.needsClipboard) {
-            clipboardText = await clipboardService.readText();
-        }
-        editor.focus();
-        SnippetController2.get(editor)?.insert(snippet.codeSnippet, { clipboardText });
-        snippetsService.updateUsageTimestamp(snippet);
-    }
-}
-export { SurroundWithSnippetEditorAction, getSurroundableSnippets };

package/vscode/src/vs/workbench/contrib/snippets/browser/snippetCodeActionProvider.js

@@ -1,136 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { Selection } from 'monaco-editor/esm/vs/editor/common/core/selection.js';
-import { ILanguageFeaturesService } from 'monaco-editor/esm/vs/editor/common/services/languageFeatures.js';
-import { CodeActionKind } from 'monaco-editor/esm/vs/editor/contrib/codeAction/common/types.js';
-import { localize } from 'monaco-editor/esm/vs/nls.js';
-import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
-import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
-import { ApplyFileSnippetAction } from './commands/fileTemplateSnippets.js';
-import { SurroundWithSnippetEditorAction, getSurroundableSnippets } from './commands/surroundWithSnippet.js';
-import { ISnippetsService } from './snippets.js';
-var SurroundWithSnippetCodeActionProvider_1, FileTemplateCodeActionProvider_1;
-let SurroundWithSnippetCodeActionProvider = class SurroundWithSnippetCodeActionProvider {
-    static { SurroundWithSnippetCodeActionProvider_1 = this; }
-    static { this._MAX_CODE_ACTIONS = 4; }
-    static { this._overflowCommandCodeAction = {
-        kind: CodeActionKind.SurroundWith.value,
-        title: SurroundWithSnippetEditorAction.options.title.value,
-        command: {
-            id: SurroundWithSnippetEditorAction.options.id,
-            title: SurroundWithSnippetEditorAction.options.title.value,
-        },
-    }; }
-    constructor(_snippetService) {
-        this._snippetService = _snippetService;
-    }
-    async provideCodeActions(model, range) {
-        if (range.isEmpty()) {
-            return undefined;
-        }
-        const position = Selection.isISelection(range) ? range.getPosition() : range.getStartPosition();
-        const snippets = await getSurroundableSnippets(this._snippetService, model, position, false);
-        if (!snippets.length) {
-            return undefined;
-        }
-        const actions = [];
-        for (const snippet of snippets) {
-            if (actions.length >= SurroundWithSnippetCodeActionProvider_1._MAX_CODE_ACTIONS) {
-                actions.push(SurroundWithSnippetCodeActionProvider_1._overflowCommandCodeAction);
-                break;
-            }
-            actions.push({
-                title: ( localize('codeAction', "Surround With: {0}", snippet.name)),
-                kind: CodeActionKind.SurroundWith.value,
-                edit: asWorkspaceEdit(model, range, snippet)
-            });
-        }
-        return {
-            actions,
-            dispose() { }
-        };
-    }
-};
-SurroundWithSnippetCodeActionProvider = SurroundWithSnippetCodeActionProvider_1 = ( __decorate([
-    ( __param(0, ISnippetsService))
-], SurroundWithSnippetCodeActionProvider));
-let FileTemplateCodeActionProvider = class FileTemplateCodeActionProvider {
-    static { FileTemplateCodeActionProvider_1 = this; }
-    static { this._MAX_CODE_ACTIONS = 4; }
-    static { this._overflowCommandCodeAction = {
-        title: ( localize('overflow.start.title', 'Start with Snippet')),
-        kind: CodeActionKind.SurroundWith.value,
-        command: {
-            id: ApplyFileSnippetAction.Id,
-            title: ''
-        }
-    }; }
-    constructor(_snippetService) {
-        this._snippetService = _snippetService;
-        this.providedCodeActionKinds = [CodeActionKind.SurroundWith.value];
-    }
-    async provideCodeActions(model) {
-        if (model.getValueLength() !== 0) {
-            return undefined;
-        }
-        const snippets = await this._snippetService.getSnippets(model.getLanguageId(), { fileTemplateSnippets: true, includeNoPrefixSnippets: true });
-        const actions = [];
-        for (const snippet of snippets) {
-            if (actions.length >= FileTemplateCodeActionProvider_1._MAX_CODE_ACTIONS) {
-                actions.push(FileTemplateCodeActionProvider_1._overflowCommandCodeAction);
-                break;
-            }
-            actions.push({
-                title: ( localize('title', 'Start with: {0}', snippet.name)),
-                kind: CodeActionKind.SurroundWith.value,
-                edit: asWorkspaceEdit(model, model.getFullModelRange(), snippet)
-            });
-        }
-        return {
-            actions,
-            dispose() { }
-        };
-    }
-};
-FileTemplateCodeActionProvider = FileTemplateCodeActionProvider_1 = ( __decorate([
-    ( __param(0, ISnippetsService))
-], FileTemplateCodeActionProvider));
-function asWorkspaceEdit(model, range, snippet) {
-    return {
-        edits: [{
-                versionId: model.getVersionId(),
-                resource: model.uri,
-                textEdit: {
-                    range,
-                    text: snippet.body,
-                    insertAsSnippet: true,
-                }
-            }]
-    };
-}
-let SnippetCodeActions = class SnippetCodeActions {
-    constructor(instantiationService, languageFeaturesService, configService) {
-        this._store = ( new DisposableStore());
-        const setting = 'editor.snippets.codeActions.enabled';
-        const sessionStore = ( new DisposableStore());
-        const update = () => {
-            sessionStore.clear();
-            if (configService.getValue(setting)) {
-                sessionStore.add(languageFeaturesService.codeActionProvider.register('*', instantiationService.createInstance(SurroundWithSnippetCodeActionProvider)));
-                sessionStore.add(languageFeaturesService.codeActionProvider.register('*', instantiationService.createInstance(FileTemplateCodeActionProvider)));
-            }
-        };
-        update();
-        this._store.add(configService.onDidChangeConfiguration(e => e.affectsConfiguration(setting) && update()));
-        this._store.add(sessionStore);
-    }
-    dispose() {
-        this._store.dispose();
-    }
-};
-SnippetCodeActions = ( __decorate([
-    ( __param(0, IInstantiationService)),
-    ( __param(1, ILanguageFeaturesService)),
-    ( __param(2, IConfigurationService))
-], SnippetCodeActions));
-export { SnippetCodeActions };

package/vscode/src/vs/workbench/contrib/snippets/browser/snippetPicker.js

@@ -1,83 +0,0 @@
-import * as nls from 'monaco-editor/esm/vs/nls.js';
-import { ISnippetsService } from './snippets.js';
-import { IQuickInputService } from 'monaco-editor/esm/vs/platform/quickinput/common/quickInput.js';
-import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
-import { ThemeIcon } from 'monaco-editor/esm/vs/base/common/themables.js';
-import { Event } from 'monaco-editor/esm/vs/base/common/event.js';
-async function pickSnippet(accessor, languageIdOrSnippets) {
-    const snippetService = accessor.get(ISnippetsService);
-    const quickInputService = accessor.get(IQuickInputService);
-    let snippets;
-    if (Array.isArray(languageIdOrSnippets)) {
-        snippets = languageIdOrSnippets;
-    }
-    else {
-        snippets = (await snippetService.getSnippets(languageIdOrSnippets, { includeDisabledSnippets: true, includeNoPrefixSnippets: true }));
-    }
-    snippets.sort((a, b) => a.snippetSource - b.snippetSource);
-    const makeSnippetPicks = () => {
-        const result = [];
-        let prevSnippet;
-        for (const snippet of snippets) {
-            const pick = {
-                label: snippet.prefix || snippet.name,
-                detail: snippet.description || snippet.body,
-                snippet
-            };
-            if (!prevSnippet || prevSnippet.snippetSource !== snippet.snippetSource || prevSnippet.source !== snippet.source) {
-                let label = '';
-                switch (snippet.snippetSource) {
-                    case 1 :
-                        label = ( nls.localize('sep.userSnippet', "User Snippets"));
-                        break;
-                    case 3 :
-                        label = snippet.source;
-                        break;
-                    case 2 :
-                        label = ( nls.localize('sep.workspaceSnippet', "Workspace Snippets"));
-                        break;
-                }
-                result.push({ type: 'separator', label });
-            }
-            if (snippet.snippetSource === 3 ) {
-                const isEnabled = snippetService.isEnabled(snippet);
-                if (isEnabled) {
-                    pick.buttons = [{
-                            iconClass: ThemeIcon.asClassName(Codicon.eyeClosed),
-                            tooltip: ( nls.localize('disableSnippet', 'Hide from IntelliSense'))
-                        }];
-                }
-                else {
-                    pick.description = ( nls.localize('isDisabled', "(hidden from IntelliSense)"));
-                    pick.buttons = [{
-                            iconClass: ThemeIcon.asClassName(Codicon.eye),
-                            tooltip: ( nls.localize('enable.snippet', 'Show in IntelliSense'))
-                        }];
-                }
-            }
-            result.push(pick);
-            prevSnippet = snippet;
-        }
-        return result;
-    };
-    const picker = quickInputService.createQuickPick();
-    picker.placeholder = ( nls.localize('pick.placeholder', "Select a snippet"));
-    picker.matchOnDetail = true;
-    picker.ignoreFocusOut = false;
-    picker.keepScrollPosition = true;
-    picker.onDidTriggerItemButton(ctx => {
-        const isEnabled = snippetService.isEnabled(ctx.item.snippet);
-        snippetService.updateEnablement(ctx.item.snippet, !isEnabled);
-        picker.items = makeSnippetPicks();
-    });
-    picker.items = makeSnippetPicks();
-    if (!picker.items.length) {
-        picker.validationMessage = ( nls.localize('pick.noSnippetAvailable', "No snippet available"));
-    }
-    picker.show();
-    await Promise.race([Event.toPromise(picker.onDidAccept), Event.toPromise(picker.onDidHide)]);
-    const result = picker.selectedItems[0]?.snippet;
-    picker.dispose();
-    return result;
-}
-export { pickSnippet };

package/vscode/src/vs/workbench/contrib/snippets/browser/snippets.contribution.js

@@ -1,113 +0,0 @@
-import * as nls from 'monaco-editor/esm/vs/nls.js';
-import { registerAction2 } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
-import { CommandsRegistry } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
-import * as JSONContributionRegistry from 'monaco-editor/esm/vs/platform/jsonschemas/common/jsonContributionRegistry.js';
-import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
-import { Extensions as Extensions$1 } from '../../../common/contributions.js';
-import { ConfigureSnippetsAction } from './commands/configureSnippets.js';
-import { ApplyFileSnippetAction } from './commands/fileTemplateSnippets.js';
-import { InsertSnippetAction } from './commands/insertSnippet.js';
-import { SurroundWithSnippetEditorAction } from './commands/surroundWithSnippet.js';
-import { SnippetCodeActions } from './snippetCodeActionProvider.js';
-import { Extensions } from 'monaco-editor/esm/vs/platform/configuration/common/configurationRegistry.js';
-import { editorConfigurationBaseNode } from 'monaco-editor/esm/vs/editor/common/config/editorConfigurationSchema.js';
-registerAction2(InsertSnippetAction);
-CommandsRegistry.registerCommandAlias('editor.action.showSnippets', 'editor.action.insertSnippet');
-registerAction2(SurroundWithSnippetEditorAction);
-registerAction2(ApplyFileSnippetAction);
-registerAction2(ConfigureSnippetsAction);
-const workbenchContribRegistry = ( Registry.as(Extensions$1.Workbench));
-workbenchContribRegistry.registerWorkbenchContribution(SnippetCodeActions, 3 );
-( Registry
-    .as(Extensions.Configuration))
-    .registerConfiguration({
-    ...editorConfigurationBaseNode,
-    'properties': {
-        'editor.snippets.codeActions.enabled': {
-            'description': ( nls.localize(
-                'editor.snippets.codeActions.enabled',
-                'Controls if surround-with-snippets or file template snippets show as Code Actions.'
-            )),
-            'type': 'boolean',
-            'default': true
-        }
-    }
-});
-const languageScopeSchemaId = 'vscode://schemas/snippets';
-const snippetSchemaProperties = {
-    prefix: {
-        description: ( nls.localize(
-            'snippetSchema.json.prefix',
-            'The prefix to use when selecting the snippet in intellisense'
-        )),
-        type: ['string', 'array']
-    },
-    isFileTemplate: {
-        description: ( nls.localize(
-            'snippetSchema.json.isFileTemplate',
-            'The snippet is meant to populate or replace a whole file'
-        )),
-        type: 'boolean'
-    },
-    body: {
-        markdownDescription: ( nls.localize(
-            'snippetSchema.json.body',
-            'The snippet content. Use `$1`, `${1:defaultText}` to define cursor positions, use `$0` for the final cursor position. Insert variable values with `${varName}` and `${varName:defaultText}`, e.g. `This is file: $TM_FILENAME`.'
-        )),
-        type: ['string', 'array'],
-        items: {
-            type: 'string'
-        }
-    },
-    description: {
-        description: ( nls.localize('snippetSchema.json.description', 'The snippet description.')),
-        type: ['string', 'array']
-    }
-};
-const languageScopeSchema = {
-    id: languageScopeSchemaId,
-    allowComments: true,
-    allowTrailingCommas: true,
-    defaultSnippets: [{
-            label: ( nls.localize('snippetSchema.json.default', "Empty snippet")),
-            body: { '${1:snippetName}': { 'prefix': '${2:prefix}', 'body': '${3:snippet}', 'description': '${4:description}' } }
-        }],
-    type: 'object',
-    description: ( nls.localize('snippetSchema.json', 'User snippet configuration')),
-    additionalProperties: {
-        type: 'object',
-        required: ['body'],
-        properties: snippetSchemaProperties,
-        additionalProperties: false
-    }
-};
-const globalSchemaId = 'vscode://schemas/global-snippets';
-const globalSchema = {
-    id: globalSchemaId,
-    allowComments: true,
-    allowTrailingCommas: true,
-    defaultSnippets: [{
-            label: ( nls.localize('snippetSchema.json.default', "Empty snippet")),
-            body: { '${1:snippetName}': { 'scope': '${2:scope}', 'prefix': '${3:prefix}', 'body': '${4:snippet}', 'description': '${5:description}' } }
-        }],
-    type: 'object',
-    description: ( nls.localize('snippetSchema.json', 'User snippet configuration')),
-    additionalProperties: {
-        type: 'object',
-        required: ['body'],
-        properties: {
-            ...snippetSchemaProperties,
-            scope: {
-                description: ( nls.localize(
-                    'snippetSchema.json.scope',
-                    "A list of language names to which this snippet applies, e.g. 'typescript,javascript'."
-                )),
-                type: 'string'
-            }
-        },
-        additionalProperties: false
-    }
-};
-const reg = ( Registry.as(JSONContributionRegistry.Extensions.JSONContribution));
-reg.registerSchema(languageScopeSchemaId, languageScopeSchema);
-reg.registerSchema(globalSchemaId, globalSchema);

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

@@ -1,101 +0,0 @@
-import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
-import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
-import { localize } from 'monaco-editor/esm/vs/nls.js';
-class BaseTerminalBackend extends Disposable {
-    get isResponsive() { return !this._isPtyHostUnresponsive; }
-    constructor(_ptyHostController, _logService, historyService, configurationResolverService, statusBarService, _workspaceContextService) {
-        super();
-        this._ptyHostController = _ptyHostController;
-        this._logService = _logService;
-        this._workspaceContextService = _workspaceContextService;
-        this._isPtyHostUnresponsive = false;
-        this._onPtyHostConnected = this._register(( (new Emitter())));
-        this.onPtyHostConnected = this._onPtyHostConnected.event;
-        this._onPtyHostRestart = this._register(( (new Emitter())));
-        this.onPtyHostRestart = this._onPtyHostRestart.event;
-        this._onPtyHostUnresponsive = this._register(( (new Emitter())));
-        this.onPtyHostUnresponsive = this._onPtyHostUnresponsive.event;
-        this._onPtyHostResponsive = this._register(( (new Emitter())));
-        this.onPtyHostResponsive = this._onPtyHostResponsive.event;
-        let unresponsiveStatusBarEntry;
-        let statusBarAccessor;
-        let hasStarted = false;
-        this._register(this._ptyHostController.onPtyHostExit(() => {
-            this._logService.error(`The terminal's pty host process exited, the connection to all terminal processes was lost`);
-        }));
-        this.onPtyHostConnected(() => hasStarted = true);
-        this._register(this._ptyHostController.onPtyHostStart(() => {
-            this._logService.debug(`The terminal's pty host process is starting`);
-            if (hasStarted) {
-                this._logService.trace('IPtyHostController#onPtyHostRestart');
-                this._onPtyHostRestart.fire();
-            }
-            statusBarAccessor?.dispose();
-            this._isPtyHostUnresponsive = false;
-        }));
-        this._register(this._ptyHostController.onPtyHostUnresponsive(() => {
-            statusBarAccessor?.dispose();
-            if (!unresponsiveStatusBarEntry) {
-                unresponsiveStatusBarEntry = {
-                    name: ( (localize('ptyHostStatus', 'Pty Host Status'))),
-                    text: `$(debug-disconnect) ${( ( localize('ptyHostStatus.short', 'Pty Host')))}`,
-                    tooltip: ( (localize(
-                        'nonResponsivePtyHost',
-                        "The connection to the terminal's pty host process is unresponsive, terminals may stop working. Click to manually restart the pty host."
-                    ))),
-                    ariaLabel: ( (localize('ptyHostStatus.ariaLabel', 'Pty Host is unresponsive'))),
-                    command: "workbench.action.terminal.restartPtyHost" ,
-                    kind: 'warning'
-                };
-            }
-            statusBarAccessor = statusBarService.addEntry(unresponsiveStatusBarEntry, 'ptyHostStatus', 0 );
-            this._isPtyHostUnresponsive = true;
-            this._onPtyHostUnresponsive.fire();
-        }));
-        this._register(this._ptyHostController.onPtyHostResponsive(() => {
-            if (!this._isPtyHostUnresponsive) {
-                return;
-            }
-            this._logService.info('The pty host became responsive again');
-            statusBarAccessor?.dispose();
-            this._isPtyHostUnresponsive = false;
-            this._onPtyHostResponsive.fire();
-        }));
-        this._register(this._ptyHostController.onPtyHostRequestResolveVariables(async (e) => {
-            if (e.workspaceId !== this._workspaceContextService.getWorkspace().id) {
-                return;
-            }
-            const activeWorkspaceRootUri = historyService.getLastActiveWorkspaceRoot(Schemas.file);
-            const lastActiveWorkspaceRoot = activeWorkspaceRootUri ? this._workspaceContextService.getWorkspaceFolder(activeWorkspaceRootUri) ?? undefined : undefined;
-            const resolveCalls = ( (e.originalText.map(t => {
-                return configurationResolverService.resolveAsync(lastActiveWorkspaceRoot, t);
-            })));
-            const result = await Promise.all(resolveCalls);
-            this._ptyHostController.acceptPtyHostResolvedVariables(e.requestId, result);
-        }));
-    }
-    restartPtyHost() {
-        this._ptyHostController.restartPtyHost();
-    }
-    _deserializeTerminalState(serializedState) {
-        if (serializedState === undefined) {
-            return undefined;
-        }
-        const parsedUnknown = JSON.parse(serializedState);
-        if (!('version' in parsedUnknown) || !('state' in parsedUnknown) || !Array.isArray(parsedUnknown.state)) {
-            this._logService.warn('Could not revive serialized processes, wrong format', parsedUnknown);
-            return undefined;
-        }
-        const parsedCrossVersion = parsedUnknown;
-        if (parsedCrossVersion.version !== 1) {
-            this._logService.warn(`Could not revive serialized processes, wrong version "${parsedCrossVersion.version}"`, parsedCrossVersion);
-            return undefined;
-        }
-        return parsedCrossVersion.state;
-    }
-    _getWorkspaceId() {
-        return this._workspaceContextService.getWorkspace().id;
-    }
-}
-export { BaseTerminalBackend };

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

@@ -1,54 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { Delayer } from 'monaco-editor/esm/vs/base/common/async.js';
-import { onUnexpectedError } from 'monaco-editor/esm/vs/base/common/errors.js';
-import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { MicrotaskDelay } from 'monaco-editor/esm/vs/base/common/symbols.js';
-import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
-import { TerminalCapabilityStore } from '../../../../platform/terminal/common/capabilities/terminalCapabilityStore.js';
-import { TerminalExtensionsRegistry } from './terminalExtensions.js';
-import { TerminalWidgetManager } from './widgets/widgetManager.js';
-let DeatachedTerminal = class DeatachedTerminal extends Disposable {
-    get xterm() {
-        return this._xterm;
-    }
-    constructor(_xterm, options, instantiationService) {
-        super();
-        this._xterm = _xterm;
-        this._widgets = this._register(( new TerminalWidgetManager()));
-        this.capabilities = ( new TerminalCapabilityStore());
-        this._contributions = ( new Map());
-        this._register(_xterm);
-        const contributionDescs = TerminalExtensionsRegistry.getTerminalContributions();
-        for (const desc of contributionDescs) {
-            if (( this._contributions.has(desc.id))) {
-                onUnexpectedError(( new Error(`Cannot have two terminal contributions with the same id ${desc.id}`)));
-                continue;
-            }
-            if (desc.canRunInDetachedTerminals === false) {
-                continue;
-            }
-            let contribution;
-            try {
-                contribution = instantiationService.createInstance(desc.ctor, this, options.processInfo, this._widgets);
-                this._contributions.set(desc.id, contribution);
-                this._register(contribution);
-            }
-            catch (err) {
-                onUnexpectedError(err);
-            }
-        }
-        this._register(( new Delayer(MicrotaskDelay))).trigger(() => {
-            for (const contr of ( this._contributions.values())) {
-                contr.xtermReady?.(this._xterm);
-            }
-        });
-    }
-    attachToElement(container, options) {
-        const screenElement = this._xterm.attachToElement(container, options);
-        this._widgets.attachToElement(screenElement);
-    }
-};
-DeatachedTerminal = ( __decorate([
-    ( __param(2, IInstantiationService))
-], DeatachedTerminal));
-export { DeatachedTerminal };