@codingame/monaco-vscode-api 1.83.15 → 1.83.16

package/vscode/src/vs/workbench/contrib/format/browser/formatActionsMultiple.js

@@ -0,0 +1,423 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { getCodeEditor } from 'monaco-editor/esm/vs/editor/browser/editorBrowser.js';
+import { registerEditorAction, EditorAction } from 'monaco-editor/esm/vs/editor/browser/editorExtensions.js';
+import { EditorContextKeys } from 'monaco-editor/esm/vs/editor/common/editorContextKeys.js';
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import { ContextKeyExpr } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { IQuickInputService } from 'monaco-editor/esm/vs/platform/quickinput/common/quickInput.js';
+import { CancellationToken, CancellationTokenSource } from 'monaco-editor/esm/vs/base/common/cancellation.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { FormattingConflicts, getRealAndSyntheticDocumentFormattersOrdered, formatDocumentWithProvider, formatDocumentRangesWithProvider } from 'monaco-editor/esm/vs/editor/contrib/format/browser/format.js';
+import { Range } from 'monaco-editor/esm/vs/editor/common/core/range.js';
+import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
+import { ExtensionIdentifier } from 'monaco-editor/esm/vs/platform/extensions/common/extensions.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { Extensions as Extensions$1 } from 'monaco-editor/esm/vs/platform/configuration/common/configurationRegistry.js';
+import { Extensions } from '../../../common/contributions.js';
+import { toExtension, IExtensionService } from '../../../services/extensions/common/extensions.js';
+import { Disposable, DisposableStore, toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { Severity, NotificationPriority, INotificationService } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
+import { ILanguageService } from 'monaco-editor/esm/vs/editor/common/languages/language.js';
+import { IWorkbenchExtensionEnablementService } from '../../../services/extensionManagement/common/extensionManagement.js';
+import { editorConfigurationBaseNode } from 'monaco-editor/esm/vs/editor/common/config/editorConfigurationSchema.js';
+import '../../../../../../../override/vs/platform/dialogs/common/dialogs.js';
+import { ILanguageFeaturesService } from 'monaco-editor/esm/vs/editor/common/services/languageFeatures.js';
+import { ILanguageStatusService } from '../../../services/languageStatus/common/languageStatusService.js';
+import { IEditorService } from '../../../services/editor/common/editorService.js';
+import { CommandsRegistry } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
+import { generateUuid } from 'monaco-editor/esm/vs/base/common/uuid.js';
+import { IDialogService } from '../../../../platform/dialogs/common/dialogs.js';
+var DefaultFormatter_1;
+let DefaultFormatter = class DefaultFormatter extends Disposable {
+    static { DefaultFormatter_1 = this; }
+    static { this.configName = 'editor.defaultFormatter'; }
+    static { this.extensionIds = []; }
+    static { this.extensionItemLabels = []; }
+    static { this.extensionDescriptions = []; }
+    constructor(_extensionService, _extensionEnablementService, _configService, _notificationService, _dialogService, _quickInputService, _languageService, _languageFeaturesService, _languageStatusService, _editorService) {
+        super();
+        this._extensionService = _extensionService;
+        this._extensionEnablementService = _extensionEnablementService;
+        this._configService = _configService;
+        this._notificationService = _notificationService;
+        this._dialogService = _dialogService;
+        this._quickInputService = _quickInputService;
+        this._languageService = _languageService;
+        this._languageFeaturesService = _languageFeaturesService;
+        this._languageStatusService = _languageStatusService;
+        this._editorService = _editorService;
+        this._languageStatusStore = this._store.add(( new DisposableStore()));
+        this._store.add(this._extensionService.onDidChangeExtensions(this._updateConfigValues, this));
+        this._store.add(FormattingConflicts.setFormatterSelector((formatter, document, mode) => this._selectFormatter(formatter, document, mode)));
+        this._store.add(_editorService.onDidActiveEditorChange(this._updateStatus, this));
+        this._store.add(_languageFeaturesService.documentFormattingEditProvider.onDidChange(this._updateStatus, this));
+        this._store.add(_languageFeaturesService.documentRangeFormattingEditProvider.onDidChange(this._updateStatus, this));
+        this._store.add(_configService.onDidChangeConfiguration(e => e.affectsConfiguration(DefaultFormatter_1.configName) && this._updateStatus()));
+        this._updateConfigValues();
+    }
+    async _updateConfigValues() {
+        await this._extensionService.whenInstalledExtensionsRegistered();
+        let extensions = [...this._extensionService.extensions];
+        extensions = extensions.sort((a, b) => {
+            const boostA = a.categories?.find(cat => cat === 'Formatters' || cat === 'Programming Languages');
+            const boostB = b.categories?.find(cat => cat === 'Formatters' || cat === 'Programming Languages');
+            if (boostA && !boostB) {
+                return -1;
+            }
+            else if (!boostA && boostB) {
+                return 1;
+            }
+            else {
+                return a.name.localeCompare(b.name);
+            }
+        });
+        DefaultFormatter_1.extensionIds.length = 0;
+        DefaultFormatter_1.extensionItemLabels.length = 0;
+        DefaultFormatter_1.extensionDescriptions.length = 0;
+        DefaultFormatter_1.extensionIds.push(null);
+        DefaultFormatter_1.extensionItemLabels.push(( nls.localizeWithPath(
+            'vs/workbench/contrib/format/browser/formatActionsMultiple',
+            'null',
+            'None'
+        )));
+        DefaultFormatter_1.extensionDescriptions.push(( nls.localizeWithPath(
+            'vs/workbench/contrib/format/browser/formatActionsMultiple',
+            'nullFormatterDescription',
+            "None"
+        )));
+        for (const extension of extensions) {
+            if (extension.main || extension.browser) {
+                DefaultFormatter_1.extensionIds.push(extension.identifier.value);
+                DefaultFormatter_1.extensionItemLabels.push(extension.displayName ?? '');
+                DefaultFormatter_1.extensionDescriptions.push(extension.description ?? '');
+            }
+        }
+    }
+    static _maybeQuotes(s) {
+        return s.match(/\s/) ? `'${s}'` : s;
+    }
+    async _analyzeFormatter(formatter, document) {
+        const defaultFormatterId = this._configService.getValue(DefaultFormatter_1.configName, {
+            resource: document.uri,
+            overrideIdentifier: document.getLanguageId()
+        });
+        if (defaultFormatterId) {
+            const defaultFormatter = formatter.find(formatter => ExtensionIdentifier.equals(formatter.extensionId, defaultFormatterId));
+            if (defaultFormatter) {
+                return defaultFormatter;
+            }
+            const extension = await this._extensionService.getExtension(defaultFormatterId);
+            if (extension && this._extensionEnablementService.isEnabled(toExtension(extension))) {
+                const langName = this._languageService.getLanguageName(document.getLanguageId()) || document.getLanguageId();
+                const detail = ( nls.localizeWithPath(
+                    'vs/workbench/contrib/format/browser/formatActionsMultiple',
+                    'miss',
+                    "Extension '{0}' is configured as formatter but it cannot format '{1}'-files",
+                    extension.displayName || extension.name,
+                    langName
+                ));
+                return detail;
+            }
+        }
+        else if (formatter.length === 1) {
+            return formatter[0];
+        }
+        const langName = this._languageService.getLanguageName(document.getLanguageId()) || document.getLanguageId();
+        const message = !defaultFormatterId
+            ? ( nls.localizeWithPath(
+            'vs/workbench/contrib/format/browser/formatActionsMultiple',
+            'config.needed',
+            "There are multiple formatters for '{0}' files. One of them should be configured as default formatter.",
+            DefaultFormatter_1._maybeQuotes(langName)
+        ))
+            : ( nls.localizeWithPath(
+            'vs/workbench/contrib/format/browser/formatActionsMultiple',
+            'config.bad',
+            "Extension '{0}' is configured as formatter but not available. Select a different default formatter to continue.",
+            defaultFormatterId
+        ));
+        return message;
+    }
+    async _selectFormatter(formatter, document, mode) {
+        const formatterOrMessage = await this._analyzeFormatter(formatter, document);
+        if (typeof formatterOrMessage !== 'string') {
+            return formatterOrMessage;
+        }
+        if (mode !== 2 ) {
+            const { confirmed } = await this._dialogService.confirm({
+                message: ( nls.localizeWithPath(
+                    'vs/workbench/contrib/format/browser/formatActionsMultiple',
+                    'miss.1',
+                    "Configure Default Formatter"
+                )),
+                detail: formatterOrMessage,
+                primaryButton: ( nls.localizeWithPath(
+                    'vs/workbench/contrib/format/browser/formatActionsMultiple',
+                    { key: 'do.config', comment: ['&& denotes a mnemonic'] },
+                    "&&Configure..."
+                ))
+            });
+            if (confirmed) {
+                return this._pickAndPersistDefaultFormatter(formatter, document);
+            }
+        }
+        else {
+            this._notificationService.prompt(Severity.Info, formatterOrMessage, [{ label: ( nls.localizeWithPath(
+                'vs/workbench/contrib/format/browser/formatActionsMultiple',
+                'do.config.notification',
+                "Configure..."
+            )), run: () => this._pickAndPersistDefaultFormatter(formatter, document) }], { priority: NotificationPriority.SILENT });
+        }
+        return undefined;
+    }
+    async _pickAndPersistDefaultFormatter(formatter, document) {
+        const picks = ( formatter.map((formatter, index) => {
+            return {
+                index,
+                label: formatter.displayName || (formatter.extensionId ? formatter.extensionId.value : '?'),
+                description: formatter.extensionId && formatter.extensionId.value
+            };
+        }));
+        const langName = this._languageService.getLanguageName(document.getLanguageId()) || document.getLanguageId();
+        const pick = await this._quickInputService.pick(picks, { placeHolder: ( nls.localizeWithPath(
+            'vs/workbench/contrib/format/browser/formatActionsMultiple',
+            'select',
+            "Select a default formatter for '{0}' files",
+            DefaultFormatter_1._maybeQuotes(langName)
+        )) });
+        if (!pick || !formatter[pick.index].extensionId) {
+            return undefined;
+        }
+        this._configService.updateValue(DefaultFormatter_1.configName, formatter[pick.index].extensionId.value, {
+            resource: document.uri,
+            overrideIdentifier: document.getLanguageId()
+        });
+        return formatter[pick.index];
+    }
+    _updateStatus() {
+        this._languageStatusStore.clear();
+        const editor = getCodeEditor(this._editorService.activeTextEditorControl);
+        if (!editor || !editor.hasModel()) {
+            return;
+        }
+        const document = editor.getModel();
+        const formatter = getRealAndSyntheticDocumentFormattersOrdered(this._languageFeaturesService.documentFormattingEditProvider, this._languageFeaturesService.documentRangeFormattingEditProvider, document);
+        if (formatter.length === 0) {
+            return;
+        }
+        const cts = ( new CancellationTokenSource());
+        this._languageStatusStore.add(toDisposable(() => cts.dispose(true)));
+        this._analyzeFormatter(formatter, document).then(result => {
+            if (cts.token.isCancellationRequested) {
+                return;
+            }
+            if (typeof result !== 'string') {
+                return;
+            }
+            const command = { id: `formatter/configure/dfl/${generateUuid()}`, title: ( nls.localizeWithPath(
+                'vs/workbench/contrib/format/browser/formatActionsMultiple',
+                'do.config.command',
+                "Configure..."
+            )) };
+            this._languageStatusStore.add(CommandsRegistry.registerCommand(command.id, () => this._pickAndPersistDefaultFormatter(formatter, document)));
+            this._languageStatusStore.add(this._languageStatusService.addStatus({
+                id: 'formatter.conflict',
+                name: ( nls.localizeWithPath(
+                    'vs/workbench/contrib/format/browser/formatActionsMultiple',
+                    'summary',
+                    "Formatter Conflicts"
+                )),
+                selector: { language: document.getLanguageId(), pattern: document.uri.fsPath },
+                severity: Severity.Error,
+                label: ( nls.localizeWithPath(
+                    'vs/workbench/contrib/format/browser/formatActionsMultiple',
+                    'formatter',
+                    "Formatting"
+                )),
+                detail: result,
+                busy: false,
+                source: '',
+                command,
+                accessibilityInfo: undefined
+            }));
+        });
+    }
+};
+DefaultFormatter = DefaultFormatter_1 = ( __decorate([
+    ( __param(0, IExtensionService)),
+    ( __param(1, IWorkbenchExtensionEnablementService)),
+    ( __param(2, IConfigurationService)),
+    ( __param(3, INotificationService)),
+    ( __param(4, IDialogService)),
+    ( __param(5, IQuickInputService)),
+    ( __param(6, ILanguageService)),
+    ( __param(7, ILanguageFeaturesService)),
+    ( __param(8, ILanguageStatusService)),
+    ( __param(9, IEditorService))
+], DefaultFormatter));
+( Registry.as(Extensions.Workbench)).registerWorkbenchContribution(DefaultFormatter, 3 );
+( Registry.as(Extensions$1.Configuration)).registerConfiguration({
+    ...editorConfigurationBaseNode,
+    properties: {
+        [DefaultFormatter.configName]: {
+            description: ( nls.localizeWithPath(
+                'vs/workbench/contrib/format/browser/formatActionsMultiple',
+                'formatter.default',
+                "Defines a default formatter which takes precedence over all other formatter settings. Must be the identifier of an extension contributing a formatter."
+            )),
+            type: ['string', 'null'],
+            default: null,
+            enum: DefaultFormatter.extensionIds,
+            enumItemLabels: DefaultFormatter.extensionItemLabels,
+            markdownEnumDescriptions: DefaultFormatter.extensionDescriptions
+        }
+    }
+});
+function logFormatterTelemetry(telemetryService, mode, options, pick) {
+    function extKey(obj) {
+        return obj.extensionId ? ExtensionIdentifier.toKey(obj.extensionId) : 'unknown';
+    }
+    telemetryService.publicLog2('formatterpick', {
+        mode,
+        extensions: ( options.map(extKey)),
+        pick: pick ? extKey(pick) : 'none'
+    });
+}
+async function showFormatterPick(accessor, model, formatters) {
+    const quickPickService = accessor.get(IQuickInputService);
+    const configService = accessor.get(IConfigurationService);
+    const languageService = accessor.get(ILanguageService);
+    const overrides = { resource: model.uri, overrideIdentifier: model.getLanguageId() };
+    const defaultFormatter = configService.getValue(DefaultFormatter.configName, overrides);
+    let defaultFormatterPick;
+    const picks = ( formatters.map((provider, index) => {
+        const isDefault = ExtensionIdentifier.equals(provider.extensionId, defaultFormatter);
+        const pick = {
+            index,
+            label: provider.displayName || '',
+            description: isDefault ? ( nls.localizeWithPath(
+                'vs/workbench/contrib/format/browser/formatActionsMultiple',
+                'def',
+                "(default)"
+            )) : undefined,
+        };
+        if (isDefault) {
+            defaultFormatterPick = pick;
+        }
+        return pick;
+    }));
+    const configurePick = {
+        label: ( nls.localizeWithPath(
+            'vs/workbench/contrib/format/browser/formatActionsMultiple',
+            'config',
+            "Configure Default Formatter..."
+        ))
+    };
+    const pick = await quickPickService.pick([...picks, { type: 'separator' }, configurePick], {
+        placeHolder: ( nls.localizeWithPath(
+            'vs/workbench/contrib/format/browser/formatActionsMultiple',
+            'format.placeHolder',
+            "Select a formatter"
+        )),
+        activeItem: defaultFormatterPick
+    });
+    if (!pick) {
+        return undefined;
+    }
+    else if (pick === configurePick) {
+        const langName = languageService.getLanguageName(model.getLanguageId()) || model.getLanguageId();
+        const pick = await quickPickService.pick(picks, { placeHolder: ( nls.localizeWithPath(
+            'vs/workbench/contrib/format/browser/formatActionsMultiple',
+            'select',
+            "Select a default formatter for '{0}' files",
+            DefaultFormatter._maybeQuotes(langName)
+        )) });
+        if (pick && formatters[pick.index].extensionId) {
+            configService.updateValue(DefaultFormatter.configName, formatters[pick.index].extensionId.value, overrides);
+        }
+        return undefined;
+    }
+    else {
+        return pick.index;
+    }
+}
+registerEditorAction(class FormatDocumentMultipleAction extends EditorAction {
+    constructor() {
+        super({
+            id: 'editor.action.formatDocument.multiple',
+            label: ( nls.localizeWithPath(
+                'vs/workbench/contrib/format/browser/formatActionsMultiple',
+                'formatDocument.label.multiple',
+                "Format Document With..."
+            )),
+            alias: 'Format Document...',
+            precondition: ( ContextKeyExpr.and(
+                EditorContextKeys.writable,
+                EditorContextKeys.hasMultipleDocumentFormattingProvider
+            )),
+            contextMenuOpts: {
+                group: '1_modification',
+                order: 1.3
+            }
+        });
+    }
+    async run(accessor, editor, args) {
+        if (!editor.hasModel()) {
+            return;
+        }
+        const instaService = accessor.get(IInstantiationService);
+        const telemetryService = accessor.get(ITelemetryService);
+        const languageFeaturesService = accessor.get(ILanguageFeaturesService);
+        const model = editor.getModel();
+        const provider = getRealAndSyntheticDocumentFormattersOrdered(languageFeaturesService.documentFormattingEditProvider, languageFeaturesService.documentRangeFormattingEditProvider, model);
+        const pick = await instaService.invokeFunction(showFormatterPick, model, provider);
+        if (typeof pick === 'number') {
+            await instaService.invokeFunction(formatDocumentWithProvider, provider[pick], editor, 1 , CancellationToken.None);
+        }
+        logFormatterTelemetry(telemetryService, 'document', provider, typeof pick === 'number' && provider[pick] || undefined);
+    }
+});
+registerEditorAction(class FormatSelectionMultipleAction extends EditorAction {
+    constructor() {
+        super({
+            id: 'editor.action.formatSelection.multiple',
+            label: ( nls.localizeWithPath(
+                'vs/workbench/contrib/format/browser/formatActionsMultiple',
+                'formatSelection.label.multiple',
+                "Format Selection With..."
+            )),
+            alias: 'Format Code...',
+            precondition: ( ContextKeyExpr.and(( ContextKeyExpr.and(EditorContextKeys.writable)), EditorContextKeys.hasMultipleDocumentSelectionFormattingProvider)),
+            contextMenuOpts: {
+                when: ( ContextKeyExpr.and(EditorContextKeys.hasNonEmptySelection)),
+                group: '1_modification',
+                order: 1.31
+            }
+        });
+    }
+    async run(accessor, editor) {
+        if (!editor.hasModel()) {
+            return;
+        }
+        const instaService = accessor.get(IInstantiationService);
+        const languageFeaturesService = accessor.get(ILanguageFeaturesService);
+        const telemetryService = accessor.get(ITelemetryService);
+        const model = editor.getModel();
+        let range = editor.getSelection();
+        if (range.isEmpty()) {
+            range = ( new Range(
+                range.startLineNumber,
+                1,
+                range.startLineNumber,
+                model.getLineMaxColumn(range.startLineNumber)
+            ));
+        }
+        const provider = languageFeaturesService.documentRangeFormattingEditProvider.ordered(model);
+        const pick = await instaService.invokeFunction(showFormatterPick, model, provider);
+        if (typeof pick === 'number') {
+            await instaService.invokeFunction(formatDocumentRangesWithProvider, provider[pick], editor, range, CancellationToken.None);
+        }
+        logFormatterTelemetry(telemetryService, 'range', provider, typeof pick === 'number' && provider[pick] || undefined);
+    }
+});

package/vscode/src/vs/workbench/contrib/format/browser/formatActionsNone.js

@@ -0,0 +1,82 @@
+import { registerEditorAction, EditorAction } from 'monaco-editor/esm/vs/editor/browser/editorExtensions.js';
+import { EditorContextKeys } from 'monaco-editor/esm/vs/editor/common/editorContextKeys.js';
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import { ContextKeyExpr } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { ICommandService } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
+import { INotificationService } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
+import { VIEWLET_ID } from '../../extensions/common/extensions.js';
+import '../../../../../../../override/vs/platform/dialogs/common/dialogs.js';
+import { IPaneCompositePartService } from '../../../services/panecomposite/browser/panecomposite.js';
+import { ILanguageFeaturesService } from 'monaco-editor/esm/vs/editor/common/services/languageFeatures.js';
+import { IDialogService } from '../../../../platform/dialogs/common/dialogs.js';
+async function showExtensionQuery(paneCompositeService, query) {
+    const viewlet = await paneCompositeService.openPaneComposite(VIEWLET_ID, 0 , true);
+    if (viewlet) {
+        (viewlet?.getViewPaneContainer()).search(query);
+    }
+}
+registerEditorAction(class FormatDocumentMultipleAction extends EditorAction {
+    constructor() {
+        super({
+            id: 'editor.action.formatDocument.none',
+            label: ( nls.localizeWithPath(
+                'vs/workbench/contrib/format/browser/formatActionsNone',
+                'formatDocument.label.multiple',
+                "Format Document"
+            )),
+            alias: 'Format Document',
+            precondition: ( ContextKeyExpr.and(EditorContextKeys.writable, ( EditorContextKeys.hasDocumentFormattingProvider.toNegated()))),
+            kbOpts: {
+                kbExpr: EditorContextKeys.editorTextFocus,
+                primary: 1024  | 512  | 36 ,
+                linux: { primary: 2048  | 1024  | 39  },
+                weight: 100 ,
+            }
+        });
+    }
+    async run(accessor, editor) {
+        if (!editor.hasModel()) {
+            return;
+        }
+        const commandService = accessor.get(ICommandService);
+        const paneCompositeService = accessor.get(IPaneCompositePartService);
+        const notificationService = accessor.get(INotificationService);
+        const dialogService = accessor.get(IDialogService);
+        const languageFeaturesService = accessor.get(ILanguageFeaturesService);
+        const model = editor.getModel();
+        const formatterCount = languageFeaturesService.documentFormattingEditProvider.all(model).length;
+        if (formatterCount > 1) {
+            return commandService.executeCommand('editor.action.formatDocument.multiple');
+        }
+        else if (formatterCount === 1) {
+            return commandService.executeCommand('editor.action.formatDocument');
+        }
+        else if (model.isTooLargeForSyncing()) {
+            notificationService.warn(( nls.localizeWithPath(
+                'vs/workbench/contrib/format/browser/formatActionsNone',
+                'too.large',
+                "This file cannot be formatted because it is too large"
+            )));
+        }
+        else {
+            const langName = model.getLanguageId();
+            const message = ( nls.localizeWithPath(
+                'vs/workbench/contrib/format/browser/formatActionsNone',
+                'no.provider',
+                "There is no formatter for '{0}' files installed.",
+                langName
+            ));
+            const { confirmed } = await dialogService.confirm({
+                message,
+                primaryButton: ( nls.localizeWithPath(
+                    'vs/workbench/contrib/format/browser/formatActionsNone',
+                    { key: 'install.formatter', comment: ['&& denotes a mnemonic'] },
+                    "&&Install Formatter..."
+                ))
+            });
+            if (confirmed) {
+                showExtensionQuery(paneCompositeService, `category:formatters ${langName}`);
+            }
+        }
+    }
+});

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

@@ -0,0 +1,67 @@
+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));
+class DetachedProcessInfo {
+    constructor(initialValues) {
+        this.processState = 3 ;
+        this.ptyProcessReady = Promise.resolve();
+        this.initialCwd = '';
+        this.shouldPersist = false;
+        this.hasWrittenData = false;
+        this.hasChildProcesses = false;
+        this.capabilities = ( new TerminalCapabilityStore());
+        this.shellIntegrationNonce = '';
+        Object.assign(this, initialValues);
+    }
+}
+export { DeatachedTerminal, DetachedProcessInfo };

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

@@ -0,0 +1,25 @@
+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 };

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

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