@codingame/monaco-vscode-debug-service-override 1.82.4 → 1.82.5-next.0

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

@@ -0,0 +1,283 @@
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import Severity from 'monaco-editor/esm/vs/base/common/severity.js';
+import { isObject, isString } from 'monaco-editor/esm/vs/base/common/types.js';
+import { generateUuid } from 'monaco-editor/esm/vs/base/common/uuid.js';
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import { ExpressionContainer } from './debugModel.js';
+
+const MAX_REPL_LENGTH = 10000;
+let topReplElementCounter = 0;
+const getUniqueId = () => `topReplElement:${topReplElementCounter++}`;
+class ReplOutputElement {
+    constructor(session, id, value, severity, sourceData, expression) {
+        this.session = session;
+        this.id = id;
+        this.value = value;
+        this.severity = severity;
+        this.sourceData = sourceData;
+        this.expression = expression;
+        this._count = 1;
+        this._onDidChangeCount = ( new Emitter());
+    }
+    toString(includeSource = false) {
+        let valueRespectCount = this.value;
+        for (let i = 1; i < this.count; i++) {
+            valueRespectCount += (valueRespectCount.endsWith('\n') ? '' : '\n') + this.value;
+        }
+        const sourceStr = (this.sourceData && includeSource) ? ` ${this.sourceData.source.name}` : '';
+        return valueRespectCount + sourceStr;
+    }
+    getId() {
+        return this.id;
+    }
+    getChildren() {
+        return this.expression?.getChildren() || Promise.resolve([]);
+    }
+    set count(value) {
+        this._count = value;
+        this._onDidChangeCount.fire();
+    }
+    get count() {
+        return this._count;
+    }
+    get onDidChangeCount() {
+        return this._onDidChangeCount.event;
+    }
+    get hasChildren() {
+        return !!this.expression?.hasChildren;
+    }
+}
+class ReplVariableElement {
+    constructor(expression, severity, sourceData) {
+        this.expression = expression;
+        this.severity = severity;
+        this.sourceData = sourceData;
+        this.id = generateUuid();
+        this.hasChildren = expression.hasChildren;
+    }
+    getChildren() {
+        return this.expression.getChildren();
+    }
+    toString() {
+        return ( this.expression.toString());
+    }
+    getId() {
+        return this.id;
+    }
+}
+class RawObjectReplElement {
+    static { this.MAX_CHILDREN = 1000; }
+    constructor(id, name, valueObj, sourceData, annotation) {
+        this.id = id;
+        this.name = name;
+        this.valueObj = valueObj;
+        this.sourceData = sourceData;
+        this.annotation = annotation;
+    }
+    getId() {
+        return this.id;
+    }
+    get value() {
+        if (this.valueObj === null) {
+            return 'null';
+        }
+        else if (Array.isArray(this.valueObj)) {
+            return `Array[${this.valueObj.length}]`;
+        }
+        else if (isObject(this.valueObj)) {
+            return 'Object';
+        }
+        else if (isString(this.valueObj)) {
+            return `"${this.valueObj}"`;
+        }
+        return String(this.valueObj) || '';
+    }
+    get hasChildren() {
+        return (Array.isArray(this.valueObj) && this.valueObj.length > 0) || (isObject(this.valueObj) && Object.getOwnPropertyNames(this.valueObj).length > 0);
+    }
+    evaluateLazy() {
+        throw new Error('Method not implemented.');
+    }
+    getChildren() {
+        let result = [];
+        if (Array.isArray(this.valueObj)) {
+            result = ( this.valueObj.slice(0, RawObjectReplElement.MAX_CHILDREN)
+                .map((v, index) => ( new RawObjectReplElement(`${this.id}:${index}`, String(index), v))));
+        }
+        else if (isObject(this.valueObj)) {
+            result = ( Object.getOwnPropertyNames(this.valueObj).slice(0, RawObjectReplElement.MAX_CHILDREN)
+                .map((key, index) => ( new RawObjectReplElement(`${this.id}:${index}`, key, this.valueObj[key]))));
+        }
+        return Promise.resolve(result);
+    }
+    toString() {
+        return `${this.name}\n${this.value}`;
+    }
+}
+class ReplEvaluationInput {
+    constructor(value) {
+        this.value = value;
+        this.id = generateUuid();
+    }
+    toString() {
+        return this.value;
+    }
+    getId() {
+        return this.id;
+    }
+}
+class ReplEvaluationResult extends ExpressionContainer {
+    get available() {
+        return this._available;
+    }
+    constructor(originalExpression) {
+        super(undefined, undefined, 0, generateUuid());
+        this.originalExpression = originalExpression;
+        this._available = true;
+    }
+    async evaluateExpression(expression, session, stackFrame, context) {
+        const result = await super.evaluateExpression(expression, session, stackFrame, context);
+        this._available = result;
+        return result;
+    }
+    toString() {
+        return `${this.value}`;
+    }
+}
+class ReplGroup {
+    static { this.COUNTER = 0; }
+    constructor(name, autoExpand, sourceData) {
+        this.name = name;
+        this.autoExpand = autoExpand;
+        this.sourceData = sourceData;
+        this.children = [];
+        this.ended = false;
+        this.id = `replGroup:${ReplGroup.COUNTER++}`;
+    }
+    get hasChildren() {
+        return true;
+    }
+    getId() {
+        return this.id;
+    }
+    toString(includeSource = false) {
+        const sourceStr = (includeSource && this.sourceData) ? ` ${this.sourceData.source.name}` : '';
+        return this.name + sourceStr;
+    }
+    addChild(child) {
+        const lastElement = this.children.length ? this.children[this.children.length - 1] : undefined;
+        if (lastElement instanceof ReplGroup && !lastElement.hasEnded) {
+            lastElement.addChild(child);
+        }
+        else {
+            this.children.push(child);
+        }
+    }
+    getChildren() {
+        return this.children;
+    }
+    end() {
+        const lastElement = this.children.length ? this.children[this.children.length - 1] : undefined;
+        if (lastElement instanceof ReplGroup && !lastElement.hasEnded) {
+            lastElement.end();
+        }
+        else {
+            this.ended = true;
+        }
+    }
+    get hasEnded() {
+        return this.ended;
+    }
+}
+function areSourcesEqual(first, second) {
+    if (!first && !second) {
+        return true;
+    }
+    if (first && second) {
+        return first.column === second.column && first.lineNumber === second.lineNumber && ( first.source.uri.toString()) === ( second.source.uri.toString());
+    }
+    return false;
+}
+class ReplModel {
+    constructor(configurationService) {
+        this.configurationService = configurationService;
+        this.replElements = [];
+        this._onDidChangeElements = ( new Emitter());
+        this.onDidChangeElements = this._onDidChangeElements.event;
+    }
+    getReplElements() {
+        return this.replElements;
+    }
+    async addReplExpression(session, stackFrame, name) {
+        this.addReplElement(( new ReplEvaluationInput(name)));
+        const result = ( new ReplEvaluationResult(name));
+        await result.evaluateExpression(name, session, stackFrame, 'repl');
+        this.addReplElement(result);
+    }
+    appendToRepl(session, { output, expression, sev, source }) {
+        const clearAnsiSequence = '\u001b[2J';
+        const clearAnsiIndex = output.lastIndexOf(clearAnsiSequence);
+        if (clearAnsiIndex !== -1) {
+            this.removeReplExpressions();
+            this.appendToRepl(session, { output: ( nls.localize('consoleCleared', "Console was cleared")), sev: Severity.Ignore });
+            output = output.substring(clearAnsiIndex + clearAnsiSequence.length);
+        }
+        if (expression) {
+            this.addReplElement(output
+                ? ( new ReplOutputElement(session, getUniqueId(), output, sev, source, expression))
+                : ( new ReplVariableElement(expression, sev, source)));
+            return;
+        }
+        const previousElement = this.replElements.length ? this.replElements[this.replElements.length - 1] : undefined;
+        if (previousElement instanceof ReplOutputElement && previousElement.severity === sev) {
+            const config = this.configurationService.getValue('debug');
+            if (previousElement.value === output && areSourcesEqual(previousElement.sourceData, source) && config.console.collapseIdenticalLines) {
+                previousElement.count++;
+                return;
+            }
+            if (!previousElement.value.endsWith('\n') && !previousElement.value.endsWith('\r\n') && previousElement.count === 1) {
+                this.replElements[this.replElements.length - 1] = ( new ReplOutputElement(session, getUniqueId(), previousElement.value + output, sev, source));
+                this._onDidChangeElements.fire();
+                return;
+            }
+        }
+        const element = ( new ReplOutputElement(session, getUniqueId(), output, sev, source));
+        this.addReplElement(element);
+    }
+    startGroup(name, autoExpand, sourceData) {
+        const group = ( new ReplGroup(name, autoExpand, sourceData));
+        this.addReplElement(group);
+    }
+    endGroup() {
+        const lastElement = this.replElements[this.replElements.length - 1];
+        if (lastElement instanceof ReplGroup) {
+            lastElement.end();
+        }
+    }
+    addReplElement(newElement) {
+        const lastElement = this.replElements.length ? this.replElements[this.replElements.length - 1] : undefined;
+        if (lastElement instanceof ReplGroup && !lastElement.hasEnded) {
+            lastElement.addChild(newElement);
+        }
+        else {
+            this.replElements.push(newElement);
+            if (this.replElements.length > MAX_REPL_LENGTH) {
+                this.replElements.splice(0, this.replElements.length - MAX_REPL_LENGTH);
+            }
+        }
+        this._onDidChangeElements.fire();
+    }
+    removeReplExpressions() {
+        if (this.replElements.length > 0) {
+            this.replElements = [];
+            this._onDidChangeElements.fire();
+        }
+    }
+    clone() {
+        const newRepl = ( new ReplModel(this.configurationService));
+        newRepl.replElements = this.replElements.slice();
+        return newRepl;
+    }
+}
+
+export { RawObjectReplElement, ReplEvaluationInput, ReplEvaluationResult, ReplGroup, ReplModel, ReplOutputElement, ReplVariableElement };

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

