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

package/vscode/src/vs/workbench/contrib/debug/browser/debugConfigurationManager.js

@@ -1,619 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { flatten, distinct } from 'monaco-editor/esm/vs/base/common/arrays.js';
-import { sequence } from 'monaco-editor/esm/vs/base/common/async.js';
-import { CancellationTokenSource, CancellationToken } from 'monaco-editor/esm/vs/base/common/cancellation.js';
-import { Emitter, Event } from 'monaco-editor/esm/vs/base/common/event.js';
-import * as json from 'monaco-editor/esm/vs/base/common/json.js';
-import { dispose, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import * as objects from 'monaco-editor/esm/vs/base/common/objects.js';
-import * as resources from 'monaco-editor/esm/vs/base/common/resources.js';
-import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
-import * as nls from 'monaco-editor/esm/vs/nls.js';
-import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
-import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
-import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
-import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
-import { Extensions } from 'monaco-editor/esm/vs/platform/jsonschemas/common/jsonContributionRegistry.js';
-import { IQuickInputService } from 'monaco-editor/esm/vs/platform/quickinput/common/quickInput.js';
-import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
-import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
-import { ThemeIcon } from 'monaco-editor/esm/vs/base/common/themables.js';
-import { IUriIdentityService } from 'monaco-editor/esm/vs/platform/uriIdentity/common/uriIdentity.js';
-import { IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
-import { debugConfigure } from './debugIcons.js';
-import { CONTEXT_DEBUG_CONFIGURATION_TYPE, DebugConfigurationProviderTriggerKind } from '../common/debug.js';
-import { launchSchema } from '../common/debugSchemas.js';
-import { getVisibleAndSorted } from '../common/debugUtils.js';
-import { launchSchemaId } from '../../../services/configuration/common/configuration.js';
-import { ACTIVE_GROUP, IEditorService } from '../../../services/editor/common/editorService.js';
-import { IExtensionService } from '../../../services/extensions/common/extensions.js';
-import { IHistoryService } from '../../../services/history/common/history.js';
-import { IPreferencesService } from '../../../services/preferences/common/preferences.js';
-import { ITextFileService } from '../../../services/textfile/common/textfiles.js';
-const jsonRegistry = ( Registry.as(Extensions.JSONContribution));
-jsonRegistry.registerSchema(launchSchemaId, launchSchema);
-const DEBUG_SELECTED_CONFIG_NAME_KEY = 'debug.selectedconfigname';
-const DEBUG_SELECTED_ROOT = 'debug.selectedroot';
-const DEBUG_SELECTED_TYPE = 'debug.selectedtype';
-const DEBUG_RECENT_DYNAMIC_CONFIGURATIONS = 'debug.recentdynamicconfigurations';
-let ConfigurationManager = class ConfigurationManager {
-    constructor(adapterManager, contextService, configurationService, quickInputService, instantiationService, storageService, extensionService, historyService, uriIdentityService, contextKeyService) {
-        this.adapterManager = adapterManager;
-        this.contextService = contextService;
-        this.configurationService = configurationService;
-        this.quickInputService = quickInputService;
-        this.instantiationService = instantiationService;
-        this.storageService = storageService;
-        this.extensionService = extensionService;
-        this.historyService = historyService;
-        this.uriIdentityService = uriIdentityService;
-        this.getSelectedConfig = () => Promise.resolve(undefined);
-        this.selectedDynamic = false;
-        this._onDidSelectConfigurationName = ( new Emitter());
-        this.configProviders = [];
-        this.toDispose = [];
-        this.initLaunches();
-        this.setCompoundSchemaValues();
-        this.registerListeners();
-        const previousSelectedRoot = this.storageService.get(DEBUG_SELECTED_ROOT, 1 );
-        const previousSelectedType = this.storageService.get(DEBUG_SELECTED_TYPE, 1 );
-        const previousSelectedLaunch = this.launches.find(l => ( l.uri.toString()) === previousSelectedRoot);
-        const previousSelectedName = this.storageService.get(DEBUG_SELECTED_CONFIG_NAME_KEY, 1 );
-        this.debugConfigurationTypeContext = CONTEXT_DEBUG_CONFIGURATION_TYPE.bindTo(contextKeyService);
-        const dynamicConfig = previousSelectedType ? { type: previousSelectedType } : undefined;
-        if (previousSelectedLaunch && previousSelectedLaunch.getConfigurationNames().length) {
-            this.selectConfiguration(previousSelectedLaunch, previousSelectedName, undefined, dynamicConfig);
-        }
-        else if (this.launches.length > 0) {
-            this.selectConfiguration(undefined, previousSelectedName, undefined, dynamicConfig);
-        }
-    }
-    registerDebugConfigurationProvider(debugConfigurationProvider) {
-        this.configProviders.push(debugConfigurationProvider);
-        return {
-            dispose: () => {
-                this.unregisterDebugConfigurationProvider(debugConfigurationProvider);
-            }
-        };
-    }
-    unregisterDebugConfigurationProvider(debugConfigurationProvider) {
-        const ix = this.configProviders.indexOf(debugConfigurationProvider);
-        if (ix >= 0) {
-            this.configProviders.splice(ix, 1);
-        }
-    }
-    hasDebugConfigurationProvider(debugType, triggerKind) {
-        if (triggerKind === undefined) {
-            triggerKind = DebugConfigurationProviderTriggerKind.Initial;
-        }
-        const provider = this.configProviders.find(p => p.provideDebugConfigurations && (p.type === debugType) && (p.triggerKind === triggerKind));
-        return !!provider;
-    }
-    async resolveConfigurationByProviders(folderUri, type, config, token) {
-        const resolveDebugConfigurationForType = async (type, config) => {
-            if (type !== '*') {
-                await this.adapterManager.activateDebuggers('onDebugResolve', type);
-            }
-            for (const p of this.configProviders) {
-                if (p.type === type && p.resolveDebugConfiguration && config) {
-                    config = await p.resolveDebugConfiguration(folderUri, config, token);
-                }
-            }
-            return config;
-        };
-        let resolvedType = config.type ?? type;
-        let result = config;
-        for (let seen = ( new Set()); result && !( seen.has(resolvedType));) {
-            seen.add(resolvedType);
-            result = await resolveDebugConfigurationForType(resolvedType, result);
-            result = await resolveDebugConfigurationForType('*', result);
-            resolvedType = result?.type ?? type;
-        }
-        return result;
-    }
-    async resolveDebugConfigurationWithSubstitutedVariables(folderUri, type, config, token) {
-        const providers = this.configProviders.filter(p => p.type === type && p.resolveDebugConfigurationWithSubstitutedVariables)
-            .concat(this.configProviders.filter(p => p.type === '*' && p.resolveDebugConfigurationWithSubstitutedVariables));
-        let result = config;
-        await sequence(( providers.map(provider => async () => {
-            if (result) {
-                result = await provider.resolveDebugConfigurationWithSubstitutedVariables(folderUri, result, token);
-            }
-        })));
-        return result;
-    }
-    async provideDebugConfigurations(folderUri, type, token) {
-        await this.adapterManager.activateDebuggers('onDebugInitialConfigurations');
-        const results = await Promise.all(( this.configProviders.filter(p => p.type === type && p.triggerKind === DebugConfigurationProviderTriggerKind.Initial && p.provideDebugConfigurations).map(p => p.provideDebugConfigurations(folderUri, token))));
-        return results.reduce((first, second) => first.concat(second), []);
-    }
-    async getDynamicProviders() {
-        await this.extensionService.whenInstalledExtensionsRegistered();
-        const onDebugDynamicConfigurationsName = 'onDebugDynamicConfigurations';
-        const debugDynamicExtensionsTypes = this.extensionService.extensions.reduce((acc, e) => {
-            if (!e.activationEvents) {
-                return acc;
-            }
-            const explicitTypes = [];
-            let hasGenericEvent = false;
-            for (const event of e.activationEvents) {
-                if (event === onDebugDynamicConfigurationsName) {
-                    hasGenericEvent = true;
-                }
-                else if (event.startsWith(`${onDebugDynamicConfigurationsName}:`)) {
-                    explicitTypes.push(event.slice(onDebugDynamicConfigurationsName.length + 1));
-                }
-            }
-            if (explicitTypes.length) {
-                return acc.concat(explicitTypes);
-            }
-            if (hasGenericEvent) {
-                const debuggerType = e.contributes?.debuggers?.[0].type;
-                return debuggerType ? acc.concat(debuggerType) : acc;
-            }
-            return acc;
-        }, []);
-        return ( debugDynamicExtensionsTypes.map(type => {
-            return {
-                label: this.adapterManager.getDebuggerLabel(type),
-                getProvider: async () => {
-                    await this.adapterManager.activateDebuggers(onDebugDynamicConfigurationsName, type);
-                    return this.configProviders.find(p => p.type === type && p.triggerKind === DebugConfigurationProviderTriggerKind.Dynamic && p.provideDebugConfigurations);
-                },
-                type,
-                pick: async () => {
-                    await this.adapterManager.activateDebuggers(onDebugDynamicConfigurationsName, type);
-                    const token = ( new CancellationTokenSource());
-                    const picks = [];
-                    const provider = this.configProviders.find(p => p.type === type && p.triggerKind === DebugConfigurationProviderTriggerKind.Dynamic && p.provideDebugConfigurations);
-                    this.getLaunches().forEach(launch => {
-                        if (launch.workspace && provider) {
-                            picks.push(provider.provideDebugConfigurations(launch.workspace.uri, token.token).then(configurations => ( configurations.map(config => ({
-                                label: config.name,
-                                description: launch.name,
-                                config,
-                                buttons: [{
-                                        iconClass: ThemeIcon.asClassName(debugConfigure),
-                                        tooltip: ( nls.localize('editLaunchConfig', "Edit Debug Configuration in launch.json"))
-                                    }],
-                                launch
-                            })))));
-                        }
-                    });
-                    const disposables = ( new DisposableStore());
-                    const input = disposables.add(this.quickInputService.createQuickPick());
-                    input.busy = true;
-                    input.placeholder = ( nls.localize('selectConfiguration', "Select Launch Configuration"));
-                    const chosenPromise = ( new Promise(resolve => {
-                        disposables.add(input.onDidAccept(() => resolve(input.activeItems[0])));
-                        disposables.add(input.onDidTriggerItemButton(async (context) => {
-                            resolve(undefined);
-                            const { launch, config } = context.item;
-                            await launch.openConfigFile({ preserveFocus: false, type: config.type, suppressInitialConfigs: true });
-                            await launch.writeConfiguration(config);
-                            await this.selectConfiguration(launch, config.name);
-                            this.removeRecentDynamicConfigurations(config.name, config.type);
-                        }));
-                    }));
-                    const nestedPicks = await Promise.all(picks);
-                    const items = flatten(nestedPicks);
-                    input.items = items;
-                    input.busy = false;
-                    input.show();
-                    const chosen = await chosenPromise;
-                    disposables.dispose();
-                    if (!chosen) {
-                        token.cancel();
-                        return;
-                    }
-                    return chosen;
-                }
-            };
-        }));
-    }
-    getAllConfigurations() {
-        const all = [];
-        for (const l of this.launches) {
-            for (const name of l.getConfigurationNames()) {
-                const config = l.getConfiguration(name) || l.getCompound(name);
-                if (config) {
-                    all.push({ launch: l, name, presentation: config.presentation });
-                }
-            }
-        }
-        return getVisibleAndSorted(all);
-    }
-    removeRecentDynamicConfigurations(name, type) {
-        const remaining = this.getRecentDynamicConfigurations().filter(c => c.name !== name || c.type !== type);
-        this.storageService.store(DEBUG_RECENT_DYNAMIC_CONFIGURATIONS, JSON.stringify(remaining), 1 , 1 );
-        if (this.selectedConfiguration.name === name && this.selectedType === type && this.selectedDynamic) {
-            this.selectConfiguration(undefined, undefined);
-        }
-        else {
-            this._onDidSelectConfigurationName.fire();
-        }
-    }
-    getRecentDynamicConfigurations() {
-        return JSON.parse(this.storageService.get(DEBUG_RECENT_DYNAMIC_CONFIGURATIONS, 1 , '[]'));
-    }
-    registerListeners() {
-        this.toDispose.push(Event.any(this.contextService.onDidChangeWorkspaceFolders, this.contextService.onDidChangeWorkbenchState)(() => {
-            this.initLaunches();
-            this.selectConfiguration(undefined);
-            this.setCompoundSchemaValues();
-        }));
-        this.toDispose.push(this.configurationService.onDidChangeConfiguration(async (e) => {
-            if (e.affectsConfiguration('launch')) {
-                await this.selectConfiguration(undefined);
-                this.setCompoundSchemaValues();
-            }
-        }));
-        this.toDispose.push(this.adapterManager.onDidDebuggersExtPointRead(() => {
-            this.setCompoundSchemaValues();
-        }));
-    }
-    initLaunches() {
-        this.launches = ( this.contextService.getWorkspace().folders.map(
-            folder => this.instantiationService.createInstance(Launch, this, this.adapterManager, folder)
-        ));
-        if (this.contextService.getWorkbenchState() === 3 ) {
-            this.launches.push(this.instantiationService.createInstance(WorkspaceLaunch, this, this.adapterManager));
-        }
-        this.launches.push(this.instantiationService.createInstance(UserLaunch, this, this.adapterManager));
-        if (this.selectedLaunch && this.launches.indexOf(this.selectedLaunch) === -1) {
-            this.selectConfiguration(undefined);
-        }
-    }
-    setCompoundSchemaValues() {
-        const compoundConfigurationsSchema = launchSchema.properties['compounds'].items.properties['configurations'];
-        const launchNames = ( this.launches.map(l => l.getConfigurationNames(true))).reduce((first, second) => first.concat(second), []);
-        compoundConfigurationsSchema.items.oneOf[0].enum = launchNames;
-        compoundConfigurationsSchema.items.oneOf[1].properties.name.enum = launchNames;
-        const folderNames = ( this.contextService.getWorkspace().folders.map(f => f.name));
-        compoundConfigurationsSchema.items.oneOf[1].properties.folder.enum = folderNames;
-        jsonRegistry.registerSchema(launchSchemaId, launchSchema);
-    }
-    getLaunches() {
-        return this.launches;
-    }
-    getLaunch(workspaceUri) {
-        if (!URI.isUri(workspaceUri)) {
-            return undefined;
-        }
-        return this.launches.find(l => l.workspace && this.uriIdentityService.extUri.isEqual(l.workspace.uri, workspaceUri));
-    }
-    get selectedConfiguration() {
-        return {
-            launch: this.selectedLaunch,
-            name: this.selectedName,
-            getConfig: this.getSelectedConfig,
-            type: this.selectedType
-        };
-    }
-    get onDidSelectConfiguration() {
-        return this._onDidSelectConfigurationName.event;
-    }
-    getWorkspaceLaunch() {
-        if (this.contextService.getWorkbenchState() === 3 ) {
-            return this.launches[this.launches.length - 1];
-        }
-        return undefined;
-    }
-    async selectConfiguration(launch, name, config, dynamicConfig) {
-        if (typeof launch === 'undefined') {
-            const rootUri = this.historyService.getLastActiveWorkspaceRoot();
-            launch = this.getLaunch(rootUri);
-            if (!launch || launch.getConfigurationNames().length === 0) {
-                launch = this.launches.find(l => !!(l && l.getConfigurationNames().length)) || launch || this.launches[0];
-            }
-        }
-        const previousLaunch = this.selectedLaunch;
-        const previousName = this.selectedName;
-        const previousSelectedDynamic = this.selectedDynamic;
-        this.selectedLaunch = launch;
-        if (this.selectedLaunch) {
-            this.storageService.store(DEBUG_SELECTED_ROOT, ( this.selectedLaunch.uri.toString()), 1 , 1 );
-        }
-        else {
-            this.storageService.remove(DEBUG_SELECTED_ROOT, 1 );
-        }
-        const names = launch ? launch.getConfigurationNames() : [];
-        this.getSelectedConfig = () => {
-            const selected = this.selectedName ? launch?.getConfiguration(this.selectedName) : undefined;
-            return Promise.resolve(selected || config);
-        };
-        let type = config?.type;
-        if (name && names.indexOf(name) >= 0) {
-            this.setSelectedLaunchName(name);
-        }
-        else if (dynamicConfig && dynamicConfig.type) {
-            type = dynamicConfig.type;
-            if (!config) {
-                const providers = (await this.getDynamicProviders()).filter(p => p.type === type);
-                this.getSelectedConfig = async () => {
-                    const activatedProviders = await Promise.all(( providers.map(p => p.getProvider())));
-                    const provider = activatedProviders.length > 0 ? activatedProviders[0] : undefined;
-                    if (provider && launch && launch.workspace) {
-                        const token = ( new CancellationTokenSource());
-                        const dynamicConfigs = await provider.provideDebugConfigurations(launch.workspace.uri, token.token);
-                        const dynamicConfig = dynamicConfigs.find(c => c.name === name);
-                        if (dynamicConfig) {
-                            return dynamicConfig;
-                        }
-                    }
-                    return undefined;
-                };
-            }
-            this.setSelectedLaunchName(name);
-            let recentDynamicProviders = this.getRecentDynamicConfigurations();
-            if (name && dynamicConfig.type) {
-                recentDynamicProviders.unshift({ name, type: dynamicConfig.type });
-                recentDynamicProviders = distinct(recentDynamicProviders, t => `${t.name} : ${t.type}`);
-                this.storageService.store(DEBUG_RECENT_DYNAMIC_CONFIGURATIONS, JSON.stringify(recentDynamicProviders), 1 , 1 );
-            }
-        }
-        else if (!this.selectedName || names.indexOf(this.selectedName) === -1) {
-            const nameToSet = names.length ? names[0] : undefined;
-            this.setSelectedLaunchName(nameToSet);
-        }
-        if (!config && launch && this.selectedName) {
-            config = launch.getConfiguration(this.selectedName);
-            type = config?.type;
-        }
-        this.selectedType = dynamicConfig?.type || config?.type;
-        this.selectedDynamic = !!dynamicConfig;
-        this.storageService.store(DEBUG_SELECTED_TYPE, dynamicConfig ? this.selectedType : undefined, 1 , 1 );
-        if (type) {
-            this.debugConfigurationTypeContext.set(type);
-        }
-        else {
-            this.debugConfigurationTypeContext.reset();
-        }
-        if (this.selectedLaunch !== previousLaunch || this.selectedName !== previousName || previousSelectedDynamic !== this.selectedDynamic) {
-            this._onDidSelectConfigurationName.fire();
-        }
-    }
-    setSelectedLaunchName(selectedName) {
-        this.selectedName = selectedName;
-        if (this.selectedName) {
-            this.storageService.store(DEBUG_SELECTED_CONFIG_NAME_KEY, this.selectedName, 1 , 1 );
-        }
-        else {
-            this.storageService.remove(DEBUG_SELECTED_CONFIG_NAME_KEY, 1 );
-        }
-    }
-    dispose() {
-        this.toDispose = dispose(this.toDispose);
-    }
-};
-ConfigurationManager = ( __decorate([
-    ( __param(1, IWorkspaceContextService)),
-    ( __param(2, IConfigurationService)),
-    ( __param(3, IQuickInputService)),
-    ( __param(4, IInstantiationService)),
-    ( __param(5, IStorageService)),
-    ( __param(6, IExtensionService)),
-    ( __param(7, IHistoryService)),
-    ( __param(8, IUriIdentityService)),
-    ( __param(9, IContextKeyService))
-], ConfigurationManager));
-class AbstractLaunch {
-    constructor(configurationManager, adapterManager) {
-        this.configurationManager = configurationManager;
-        this.adapterManager = adapterManager;
-    }
-    getCompound(name) {
-        const config = this.getConfig();
-        if (!config || !config.compounds) {
-            return undefined;
-        }
-        return config.compounds.find(compound => compound.name === name);
-    }
-    getConfigurationNames(ignoreCompoundsAndPresentation = false) {
-        const config = this.getConfig();
-        if (!config || (!Array.isArray(config.configurations) && !Array.isArray(config.compounds))) {
-            return [];
-        }
-        else {
-            const configurations = [];
-            if (config.configurations) {
-                configurations.push(...config.configurations.filter(cfg => cfg && typeof cfg.name === 'string'));
-            }
-            if (ignoreCompoundsAndPresentation) {
-                return ( configurations.map(c => c.name));
-            }
-            if (config.compounds) {
-                configurations.push(...config.compounds.filter(compound => typeof compound.name === 'string' && compound.configurations && compound.configurations.length));
-            }
-            return ( getVisibleAndSorted(configurations).map(c => c.name));
-        }
-    }
-    getConfiguration(name) {
-        const config = objects.deepClone(this.getConfig());
-        if (!config || !config.configurations) {
-            return undefined;
-        }
-        const configuration = config.configurations.find(config => config && config.name === name);
-        if (configuration) {
-            if (this instanceof UserLaunch) {
-                configuration.__configurationTarget = 2 ;
-            }
-            else if (this instanceof WorkspaceLaunch) {
-                configuration.__configurationTarget = 5 ;
-            }
-            else {
-                configuration.__configurationTarget = 6 ;
-            }
-        }
-        return configuration;
-    }
-    async getInitialConfigurationContent(folderUri, type, useInitialConfigs, token) {
-        let content = '';
-        const adapter = type ? this.adapterManager.getEnabledDebugger(type) : await this.adapterManager.guessDebugger(true);
-        if (adapter) {
-            const initialConfigs = useInitialConfigs ?
-                await this.configurationManager.provideDebugConfigurations(folderUri, adapter.type, token || CancellationToken.None) :
-                [];
-            content = await adapter.getInitialConfigurationContent(initialConfigs);
-        }
-        return content;
-    }
-    get hidden() {
-        return false;
-    }
-}
-let Launch = class Launch extends AbstractLaunch {
-    constructor(configurationManager, adapterManager, workspace, fileService, textFileService, editorService, configurationService) {
-        super(configurationManager, adapterManager);
-        this.workspace = workspace;
-        this.fileService = fileService;
-        this.textFileService = textFileService;
-        this.editorService = editorService;
-        this.configurationService = configurationService;
-    }
-    get uri() {
-        return resources.joinPath(this.workspace.uri, '/.vscode/launch.json');
-    }
-    get name() {
-        return this.workspace.name;
-    }
-    getConfig() {
-        return this.configurationService.inspect('launch', { resource: this.workspace.uri }).workspaceFolderValue;
-    }
-    async openConfigFile({ preserveFocus, type, suppressInitialConfigs }, token) {
-        const resource = this.uri;
-        let created = false;
-        let content = '';
-        try {
-            const fileContent = await this.fileService.readFile(resource);
-            content = ( fileContent.value.toString());
-        }
-        catch {
-            content = await this.getInitialConfigurationContent(this.workspace.uri, type, !suppressInitialConfigs, token);
-            if (!content) {
-                return { editor: null, created: false };
-            }
-            created = true;
-            try {
-                await this.textFileService.write(resource, content);
-            }
-            catch (error) {
-                throw new Error(nls.localize('DebugConfig.failed', "Unable to create 'launch.json' file inside the '.vscode' folder ({0}).", error.message));
-            }
-        }
-        const index = content.indexOf(`"${this.configurationManager.selectedConfiguration.name}"`);
-        let startLineNumber = 1;
-        for (let i = 0; i < index; i++) {
-            if (content.charAt(i) === '\n') {
-                startLineNumber++;
-            }
-        }
-        const selection = startLineNumber > 1 ? { startLineNumber, startColumn: 4 } : undefined;
-        const editor = await this.editorService.openEditor({
-            resource,
-            options: {
-                selection,
-                preserveFocus,
-                pinned: created,
-                revealIfVisible: true
-            },
-        }, ACTIVE_GROUP);
-        return ({
-            editor: editor ?? null,
-            created
-        });
-    }
-    async writeConfiguration(configuration) {
-        const fullConfig = objects.deepClone(this.getConfig());
-        if (!fullConfig.configurations) {
-            fullConfig.configurations = [];
-        }
-        fullConfig.configurations.push(configuration);
-        await this.configurationService.updateValue('launch', fullConfig, { resource: this.workspace.uri }, 6 );
-    }
-};
-Launch = ( __decorate([
-    ( __param(3, IFileService)),
-    ( __param(4, ITextFileService)),
-    ( __param(5, IEditorService)),
-    ( __param(6, IConfigurationService))
-], Launch));
-let WorkspaceLaunch = class WorkspaceLaunch extends AbstractLaunch {
-    constructor(configurationManager, adapterManager, editorService, configurationService, contextService) {
-        super(configurationManager, adapterManager);
-        this.editorService = editorService;
-        this.configurationService = configurationService;
-        this.contextService = contextService;
-    }
-    get workspace() {
-        return undefined;
-    }
-    get uri() {
-        return this.contextService.getWorkspace().configuration;
-    }
-    get name() {
-        return ( nls.localize('workspace', "workspace"));
-    }
-    getConfig() {
-        return this.configurationService.inspect('launch').workspaceValue;
-    }
-    async openConfigFile({ preserveFocus, type, useInitialConfigs }, token) {
-        const launchExistInFile = !!this.getConfig();
-        if (!launchExistInFile) {
-            const content = await this.getInitialConfigurationContent(undefined, type, useInitialConfigs, token);
-            if (content) {
-                await this.configurationService.updateValue('launch', json.parse(content), 5 );
-            }
-            else {
-                return { editor: null, created: false };
-            }
-        }
-        const editor = await this.editorService.openEditor({
-            resource: this.contextService.getWorkspace().configuration,
-            options: { preserveFocus }
-        }, ACTIVE_GROUP);
-        return ({
-            editor: editor ?? null,
-            created: false
-        });
-    }
-};
-WorkspaceLaunch = ( __decorate([
-    ( __param(2, IEditorService)),
-    ( __param(3, IConfigurationService)),
-    ( __param(4, IWorkspaceContextService))
-], WorkspaceLaunch));
-let UserLaunch = class UserLaunch extends AbstractLaunch {
-    constructor(configurationManager, adapterManager, configurationService, preferencesService) {
-        super(configurationManager, adapterManager);
-        this.configurationService = configurationService;
-        this.preferencesService = preferencesService;
-    }
-    get workspace() {
-        return undefined;
-    }
-    get uri() {
-        return this.preferencesService.userSettingsResource;
-    }
-    get name() {
-        return ( nls.localize('user settings', "user settings"));
-    }
-    get hidden() {
-        return true;
-    }
-    getConfig() {
-        return this.configurationService.inspect('launch').userValue;
-    }
-    async openConfigFile({ preserveFocus, type, useInitialContent }) {
-        const editor = await this.preferencesService.openUserSettings({ jsonEditor: true, preserveFocus, revealSetting: { key: 'launch' } });
-        return ({
-            editor: editor ?? null,
-            created: false
-        });
-    }
-};
-UserLaunch = ( __decorate([
-    ( __param(2, IConfigurationService)),
-    ( __param(3, IPreferencesService))
-], UserLaunch));
-export { ConfigurationManager };

package/vscode/src/vs/workbench/contrib/debug/browser/debugConsoleQuickAccess.js

@@ -1,58 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { matchesFuzzy } from 'monaco-editor/esm/vs/base/common/filters.js';
-import { localize } from 'monaco-editor/esm/vs/nls.js';
-import { ICommandService } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
-import { PickerQuickAccessProvider } from 'monaco-editor/esm/vs/platform/quickinput/browser/pickerQuickAccess.js';
-import { IViewsService } from '../../../common/views.js';
-import { DEBUG_CONSOLE_QUICK_ACCESS_PREFIX, SELECT_AND_START_ID } from './debugCommands.js';
-import { REPL_VIEW_ID, IDebugService } from '../common/debug.js';
-let DebugConsoleQuickAccess = class DebugConsoleQuickAccess extends PickerQuickAccessProvider {
-    constructor(_debugService, _viewsService, _commandService) {
-        super(DEBUG_CONSOLE_QUICK_ACCESS_PREFIX, { canAcceptInBackground: true });
-        this._debugService = _debugService;
-        this._viewsService = _viewsService;
-        this._commandService = _commandService;
-    }
-    _getPicks(filter, disposables, token) {
-        const debugConsolePicks = [];
-        this._debugService.getModel().getSessions(true).filter(s => s.hasSeparateRepl()).forEach((session, index) => {
-            const pick = this._createPick(session, index, filter);
-            if (pick) {
-                debugConsolePicks.push(pick);
-            }
-        });
-        if (debugConsolePicks.length > 0) {
-            debugConsolePicks.push({ type: 'separator' });
-        }
-        const createTerminalLabel = ( localize("workbench.action.debug.startDebug", "Start a New Debug Session"));
-        debugConsolePicks.push({
-            label: `$(plus) ${createTerminalLabel}`,
-            ariaLabel: createTerminalLabel,
-            accept: () => this._commandService.executeCommand(SELECT_AND_START_ID)
-        });
-        return debugConsolePicks;
-    }
-    _createPick(session, sessionIndex, filter) {
-        const label = session.name;
-        const highlights = matchesFuzzy(filter, label, true);
-        if (highlights) {
-            return {
-                label,
-                highlights: { label: highlights },
-                accept: (keyMod, event) => {
-                    this._debugService.focusStackFrame(undefined, undefined, session, { explicit: true });
-                    if (!this._viewsService.isViewVisible(REPL_VIEW_ID)) {
-                        this._viewsService.openView(REPL_VIEW_ID, true);
-                    }
-                }
-            };
-        }
-        return undefined;
-    }
-};
-DebugConsoleQuickAccess = ( __decorate([
-    ( __param(0, IDebugService)),
-    ( __param(1, IViewsService)),
-    ( __param(2, ICommandService))
-], DebugConsoleQuickAccess));
-export { DebugConsoleQuickAccess };