@codingame/monaco-vscode-debug-service-override 4.0.0 → 4.1.0

package/vscode/src/vs/workbench/contrib/debug/common/loadedScriptsPicker.js

@@ -1,87 +0,0 @@
-import { localizeWithPath } from 'vscode/vscode/vs/nls';
-import { matchesFuzzy } from 'vscode/vscode/vs/base/common/filters';
-import { IQuickInputService } from 'vscode/vscode/vs/platform/quickinput/common/quickInput';
-import { IDebugService } from 'vscode/vscode/vs/workbench/contrib/debug/common/debug';
-import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
-import { getIconClasses } from 'vscode/vscode/vs/editor/common/services/getIconClasses';
-import { IModelService } from 'vscode/vscode/vs/editor/common/services/model';
-import { ILanguageService } from 'vscode/vscode/vs/editor/common/languages/language';
-import { DisposableStore } from 'vscode/vscode/vs/base/common/lifecycle';
-import { dirname } from 'vscode/vscode/vs/base/common/resources';
-import { ILabelService } from 'vscode/vscode/vs/platform/label/common/label';
-
-async function showLoadedScriptMenu(accessor) {
-    const quickInputService = accessor.get(IQuickInputService);
-    const debugService = accessor.get(IDebugService);
-    const editorService = accessor.get(IEditorService);
-    const sessions = debugService.getModel().getSessions(false);
-    const modelService = accessor.get(IModelService);
-    const languageService = accessor.get(ILanguageService);
-    const labelService = accessor.get(ILabelService);
-    const localDisposableStore = ( new DisposableStore());
-    const quickPick = quickInputService.createQuickPick();
-    localDisposableStore.add(quickPick);
-    quickPick.matchOnLabel = quickPick.matchOnDescription = quickPick.matchOnDetail = quickPick.sortByLabel = false;
-    quickPick.placeholder = ( localizeWithPath(
-        'vs/workbench/contrib/debug/common/loadedScriptsPicker',
-        'moveFocusedView.selectView',
-        "Search loaded scripts by name"
-    ));
-    quickPick.items = await _getPicks(quickPick.value, sessions, editorService, modelService, languageService, labelService);
-    localDisposableStore.add(quickPick.onDidChangeValue(async () => {
-        quickPick.items = await _getPicks(quickPick.value, sessions, editorService, modelService, languageService, labelService);
-    }));
-    localDisposableStore.add(quickPick.onDidAccept(() => {
-        const selectedItem = quickPick.selectedItems[0];
-        selectedItem.accept();
-        quickPick.hide();
-        localDisposableStore.dispose();
-    }));
-    quickPick.show();
-}
-async function _getPicksFromSession(session, filter, editorService, modelService, languageService, labelService) {
-    const items = [];
-    items.push({ type: 'separator', label: session.name });
-    const sources = await session.getLoadedSources();
-    sources.forEach((element) => {
-        const pick = _createPick(element, filter, editorService, modelService, languageService, labelService);
-        if (pick) {
-            items.push(pick);
-        }
-    });
-    return items;
-}
-async function _getPicks(filter, sessions, editorService, modelService, languageService, labelService) {
-    const loadedScriptPicks = [];
-    const picks = await Promise.all(( sessions.map(
-        (session) => _getPicksFromSession(session, filter, editorService, modelService, languageService, labelService)
-    )));
-    for (const row of picks) {
-        for (const elem of row) {
-            loadedScriptPicks.push(elem);
-        }
-    }
-    return loadedScriptPicks;
-}
-function _createPick(source, filter, editorService, modelService, languageService, labelService) {
-    const label = labelService.getUriBasenameLabel(source.uri);
-    const desc = labelService.getUriLabel(dirname(source.uri));
-    const labelHighlights = matchesFuzzy(filter, label, true);
-    const descHighlights = matchesFuzzy(filter, desc, true);
-    if (labelHighlights || descHighlights) {
-        return {
-            label,
-            description: desc === '.' ? undefined : desc,
-            highlights: { label: labelHighlights ?? undefined, description: descHighlights ?? undefined },
-            iconClasses: getIconClasses(modelService, languageService, source.uri),
-            accept: () => {
-                if (source.available) {
-                    source.openInEditor(editorService, { startLineNumber: 0, startColumn: 0, endLineNumber: 0, endColumn: 0 });
-                }
-            }
-        };
-    }
-    return undefined;
-}
-
-export { showLoadedScriptMenu };

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/notebookVariables/notebookVariableCommands.js