@@ -0,0 +1,305 @@
+import { Queue } from 'monaco-editor/esm/vs/base/common/async.js';
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+import * as types from 'monaco-editor/esm/vs/base/common/types.js';
+import { isCodeEditor, isDiffEditor } from 'monaco-editor/esm/vs/editor/browser/editorBrowser.js';
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+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' && !types.isUndefinedOrNull(result)) {
+                        throw new Error(nls.localize('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(( nls.localize(
+                '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(nls.localize('inputVariable.missingAttribute', "Input variable '{0}' is of type '{1}' and must include '{2}'.", variable, info.type, attrName));
+            };
+            switch (info.type) {
+                case 'promptString': {
+                    if (!types.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 (!types.isString(info.description)) {
+                        missingAttribute('description');
+                    }
+                    if (Array.isArray(info.options)) {
+                        for (const pickOption of info.options) {
+                            if (!types.isString(pickOption) && !types.isString(pickOption.value)) {
+                                missingAttribute('value');
+                            }
+                        }
+                    }
+                    else {
+                        missingAttribute('options');
+                    }
+                    const picks = ( new Array());
+                    for (const pickOption of info.options) {
+                        const value = types.isString(pickOption) ? pickOption : pickOption.value;
+                        const label = types.isString(pickOption) ? undefined : pickOption.label;
+                        const item = {
+                            label: label ? `${label}: ${value}` : value,
+                            value: value
+                        };
+                        if (value === info.default) {
+                            item.description = ( nls.localize('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 (!types.isString(info.command)) {
+                        missingAttribute('command');
+                    }
+                    return this.userInputAccessQueue.queue(() => this.commandService.executeCommand(info.command, info.args)).then(result => {
+                        if (typeof result === 'string' || types.isUndefinedOrNull(result)) {
+                            return result;
+                        }
+                        throw new Error(nls.localize('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(nls.localize('inputVariable.unknownType', "Input variable '{0}' can only be of type 'promptString', 'pickString', or 'command'.", variable));
+            }
+        }
+        return Promise.reject(( new Error(( nls.localize(
+            '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,28 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { ICommandService } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { ILabelService } from 'monaco-editor/esm/vs/platform/label/common/label.js';
+import { IQuickInputService } from 'monaco-editor/esm/vs/platform/quickinput/common/quickInput.js';
+import { IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
+import { BaseConfigurationResolverService } from './baseConfigurationResolverService.js';
+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 };