@codingame/monaco-vscode-configuration-service-override 3.2.3 → 4.1.0

package/vscode/src/vs/workbench/api/common/configurationExtensionPoint.js

@@ -1,595 +0,0 @@
-import { localizeWithPath } from 'vscode/vscode/vs/nls';
-import { deepClone } from 'vscode/vscode/vs/base/common/objects';
-import { Registry } from 'vscode/vscode/vs/platform/registry/common/platform';
-import { ExtensionsRegistry } from 'vscode/vscode/vs/workbench/services/extensions/common/extensionsRegistry';
-import { Extensions as Extensions$1, configurationDefaultsSchemaId, OVERRIDE_PROPERTY_REGEX, validateProperty, getDefaultValue } from 'vscode/vscode/vs/platform/configuration/common/configurationRegistry';
-import { Extensions } from 'vscode/vscode/vs/platform/jsonschemas/common/jsonContributionRegistry';
-import { workspaceSettingsSchemaId, launchSchemaId, tasksSchemaId } from 'vscode/vscode/vs/workbench/services/configuration/common/configuration';
-import { isObject, isUndefined } from 'vscode/vscode/vs/base/common/types';
-import { ExtensionIdentifierMap } from 'vscode/vscode/vs/platform/extensions/common/extensions';
-import { Extensions as Extensions$2 } from 'vscode/vscode/vs/workbench/services/extensionManagement/common/extensionFeatures';
-import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
-import { SyncDescriptor } from 'vscode/vscode/vs/platform/instantiation/common/descriptors';
-import { MarkdownString } from 'vscode/vscode/vs/base/common/htmlContent';
-
-const jsonRegistry = ( Registry.as(Extensions.JSONContribution));
-const configurationRegistry = ( Registry.as(Extensions$1.Configuration));
-const configurationEntrySchema = {
-    type: 'object',
-    defaultSnippets: [{ body: { title: '', properties: {} } }],
-    properties: {
-        title: {
-            description: ( localizeWithPath(
-                'vs/workbench/api/common/configurationExtensionPoint',
-                'vscode.extension.contributes.configuration.title',
-                'A title for the current category of settings. This label will be rendered in the Settings editor as a subheading. If the title is the same as the extension display name, then the category will be grouped under the main extension heading.'
-            )),
-            type: 'string'
-        },
-        order: {
-            description: ( localizeWithPath(
-                'vs/workbench/api/common/configurationExtensionPoint',
-                'vscode.extension.contributes.configuration.order',
-                'When specified, gives the order of this category of settings relative to other categories.'
-            )),
-            type: 'integer'
-        },
-        properties: {
-            description: ( localizeWithPath(
-                'vs/workbench/api/common/configurationExtensionPoint',
-                'vscode.extension.contributes.configuration.properties',
-                'Description of the configuration properties.'
-            )),
-            type: 'object',
-            propertyNames: {
-                pattern: '\\S+',
-                patternErrorMessage: ( localizeWithPath(
-                    'vs/workbench/api/common/configurationExtensionPoint',
-                    'vscode.extension.contributes.configuration.property.empty',
-                    'Property should not be empty.'
-                )),
-            },
-            additionalProperties: {
-                anyOf: [
-                    {
-                        title: ( localizeWithPath(
-                            'vs/workbench/api/common/configurationExtensionPoint',
-                            'vscode.extension.contributes.configuration.properties.schema',
-                            'Schema of the configuration property.'
-                        )),
-                        $ref: 'http://json-schema.org/draft-07/schema#'
-                    },
-                    {
-                        type: 'object',
-                        properties: {
-                            scope: {
-                                type: 'string',
-                                enum: ['application', 'machine', 'window', 'resource', 'language-overridable', 'machine-overridable'],
-                                default: 'window',
-                                enumDescriptions: [
-                                    ( localizeWithPath(
-                                        'vs/workbench/api/common/configurationExtensionPoint',
-                                        'scope.application.description',
-                                        "Configuration that can be configured only in the user settings."
-                                    )),
-                                    ( localizeWithPath(
-                                        'vs/workbench/api/common/configurationExtensionPoint',
-                                        'scope.machine.description',
-                                        "Configuration that can be configured only in the user settings or only in the remote settings."
-                                    )),
-                                    ( localizeWithPath(
-                                        'vs/workbench/api/common/configurationExtensionPoint',
-                                        'scope.window.description',
-                                        "Configuration that can be configured in the user, remote or workspace settings."
-                                    )),
-                                    ( localizeWithPath(
-                                        'vs/workbench/api/common/configurationExtensionPoint',
-                                        'scope.resource.description',
-                                        "Configuration that can be configured in the user, remote, workspace or folder settings."
-                                    )),
-                                    ( localizeWithPath(
-                                        'vs/workbench/api/common/configurationExtensionPoint',
-                                        'scope.language-overridable.description',
-                                        "Resource configuration that can be configured in language specific settings."
-                                    )),
-                                    ( localizeWithPath(
-                                        'vs/workbench/api/common/configurationExtensionPoint',
-                                        'scope.machine-overridable.description',
-                                        "Machine configuration that can be configured also in workspace or folder settings."
-                                    ))
-                                ],
-                                markdownDescription: ( localizeWithPath(
-                                    'vs/workbench/api/common/configurationExtensionPoint',
-                                    'scope.description',
-                                    "Scope in which the configuration is applicable. Available scopes are `application`, `machine`, `window`, `resource`, and `machine-overridable`."
-                                ))
-                            },
-                            enumDescriptions: {
-                                type: 'array',
-                                items: {
-                                    type: 'string',
-                                },
-                                description: ( localizeWithPath(
-                                    'vs/workbench/api/common/configurationExtensionPoint',
-                                    'scope.enumDescriptions',
-                                    'Descriptions for enum values'
-                                ))
-                            },
-                            markdownEnumDescriptions: {
-                                type: 'array',
-                                items: {
-                                    type: 'string',
-                                },
-                                description: ( localizeWithPath(
-                                    'vs/workbench/api/common/configurationExtensionPoint',
-                                    'scope.markdownEnumDescriptions',
-                                    'Descriptions for enum values in the markdown format.'
-                                ))
-                            },
-                            enumItemLabels: {
-                                type: 'array',
-                                items: {
-                                    type: 'string'
-                                },
-                                markdownDescription: ( localizeWithPath(
-                                    'vs/workbench/api/common/configurationExtensionPoint',
-                                    'scope.enumItemLabels',
-                                    'Labels for enum values to be displayed in the Settings editor. When specified, the {0} values still show after the labels, but less prominently.',
-                                    '`enum`'
-                                ))
-                            },
-                            markdownDescription: {
-                                type: 'string',
-                                description: ( localizeWithPath(
-                                    'vs/workbench/api/common/configurationExtensionPoint',
-                                    'scope.markdownDescription',
-                                    'The description in the markdown format.'
-                                ))
-                            },
-                            deprecationMessage: {
-                                type: 'string',
-                                description: ( localizeWithPath(
-                                    'vs/workbench/api/common/configurationExtensionPoint',
-                                    'scope.deprecationMessage',
-                                    'If set, the property is marked as deprecated and the given message is shown as an explanation.'
-                                ))
-                            },
-                            markdownDeprecationMessage: {
-                                type: 'string',
-                                description: ( localizeWithPath(
-                                    'vs/workbench/api/common/configurationExtensionPoint',
-                                    'scope.markdownDeprecationMessage',
-                                    'If set, the property is marked as deprecated and the given message is shown as an explanation in the markdown format.'
-                                ))
-                            },
-                            editPresentation: {
-                                type: 'string',
-                                enum: ['singlelineText', 'multilineText'],
-                                enumDescriptions: [
-                                    ( localizeWithPath(
-                                        'vs/workbench/api/common/configurationExtensionPoint',
-                                        'scope.singlelineText.description',
-                                        'The value will be shown in an inputbox.'
-                                    )),
-                                    ( localizeWithPath(
-                                        'vs/workbench/api/common/configurationExtensionPoint',
-                                        'scope.multilineText.description',
-                                        'The value will be shown in a textarea.'
-                                    ))
-                                ],
-                                default: 'singlelineText',
-                                description: ( localizeWithPath(
-                                    'vs/workbench/api/common/configurationExtensionPoint',
-                                    'scope.editPresentation',
-                                    'When specified, controls the presentation format of the string setting.'
-                                ))
-                            },
-                            order: {
-                                type: 'integer',
-                                description: ( localizeWithPath(
-                                    'vs/workbench/api/common/configurationExtensionPoint',
-                                    'scope.order',
-                                    'When specified, gives the order of this setting relative to other settings within the same category. Settings with an order property will be placed before settings without this property set.'
-                                ))
-                            },
-                            ignoreSync: {
-                                type: 'boolean',
-                                description: ( localizeWithPath(
-                                    'vs/workbench/api/common/configurationExtensionPoint',
-                                    'scope.ignoreSync',
-                                    'When enabled, Settings Sync will not sync the user value of this configuration by default.'
-                                ))
-                            },
-                        }
-                    }
-                ]
-            }
-        }
-    }
-};
-let _configDelta;
-const defaultConfigurationExtPoint = ExtensionsRegistry.registerExtensionPoint({
-    extensionPoint: 'configurationDefaults',
-    jsonSchema: {
-        $ref: configurationDefaultsSchemaId,
-    }
-});
-defaultConfigurationExtPoint.setHandler((extensions, { added, removed }) => {
-    if (_configDelta) {
-        configurationRegistry.deltaConfiguration(_configDelta);
-    }
-    const configNow = _configDelta = {};
-    queueMicrotask(() => {
-        if (_configDelta === configNow) {
-            configurationRegistry.deltaConfiguration(_configDelta);
-            _configDelta = undefined;
-        }
-    });
-    if (removed.length) {
-        const removedDefaultConfigurations = ( removed.map(
-            extension => ({ overrides: deepClone(extension.value), source: { id: extension.description.identifier.value, displayName: extension.description.displayName } })
-        ));
-        _configDelta.removedDefaults = removedDefaultConfigurations;
-    }
-    if (added.length) {
-        const registeredProperties = configurationRegistry.getConfigurationProperties();
-        const allowedScopes = [6 , 3 , 4 , 5 ];
-        const addedDefaultConfigurations = ( added.map(extension => {
-            const overrides = deepClone(extension.value);
-            for (const key of ( Object.keys(overrides))) {
-                if (!OVERRIDE_PROPERTY_REGEX.test(key)) {
-                    const registeredPropertyScheme = registeredProperties[key];
-                    if (registeredPropertyScheme?.scope && !allowedScopes.includes(registeredPropertyScheme.scope)) {
-                        extension.collector.warn(( localizeWithPath(
-                            'vs/workbench/api/common/configurationExtensionPoint',
-                            'config.property.defaultConfiguration.warning',
-                            "Cannot register configuration defaults for '{0}'. Only defaults for machine-overridable, window, resource and language overridable scoped settings are supported.",
-                            key
-                        )));
-                        delete overrides[key];
-                    }
-                }
-            }
-            return { overrides, source: { id: extension.description.identifier.value, displayName: extension.description.displayName } };
-        }));
-        _configDelta.addedDefaults = addedDefaultConfigurations;
-    }
-});
-const configurationExtPoint = ExtensionsRegistry.registerExtensionPoint({
-    extensionPoint: 'configuration',
-    deps: [defaultConfigurationExtPoint],
-    jsonSchema: {
-        description: ( localizeWithPath(
-            'vs/workbench/api/common/configurationExtensionPoint',
-            'vscode.extension.contributes.configuration',
-            'Contributes configuration settings.'
-        )),
-        oneOf: [
-            configurationEntrySchema,
-            {
-                type: 'array',
-                items: configurationEntrySchema
-            }
-        ]
-    }
-});
-const extensionConfigurations = ( new ExtensionIdentifierMap());
-configurationExtPoint.setHandler((extensions, { added, removed }) => {
-    _configDelta ??= {};
-    if (removed.length) {
-        const removedConfigurations = [];
-        for (const extension of removed) {
-            removedConfigurations.push(...(extensionConfigurations.get(extension.description.identifier) || []));
-            extensionConfigurations.delete(extension.description.identifier);
-        }
-        _configDelta.removedConfigurations = removedConfigurations;
-    }
-    const seenProperties = ( new Set());
-    function handleConfiguration(node, extension) {
-        const configurations = [];
-        const configuration = deepClone(node);
-        if (configuration.title && (typeof configuration.title !== 'string')) {
-            extension.collector.error(( localizeWithPath(
-                'vs/workbench/api/common/configurationExtensionPoint',
-                'invalid.title',
-                "'configuration.title' must be a string"
-            )));
-        }
-        validateProperties(configuration, extension);
-        configuration.id = node.id || extension.description.identifier.value;
-        configuration.extensionInfo = { id: extension.description.identifier.value, displayName: extension.description.displayName };
-        configuration.restrictedProperties = extension.description.capabilities?.untrustedWorkspaces?.supported === 'limited' ? extension.description.capabilities?.untrustedWorkspaces.restrictedConfigurations : undefined;
-        configuration.title = configuration.title || extension.description.displayName || extension.description.identifier.value;
-        configurations.push(configuration);
-        return configurations;
-    }
-    function validateProperties(configuration, extension) {
-        const properties = configuration.properties;
-        if (properties) {
-            if (typeof properties !== 'object') {
-                extension.collector.error(( localizeWithPath(
-                    'vs/workbench/api/common/configurationExtensionPoint',
-                    'invalid.properties',
-                    "'configuration.properties' must be an object"
-                )));
-                configuration.properties = {};
-            }
-            for (const key in properties) {
-                const propertyConfiguration = properties[key];
-                const message = validateProperty(key, propertyConfiguration);
-                if (message) {
-                    delete properties[key];
-                    extension.collector.warn(message);
-                    continue;
-                }
-                if (( seenProperties.has(key))) {
-                    delete properties[key];
-                    extension.collector.warn(( localizeWithPath(
-                        'vs/workbench/api/common/configurationExtensionPoint',
-                        'config.property.duplicate',
-                        "Cannot register '{0}'. This property is already registered.",
-                        key
-                    )));
-                    continue;
-                }
-                if (!isObject(propertyConfiguration)) {
-                    delete properties[key];
-                    extension.collector.error(( localizeWithPath(
-                        'vs/workbench/api/common/configurationExtensionPoint',
-                        'invalid.property',
-                        "configuration.properties property '{0}' must be an object",
-                        key
-                    )));
-                    continue;
-                }
-                seenProperties.add(key);
-                if (propertyConfiguration.scope) {
-                    if (( propertyConfiguration.scope.toString()) === 'application') {
-                        propertyConfiguration.scope = 1 ;
-                    }
-                    else if (( propertyConfiguration.scope.toString()) === 'machine') {
-                        propertyConfiguration.scope = 2 ;
-                    }
-                    else if (( propertyConfiguration.scope.toString()) === 'resource') {
-                        propertyConfiguration.scope = 4 ;
-                    }
-                    else if (( propertyConfiguration.scope.toString()) === 'machine-overridable') {
-                        propertyConfiguration.scope = 6 ;
-                    }
-                    else if (( propertyConfiguration.scope.toString()) === 'language-overridable') {
-                        propertyConfiguration.scope = 5 ;
-                    }
-                    else {
-                        propertyConfiguration.scope = 3 ;
-                    }
-                }
-                else {
-                    propertyConfiguration.scope = 3 ;
-                }
-            }
-        }
-        const subNodes = configuration.allOf;
-        if (subNodes) {
-            extension.collector.error(( localizeWithPath(
-                'vs/workbench/api/common/configurationExtensionPoint',
-                'invalid.allOf',
-                "'configuration.allOf' is deprecated and should no longer be used. Instead, pass multiple configuration sections as an array to the 'configuration' contribution point."
-            )));
-            for (const node of subNodes) {
-                validateProperties(node, extension);
-            }
-        }
-    }
-    if (added.length) {
-        const addedConfigurations = [];
-        for (const extension of added) {
-            const configurations = [];
-            const value = extension.value;
-            if (Array.isArray(value)) {
-                value.forEach(v => configurations.push(...handleConfiguration(v, extension)));
-            }
-            else {
-                configurations.push(...handleConfiguration(value, extension));
-            }
-            extensionConfigurations.set(extension.description.identifier, configurations);
-            addedConfigurations.push(...configurations);
-        }
-        _configDelta.addedConfigurations = addedConfigurations;
-    }
-    configurationRegistry.deltaConfiguration(_configDelta);
-    _configDelta = undefined;
-});
-jsonRegistry.registerSchema('vscode://schemas/workspaceConfig', {
-    allowComments: true,
-    allowTrailingCommas: true,
-    default: {
-        folders: [
-            {
-                path: ''
-            }
-        ],
-        settings: {}
-    },
-    required: ['folders'],
-    properties: {
-        'folders': {
-            minItems: 0,
-            uniqueItems: true,
-            description: ( localizeWithPath(
-                'vs/workbench/api/common/configurationExtensionPoint',
-                'workspaceConfig.folders.description',
-                "List of folders to be loaded in the workspace."
-            )),
-            items: {
-                type: 'object',
-                defaultSnippets: [{ body: { path: '$1' } }],
-                oneOf: [{
-                        properties: {
-                            path: {
-                                type: 'string',
-                                description: ( localizeWithPath(
-                                    'vs/workbench/api/common/configurationExtensionPoint',
-                                    'workspaceConfig.path.description',
-                                    "A file path. e.g. `/root/folderA` or `./folderA` for a relative path that will be resolved against the location of the workspace file."
-                                ))
-                            },
-                            name: {
-                                type: 'string',
-                                description: ( localizeWithPath(
-                                    'vs/workbench/api/common/configurationExtensionPoint',
-                                    'workspaceConfig.name.description',
-                                    "An optional name for the folder. "
-                                ))
-                            }
-                        },
-                        required: ['path']
-                    }, {
-                        properties: {
-                            uri: {
-                                type: 'string',
-                                description: ( localizeWithPath(
-                                    'vs/workbench/api/common/configurationExtensionPoint',
-                                    'workspaceConfig.uri.description',
-                                    "URI of the folder"
-                                ))
-                            },
-                            name: {
-                                type: 'string',
-                                description: ( localizeWithPath(
-                                    'vs/workbench/api/common/configurationExtensionPoint',
-                                    'workspaceConfig.name.description',
-                                    "An optional name for the folder. "
-                                ))
-                            }
-                        },
-                        required: ['uri']
-                    }]
-            }
-        },
-        'settings': {
-            type: 'object',
-            default: {},
-            description: ( localizeWithPath(
-                'vs/workbench/api/common/configurationExtensionPoint',
-                'workspaceConfig.settings.description',
-                "Workspace settings"
-            )),
-            $ref: workspaceSettingsSchemaId
-        },
-        'launch': {
-            type: 'object',
-            default: { configurations: [], compounds: [] },
-            description: ( localizeWithPath(
-                'vs/workbench/api/common/configurationExtensionPoint',
-                'workspaceConfig.launch.description',
-                "Workspace launch configurations"
-            )),
-            $ref: launchSchemaId
-        },
-        'tasks': {
-            type: 'object',
-            default: { version: '2.0.0', tasks: [] },
-            description: ( localizeWithPath(
-                'vs/workbench/api/common/configurationExtensionPoint',
-                'workspaceConfig.tasks.description',
-                "Workspace task configurations"
-            )),
-            $ref: tasksSchemaId
-        },
-        'extensions': {
-            type: 'object',
-            default: {},
-            description: ( localizeWithPath(
-                'vs/workbench/api/common/configurationExtensionPoint',
-                'workspaceConfig.extensions.description',
-                "Workspace extensions"
-            )),
-            $ref: 'vscode://schemas/extensions'
-        },
-        'remoteAuthority': {
-            type: 'string',
-            doNotSuggest: true,
-            description: ( localizeWithPath(
-                'vs/workbench/api/common/configurationExtensionPoint',
-                'workspaceConfig.remoteAuthority',
-                "The remote server where the workspace is located."
-            )),
-        },
-        'transient': {
-            type: 'boolean',
-            doNotSuggest: true,
-            description: ( localizeWithPath(
-                'vs/workbench/api/common/configurationExtensionPoint',
-                'workspaceConfig.transient',
-                "A transient workspace will disappear when restarting or reloading."
-            )),
-        }
-    },
-    errorMessage: ( localizeWithPath(
-        'vs/workbench/api/common/configurationExtensionPoint',
-        'unknownWorkspaceProperty',
-        "Unknown workspace configuration property"
-    ))
-});
-class SettingsTableRenderer extends Disposable {
-    constructor() {
-        super(...arguments);
-        this.type = 'table';
-    }
-    shouldRender(manifest) {
-        return !!manifest.contributes?.configuration;
-    }
-    render(manifest) {
-        const configuration = manifest.contributes?.configuration;
-        let properties = {};
-        if (Array.isArray(configuration)) {
-            configuration.forEach(config => {
-                properties = { ...properties, ...config.properties };
-            });
-        }
-        else if (configuration) {
-            properties = configuration.properties;
-        }
-        const contrib = properties ? ( Object.keys(properties)) : [];
-        const headers = [( localizeWithPath(
-            'vs/workbench/api/common/configurationExtensionPoint',
-            'setting name',
-            "ID"
-        )), ( localizeWithPath(
-            'vs/workbench/api/common/configurationExtensionPoint',
-            'description',
-            "Description"
-        )), ( localizeWithPath(
-            'vs/workbench/api/common/configurationExtensionPoint',
-            'default',
-            "Default"
-        ))];
-        const rows = ( contrib.sort((a, b) => a.localeCompare(b))
-            .map(key => {
-            return [
-                ( new MarkdownString()).appendMarkdown(`\`${key}\``),
-                properties[key].markdownDescription ? ( new MarkdownString(properties[key].markdownDescription, false)) : properties[key].description ?? '',
-                ( new MarkdownString()).appendCodeblock('json', JSON.stringify(isUndefined(properties[key].default) ? getDefaultValue(properties[key].type) : properties[key].default, null, 2)),
-            ];
-        }));
-        return {
-            data: {
-                headers,
-                rows
-            },
-            dispose: () => { }
-        };
-    }
-}
-( Registry.as(Extensions$2.ExtensionFeaturesRegistry)).registerExtensionFeature({
-    id: 'configuration',
-    label: ( localizeWithPath(
-        'vs/workbench/api/common/configurationExtensionPoint',
-        'settings',
-        "Settings"
-    )),
-    access: {
-        canToggle: false
-    },
-    renderer: ( new SyncDescriptor(SettingsTableRenderer)),
-});