@codingame/monaco-vscode-api 4.1.0 → 4.1.1

package/vscode/src/vs/workbench/services/configuration/common/configurationModels.js

@@ -1,119 +0,0 @@
-import { equals } from '../../../../base/common/objects.js';
-import { toValuesTree } from '../../../../platform/configuration/common/configuration.js';
-import { Configuration as Configuration$1, ConfigurationModelParser, ConfigurationModel } from '../../../../platform/configuration/common/configurationModels.js';
-import { isBoolean } from '../../../../base/common/types.js';
-import { distinct } from '../../../../base/common/arrays.js';
-class WorkspaceConfigurationModelParser extends ConfigurationModelParser {
-    constructor(name) {
-        super(name);
-        this._folders = [];
-        this._transient = false;
-        this._settingsModelParser = ( new ConfigurationModelParser(name));
-        this._launchModel = ( new ConfigurationModel());
-        this._tasksModel = ( new ConfigurationModel());
-    }
-    get folders() {
-        return this._folders;
-    }
-    get transient() {
-        return this._transient;
-    }
-    get settingsModel() {
-        return this._settingsModelParser.configurationModel;
-    }
-    get launchModel() {
-        return this._launchModel;
-    }
-    get tasksModel() {
-        return this._tasksModel;
-    }
-    reparseWorkspaceSettings(configurationParseOptions) {
-        this._settingsModelParser.reparse(configurationParseOptions);
-    }
-    getRestrictedWorkspaceSettings() {
-        return this._settingsModelParser.restrictedConfigurations;
-    }
-    doParseRaw(raw, configurationParseOptions) {
-        this._folders = (raw['folders'] || []);
-        this._transient = isBoolean(raw['transient']) && raw['transient'];
-        this._settingsModelParser.parseRaw(raw['settings'], configurationParseOptions);
-        this._launchModel = this.createConfigurationModelFrom(raw, 'launch');
-        this._tasksModel = this.createConfigurationModelFrom(raw, 'tasks');
-        return super.doParseRaw(raw, configurationParseOptions);
-    }
-    createConfigurationModelFrom(raw, key) {
-        const data = raw[key];
-        if (data) {
-            const contents = toValuesTree(data, message => console.error(`Conflict in settings file ${this._name}: ${message}`));
-            const scopedContents = Object.create(null);
-            scopedContents[key] = contents;
-            const keys = ( ( Object.keys(data)).map(k => `${key}.${k}`));
-            return ( new ConfigurationModel(scopedContents, keys, []));
-        }
-        return ( new ConfigurationModel());
-    }
-}
-class StandaloneConfigurationModelParser extends ConfigurationModelParser {
-    constructor(name, scope) {
-        super(name);
-        this.scope = scope;
-    }
-    doParseRaw(raw, configurationParseOptions) {
-        const contents = toValuesTree(raw, message => console.error(`Conflict in settings file ${this._name}: ${message}`));
-        const scopedContents = Object.create(null);
-        scopedContents[this.scope] = contents;
-        const keys = ( ( Object.keys(raw)).map(key => `${this.scope}.${key}`));
-        return { contents: scopedContents, keys, overrides: [] };
-    }
-}
-class Configuration extends Configuration$1 {
-    constructor(defaults, policy, application, localUser, remoteUser, workspaceConfiguration, folders, memoryConfiguration, memoryConfigurationByResource, _workspace) {
-        super(defaults, policy, application, localUser, remoteUser, workspaceConfiguration, folders, memoryConfiguration, memoryConfigurationByResource);
-        this._workspace = _workspace;
-    }
-    getValue(key, overrides = {}) {
-        return super.getValue(key, overrides, this._workspace);
-    }
-    inspect(key, overrides = {}) {
-        return super.inspect(key, overrides, this._workspace);
-    }
-    keys() {
-        return ( super.keys(this._workspace));
-    }
-    compareAndDeleteFolderConfiguration(folder) {
-        if (this._workspace && this._workspace.folders.length > 0 && ( this._workspace.folders[0].uri.toString()) === ( folder.toString())) {
-            return { keys: [], overrides: [] };
-        }
-        return super.compareAndDeleteFolderConfiguration(folder);
-    }
-    compare(other) {
-        const compare = (fromKeys, toKeys, overrideIdentifier) => {
-            const keys = [];
-            keys.push(...toKeys.filter(key => fromKeys.indexOf(key) === -1));
-            keys.push(...fromKeys.filter(key => toKeys.indexOf(key) === -1));
-            keys.push(...fromKeys.filter(key => {
-                if (toKeys.indexOf(key) === -1) {
-                    return false;
-                }
-                if (!equals(this.getValue(key, { overrideIdentifier }), other.getValue(key, { overrideIdentifier }))) {
-                    return true;
-                }
-                return this._workspace && ( this._workspace.folders.some(
-                    folder => !equals(this.getValue(key, { resource: folder.uri, overrideIdentifier }), other.getValue(key, { resource: folder.uri, overrideIdentifier }))
-                ));
-            }));
-            return keys;
-        };
-        const keys = compare(this.allKeys(), other.allKeys());
-        const overrides = [];
-        const allOverrideIdentifiers = distinct([...this.allOverrideIdentifiers(), ...other.allOverrideIdentifiers()]);
-        for (const overrideIdentifier of allOverrideIdentifiers) {
-            const keys = compare(this.getAllKeysForOverrideIdentifier(overrideIdentifier), other.getAllKeysForOverrideIdentifier(overrideIdentifier), overrideIdentifier);
-            if (keys.length) {
-                overrides.push([overrideIdentifier, keys]);
-            }
-        }
-        return { keys, overrides };
-    }
-}
-export { Configuration, StandaloneConfigurationModelParser, WorkspaceConfigurationModelParser };