@@ -1,64 +0,0 @@
-import { CancellationToken } from 'vscode/vscode/vs/base/common/cancellation';
-import { URI } from 'vscode/vscode/vs/base/common/uri';
-import { localizeWithPath } from 'vscode/vscode/vs/nls';
-import { registerAction2, Action2 } from 'vscode/vscode/vs/platform/actions/common/actions';
-import { IClipboardService } from 'vscode/vscode/vs/platform/clipboard/common/clipboardService';
-import { INotebookKernelService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookKernelService';
-import { INotebookService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookService';
-
-const COPY_NOTEBOOK_VARIABLE_VALUE_ID = 'workbench.debug.viewlet.action.copyWorkspaceVariableValue';
-const COPY_NOTEBOOK_VARIABLE_VALUE_LABEL = ( localizeWithPath(
-    'vs/workbench/contrib/notebook/browser/contrib/notebookVariables/notebookVariableCommands',
-    'copyWorkspaceVariableValue',
-    "Copy Value"
-));
-registerAction2(class extends Action2 {
-    constructor() {
-        super({
-            id: COPY_NOTEBOOK_VARIABLE_VALUE_ID,
-            title: COPY_NOTEBOOK_VARIABLE_VALUE_LABEL,
-            f1: false,
-        });
-    }
-    run(accessor, context) {
-        const clipboardService = accessor.get(IClipboardService);
-        if (context.value) {
-            clipboardService.writeText(context.value);
-        }
-    }
-});
-registerAction2(class extends Action2 {
-    constructor() {
-        super({
-            id: '_executeNotebookVariableProvider',
-            title: ( localizeWithPath(
-                'vs/workbench/contrib/notebook/browser/contrib/notebookVariables/notebookVariableCommands',
-                'executeNotebookVariableProvider',
-                "Execute Notebook Variable Provider"
-            )),
-            f1: false,
-        });
-    }
-    async run(accessor, resource) {
-        if (!resource) {
-            return [];
-        }
-        const uri = URI.revive(resource);
-        const notebookKernelService = accessor.get(INotebookKernelService);
-        const notebookService = accessor.get(INotebookService);
-        const notebookTextModel = notebookService.getNotebookTextModel(uri);
-        if (!notebookTextModel) {
-            return [];
-        }
-        const selectedKernel = notebookKernelService.getMatchingKernel(notebookTextModel).selected;
-        if (selectedKernel && selectedKernel.hasVariableProvider) {
-            const variables = selectedKernel.provideVariables(notebookTextModel.uri, undefined, 'named', 0, CancellationToken.None);
-            return await ( variables
-                .map(variable => { return variable; }))
-                .toPromise();
-        }
-        return [];
-    }
-});
-
-export { COPY_NOTEBOOK_VARIABLE_VALUE_ID, COPY_NOTEBOOK_VARIABLE_VALUE_LABEL };

package/vscode/src/vs/workbench/services/configurationResolver/browser/baseConfigurationResolverService.js

@@ -1,311 +0,0 @@
-import { Queue } from 'vscode/vscode/vs/base/common/async';
-import { Schemas } from 'vscode/vscode/vs/base/common/network';
-import { isUndefinedOrNull, isString } from 'vscode/vscode/vs/base/common/types';
-import { isCodeEditor, isDiffEditor } from 'vscode/vscode/vs/editor/browser/editorBrowser';
-import { localizeWithPath } from 'vscode/vscode/vs/nls';
-import { EditorResourceAccessor, SideBySideEditor } from 'vscode/vscode/vs/workbench/common/editor';
-import { AbstractVariableResolverService } from 'vscode/vscode/vs/workbench/services/configurationResolver/common/variableResolver';
-
-class BaseConfigurationResolverService extends AbstractVariableResolverService {
-    static { this.INPUT_OR_COMMAND_VARIABLES_PATTERN = /\${((input|command):(.*?))}/g; }
-    constructor(context, envVariablesPromise, editorService, configurationService, commandService, workspaceContextService, quickInputService, labelService, pathService, extensionService) {
-        super({
-            getFolderUri: (folderName) => {
-                const folder = workspaceContextService.getWorkspace().folders.filter(f => f.name === folderName).pop();
-                return folder ? folder.uri : undefined;
-            },
-            getWorkspaceFolderCount: () => {
-                return workspaceContextService.getWorkspace().folders.length;
-            },
-            getConfigurationValue: (folderUri, suffix) => {
-                return configurationService.getValue(suffix, folderUri ? { resource: folderUri } : {});
-            },
-            getAppRoot: () => {
-                return context.getAppRoot();
-            },
-            getExecPath: () => {
-                return context.getExecPath();
-            },
-            getFilePath: () => {
-                const fileResource = EditorResourceAccessor.getOriginalUri(editorService.activeEditor, {
-                    supportSideBySide: SideBySideEditor.PRIMARY,
-                    filterByScheme: [Schemas.file, Schemas.vscodeUserData, this.pathService.defaultUriScheme]
-                });
-                if (!fileResource) {
-                    return undefined;
-                }
-                return this.labelService.getUriLabel(fileResource, { noPrefix: true });
-            },
-            getWorkspaceFolderPathForFile: () => {
-                const fileResource = EditorResourceAccessor.getOriginalUri(editorService.activeEditor, {
-                    supportSideBySide: SideBySideEditor.PRIMARY,
-                    filterByScheme: [Schemas.file, Schemas.vscodeUserData, this.pathService.defaultUriScheme]
-                });
-                if (!fileResource) {
-                    return undefined;
-                }
-                const wsFolder = workspaceContextService.getWorkspaceFolder(fileResource);
-                if (!wsFolder) {
-                    return undefined;
-                }
-                return this.labelService.getUriLabel(wsFolder.uri, { noPrefix: true });
-            },
-            getSelectedText: () => {
-                const activeTextEditorControl = editorService.activeTextEditorControl;
-                let activeControl = null;
-                if (isCodeEditor(activeTextEditorControl)) {
-                    activeControl = activeTextEditorControl;
-                }
-                else if (isDiffEditor(activeTextEditorControl)) {
-                    const original = activeTextEditorControl.getOriginalEditor();
-                    const modified = activeTextEditorControl.getModifiedEditor();
-                    activeControl = original.hasWidgetFocus() ? original : modified;
-                }
-                const activeModel = activeControl?.getModel();
-                const activeSelection = activeControl?.getSelection();
-                if (activeModel && activeSelection) {
-                    return activeModel.getValueInRange(activeSelection);
-                }
-                return undefined;
-            },
-            getLineNumber: () => {
-                const activeTextEditorControl = editorService.activeTextEditorControl;
-                if (isCodeEditor(activeTextEditorControl)) {
-                    const selection = activeTextEditorControl.getSelection();
-                    if (selection) {
-                        const lineNumber = selection.positionLineNumber;
-                        return String(lineNumber);
-                    }
-                }
-                return undefined;
-            },
-            getExtension: id => {
-                return extensionService.getExtension(id);
-            },
-        }, labelService, pathService.userHome().then(home => home.path), envVariablesPromise);
-        this.configurationService = configurationService;
-        this.commandService = commandService;
-        this.workspaceContextService = workspaceContextService;
-        this.quickInputService = quickInputService;
-        this.labelService = labelService;
-        this.pathService = pathService;
-        this.userInputAccessQueue = ( new Queue());
-    }
-    async resolveWithInteractionReplace(folder, config, section, variables, target) {
-        config = await this.resolveAnyAsync(folder, config);
-        return this.resolveWithInteraction(folder, config, section, variables, target).then(mapping => {
-            if (!mapping) {
-                return null;
-            }
-            else if (mapping.size > 0) {
-                return this.resolveAnyAsync(folder, config, Object.fromEntries(mapping));
-            }
-            else {
-                return config;
-            }
-        });
-    }
-    async resolveWithInteraction(folder, config, section, variables, target) {
-        const resolved = await this.resolveAnyMap(folder, config);
-        config = resolved.newConfig;
-        const allVariableMapping = resolved.resolvedVariables;
-        return this.resolveWithInputAndCommands(folder, config, variables, section, target).then(inputOrCommandMapping => {
-            if (this.updateMapping(inputOrCommandMapping, allVariableMapping)) {
-                return allVariableMapping;
-            }
-            return undefined;
-        });
-    }
-    updateMapping(newMapping, fullMapping) {
-        if (!newMapping) {
-            return false;
-        }
-        for (const [key, value] of Object.entries(newMapping)) {
-            fullMapping.set(key, value);
-        }
-        return true;
-    }
-    async resolveWithInputAndCommands(folder, configuration, variableToCommandMap, section, target) {
-        if (!configuration) {
-            return Promise.resolve(undefined);
-        }
-        let inputs = [];
-        if (this.workspaceContextService.getWorkbenchState() !== 1  && section) {
-            const overrides = folder ? { resource: folder.uri } : {};
-            const result = this.configurationService.inspect(section, overrides);
-            if (result && (result.userValue || result.workspaceValue || result.workspaceFolderValue)) {
-                switch (target) {
-                    case 2 :
-                        inputs = result.userValue?.inputs;
-                        break;
-                    case 5 :
-                        inputs = result.workspaceValue?.inputs;
-                        break;
-                    default: inputs = result.workspaceFolderValue?.inputs;
-                }
-            }
-            else {
-                const valueResult = this.configurationService.getValue(section, overrides);
-                if (valueResult) {
-                    inputs = valueResult.inputs;
-                }
-            }
-        }
-        const variables = [];
-        this.findVariables(configuration, variables);
-        const variableValues = Object.create(null);
-        for (const variable of variables) {
-            const [type, name] = variable.split(':', 2);
-            let result;
-            switch (type) {
-                case 'input':
-                    result = await this.showUserInput(name, inputs);
-                    break;
-                case 'command': {
-                    const commandId = (variableToCommandMap ? variableToCommandMap[name] : undefined) || name;
-                    result = await this.commandService.executeCommand(commandId, configuration);
-                    if (typeof result !== 'string' && !isUndefinedOrNull(result)) {
-                        throw new Error(localizeWithPath('vs/workbench/services/configurationResolver/browser/baseConfigurationResolverService', 'commandVariable.noStringType', "Cannot substitute command variable '{0}' because command did not return a result of type string.", commandId));
-                    }
-                    break;
-                }
-                default:
-                    if (( this._contributedVariables.has(variable))) {
-                        result = await this._contributedVariables.get(variable)();
-                    }
-            }
-            if (typeof result === 'string') {
-                variableValues[variable] = result;
-            }
-            else {
-                return undefined;
-            }
-        }
-        return variableValues;
-    }
-    findVariables(object, variables) {
-        if (typeof object === 'string') {
-            let matches;
-            while ((matches = BaseConfigurationResolverService.INPUT_OR_COMMAND_VARIABLES_PATTERN.exec(object)) !== null) {
-                if (matches.length === 4) {
-                    const command = matches[1];
-                    if (variables.indexOf(command) < 0) {
-                        variables.push(command);
-                    }
-                }
-            }
-            for (const contributed of ( this._contributedVariables.keys())) {
-                if ((variables.indexOf(contributed) < 0) && (object.indexOf('${' + contributed + '}') >= 0)) {
-                    variables.push(contributed);
-                }
-            }
-        }
-        else if (Array.isArray(object)) {
-            for (const value of object) {
-                this.findVariables(value, variables);
-            }
-        }
-        else if (object) {
-            for (const value of ( Object.values(object))) {
-                this.findVariables(value, variables);
-            }
-        }
-    }
-    showUserInput(variable, inputInfos) {
-        if (!inputInfos) {
-            return Promise.reject(( new Error(( localizeWithPath(
-                'vs/workbench/services/configurationResolver/browser/baseConfigurationResolverService',
-                'inputVariable.noInputSection',
-                "Variable '{0}' must be defined in an '{1}' section of the debug or task configuration.",
-                variable,
-                'input'
-            )))));
-        }
-        const info = inputInfos.filter(item => item.id === variable).pop();
-        if (info) {
-            const missingAttribute = (attrName) => {
-                throw new Error(localizeWithPath('vs/workbench/services/configurationResolver/browser/baseConfigurationResolverService', 'inputVariable.missingAttribute', "Input variable '{0}' is of type '{1}' and must include '{2}'.", variable, info.type, attrName));
-            };
-            switch (info.type) {
-                case 'promptString': {
-                    if (!isString(info.description)) {
-                        missingAttribute('description');
-                    }
-                    const inputOptions = { prompt: info.description, ignoreFocusLost: true };
-                    if (info.default) {
-                        inputOptions.value = info.default;
-                    }
-                    if (info.password) {
-                        inputOptions.password = info.password;
-                    }
-                    return this.userInputAccessQueue.queue(() => this.quickInputService.input(inputOptions)).then(resolvedInput => {
-                        return resolvedInput;
-                    });
-                }
-                case 'pickString': {
-                    if (!isString(info.description)) {
-                        missingAttribute('description');
-                    }
-                    if (Array.isArray(info.options)) {
-                        for (const pickOption of info.options) {
-                            if (!isString(pickOption) && !isString(pickOption.value)) {
-                                missingAttribute('value');
-                            }
-                        }
-                    }
-                    else {
-                        missingAttribute('options');
-                    }
-                    const picks = ( new Array());
-                    for (const pickOption of info.options) {
-                        const value = isString(pickOption) ? pickOption : pickOption.value;
-                        const label = isString(pickOption) ? undefined : pickOption.label;
-                        const item = {
-                            label: label ? `${label}: ${value}` : value,
-                            value: value
-                        };
-                        if (value === info.default) {
-                            item.description = ( localizeWithPath(
-                                'vs/workbench/services/configurationResolver/browser/baseConfigurationResolverService',
-                                'inputVariable.defaultInputValue',
-                                "(Default)"
-                            ));
-                            picks.unshift(item);
-                        }
-                        else {
-                            picks.push(item);
-                        }
-                    }
-                    const pickOptions = { placeHolder: info.description, matchOnDetail: true, ignoreFocusLost: true };
-                    return this.userInputAccessQueue.queue(() => this.quickInputService.pick(picks, pickOptions, undefined)).then(resolvedInput => {
-                        if (resolvedInput) {
-                            return resolvedInput.value;
-                        }
-                        return undefined;
-                    });
-                }
-                case 'command': {
-                    if (!isString(info.command)) {
-                        missingAttribute('command');
-                    }
-                    return this.userInputAccessQueue.queue(() => this.commandService.executeCommand(info.command, info.args)).then(result => {
-                        if (typeof result === 'string' || isUndefinedOrNull(result)) {
-                            return result;
-                        }
-                        throw new Error(localizeWithPath('vs/workbench/services/configurationResolver/browser/baseConfigurationResolverService', 'inputVariable.command.noStringType', "Cannot substitute input variable '{0}' because command '{1}' did not return a result of type string.", variable, info.command));
-                    });
-                }
-                default:
-                    throw new Error(localizeWithPath('vs/workbench/services/configurationResolver/browser/baseConfigurationResolverService', 'inputVariable.unknownType', "Input variable '{0}' can only be of type 'promptString', 'pickString', or 'command'.", variable));
-            }
-        }
-        return Promise.reject(( new Error(( localizeWithPath(
-            'vs/workbench/services/configurationResolver/browser/baseConfigurationResolverService',
-            'inputVariable.undefinedVariable',
-            "Undefined input variable '{0}' encountered. Remove or define '{0}' to continue.",
-            variable
-        )))));
-    }
-}
-
-export { BaseConfigurationResolverService };

package/vscode/src/vs/workbench/services/configurationResolver/browser/configurationResolverService.js

@@ -1,29 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { ICommandService } from 'vscode/vscode/vs/platform/commands/common/commands';
-import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration';
-import { ILabelService } from 'vscode/vscode/vs/platform/label/common/label';
-import { IQuickInputService } from 'vscode/vscode/vs/platform/quickinput/common/quickInput';
-import { IWorkspaceContextService } from 'vscode/vscode/vs/platform/workspace/common/workspace';
-import { BaseConfigurationResolverService } from './baseConfigurationResolverService.js';
-import 'vscode/vscode/vs/workbench/services/configurationResolver/common/configurationResolver';
-import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
-import { IExtensionService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions';
-import { IPathService } from 'vscode/vscode/vs/workbench/services/path/common/pathService';
-
-let ConfigurationResolverService = class ConfigurationResolverService extends BaseConfigurationResolverService {
-    constructor(editorService, configurationService, commandService, workspaceContextService, quickInputService, labelService, pathService, extensionService) {
-        super({ getAppRoot: () => undefined, getExecPath: () => undefined }, Promise.resolve(Object.create(null)), editorService, configurationService, commandService, workspaceContextService, quickInputService, labelService, pathService, extensionService);
-    }
-};
-ConfigurationResolverService = ( __decorate([
-    ( __param(0, IEditorService)),
-    ( __param(1, IConfigurationService)),
-    ( __param(2, ICommandService)),
-    ( __param(3, IWorkspaceContextService)),
-    ( __param(4, IQuickInputService)),
-    ( __param(5, ILabelService)),
-    ( __param(6, IPathService)),
-    ( __param(7, IExtensionService))
-], ConfigurationResolverService));
-
-export { ConfigurationResolverService };