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

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

@@ -0,0 +1,87 @@
+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

@@ -0,0 +1,64 @@
+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

@@ -0,0 +1,311 @@
+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

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