package/vscode/src/vs/workbench/services/configuration/common/jsonEditingService.js

@@ -1,120 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { localizeWithPath } from '../../../../nls.js';
-import { parse } from '../../../../base/common/json.js';
-import { setProperty } from '../../../../base/common/jsonEdit.js';
-import { Queue } from '../../../../base/common/async.js';
-import { EditOperation } from '../../../../editor/common/core/editOperation.js';
-import { Range } from '../../../../editor/common/core/range.js';
-import { Selection } from '../../../../editor/common/core/selection.js';
-import { ITextFileService } from '../../textfile/common/textfiles.js';
-import { IFileService } from '../../../../platform/files/common/files.js';
-import { ITextModelService } from '../../../../editor/common/services/resolverService.js';
-import { JSONEditingError } from './jsonEditing.js';
-let JSONEditingService = class JSONEditingService {
-    constructor(fileService, textModelResolverService, textFileService) {
-        this.fileService = fileService;
-        this.textModelResolverService = textModelResolverService;
-        this.textFileService = textFileService;
-        this.queue = ( new Queue());
-    }
-    write(resource, values) {
-        return Promise.resolve(this.queue.queue(() => this.doWriteConfiguration(resource, values)));
-    }
-    async doWriteConfiguration(resource, values) {
-        const reference = await this.resolveAndValidate(resource, true);
-        try {
-            await this.writeToBuffer(reference.object.textEditorModel, values);
-        }
-        finally {
-            reference.dispose();
-        }
-    }
-    async writeToBuffer(model, values) {
-        let hasEdits = false;
-        for (const value of values) {
-            const edit = this.getEdits(model, value)[0];
-            hasEdits = !!edit && this.applyEditsToBuffer(edit, model);
-        }
-        if (hasEdits) {
-            return this.textFileService.save(model.uri);
-        }
-    }
-    applyEditsToBuffer(edit, model) {
-        const startPosition = model.getPositionAt(edit.offset);
-        const endPosition = model.getPositionAt(edit.offset + edit.length);
-        const range = ( new Range(
-            startPosition.lineNumber,
-            startPosition.column,
-            endPosition.lineNumber,
-            endPosition.column
-        ));
-        const currentText = model.getValueInRange(range);
-        if (edit.content !== currentText) {
-            const editOperation = currentText ? EditOperation.replace(range, edit.content) : EditOperation.insert(startPosition, edit.content);
-            model.pushEditOperations([( new Selection(
-                startPosition.lineNumber,
-                startPosition.column,
-                startPosition.lineNumber,
-                startPosition.column
-            ))], [editOperation], () => []);
-            return true;
-        }
-        return false;
-    }
-    getEdits(model, configurationValue) {
-        const { tabSize, insertSpaces } = model.getOptions();
-        const eol = model.getEOL();
-        const { path, value } = configurationValue;
-        if (!path.length) {
-            const content = JSON.stringify(value, null, insertSpaces ? ' '.repeat(tabSize) : '\t');
-            return [{
-                    content,
-                    length: content.length,
-                    offset: 0
-                }];
-        }
-        return setProperty(model.getValue(), path, value, { tabSize, insertSpaces, eol });
-    }
-    async resolveModelReference(resource) {
-        const exists = await this.fileService.exists(resource);
-        if (!exists) {
-            await this.textFileService.write(resource, '{}', { encoding: 'utf8' });
-        }
-        return this.textModelResolverService.createModelReference(resource);
-    }
-    hasParseErrors(model) {
-        const parseErrors = [];
-        parse(model.getValue(), parseErrors, { allowTrailingComma: true, allowEmptyContent: true });
-        return parseErrors.length > 0;
-    }
-    async resolveAndValidate(resource, checkDirty) {
-        const reference = await this.resolveModelReference(resource);
-        const model = reference.object.textEditorModel;
-        if (this.hasParseErrors(model)) {
-            reference.dispose();
-            return this.reject(0 );
-        }
-        return reference;
-    }
-    reject(code) {
-        const message = this.toErrorMessage(code);
-        return Promise.reject(( new JSONEditingError(message, code)));
-    }
-    toErrorMessage(error) {
-        switch (error) {
-            case 0 : {
-                return ( localizeWithPath(
-                    'vs/workbench/services/configuration/common/jsonEditingService',
-                    'errorInvalidFile',
-                    "Unable to write into the file. Please open the file to correct errors/warnings in the file and try again."
-                ));
-            }
-        }
-    }
-};
-JSONEditingService = ( __decorate([
-    ( __param(0, IFileService)),
-    ( __param(1, ITextModelService)),
-    ( __param(2, ITextFileService))
-], JSONEditingService));
-export { JSONEditingService };

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

@@ -1,309 +0,0 @@
-import { Queue } from '../../../../base/common/async.js';
-import { Schemas } from '../../../../base/common/network.js';
-import { isUndefinedOrNull, isString } from '../../../../base/common/types.js';
-import { isCodeEditor, isDiffEditor } from '../../../../editor/browser/editorBrowser.js';
-import { localizeWithPath } from '../../../../nls.js';
-import { EditorResourceAccessor, SideBySideEditor } from '../../../common/editor.js';
-import { AbstractVariableResolverService } from '../common/variableResolver.js';
-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,27 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { ICommandService } from '../../../../platform/commands/common/commands.js';
-import { IConfigurationService } from '../../../../platform/configuration/common/configuration.js';
-import { ILabelService } from '../../../../platform/label/common/label.js';
-import { IQuickInputService } from '../../../../platform/quickinput/common/quickInput.js';
-import { IWorkspaceContextService } from '../../../../platform/workspace/common/workspace.js';
-import { BaseConfigurationResolverService } from './baseConfigurationResolverService.js';
-import '../common/configurationResolver.js';
-import { IEditorService } from '../../editor/common/editorService.js';
-import { IExtensionService } from '../../extensions/common/extensions.js';
-import { IPathService } from '../../path/common/pathService.js';
-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 };