@codingame/monaco-vscode-api 1.76.9 → 1.78.0-next.1

package/dist/configurationRegistry.js

@@ -1,441 +0,0 @@
-import { E as Emitter } from './services2.js';
-import { localize } from 'monaco-editor/esm/vs/nls.js';
-import { getLanguageTagSettingPlainKey } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
-import { isString, isUndefinedOrNull, isUndefined } from 'monaco-editor/esm/vs/base/common/types.js';
-import { distinct } from 'monaco-editor/esm/vs/base/common/arrays.js';
-import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
-import { Extensions } from 'monaco-editor/esm/vs/platform/jsonschemas/common/jsonContributionRegistry.js';
-var ConfigurationScope;
-( (function(ConfigurationScope) {
-    ConfigurationScope[ConfigurationScope["APPLICATION"] = 1] = "APPLICATION";
-    ConfigurationScope[ConfigurationScope["MACHINE"] = 2] = "MACHINE";
-    ConfigurationScope[ConfigurationScope["WINDOW"] = 3] = "WINDOW";
-    ConfigurationScope[ConfigurationScope["RESOURCE"] = 4] = "RESOURCE";
-    ConfigurationScope[ConfigurationScope["LANGUAGE_OVERRIDABLE"] = 5] = "LANGUAGE_OVERRIDABLE";
-    ConfigurationScope[ConfigurationScope["MACHINE_OVERRIDABLE"] = 6] = "MACHINE_OVERRIDABLE";
-})(ConfigurationScope || (ConfigurationScope = {})));
-const resourceLanguageSettingsSchemaId = 'vscode://schemas/settings/resourceLanguage';
-const configurationDefaultsSchemaId = 'vscode://schemas/settings/configurationDefaults';
-const contributionRegistry = ( Registry.as(Extensions.JSONContribution));
-class ConfigurationRegistry {
-    constructor() {
-        this.overrideIdentifiers = ( new Set());
-        this._onDidSchemaChange = ( new Emitter());
-        this.onDidSchemaChange = this._onDidSchemaChange.event;
-        this._onDidUpdateConfiguration = ( new Emitter());
-        this.onDidUpdateConfiguration = this._onDidUpdateConfiguration.event;
-        this.configurationDefaultsOverrides = ( new Map());
-        this.defaultLanguageConfigurationOverridesNode = {
-            id: 'defaultOverrides',
-            title: ( localize(
-                'defaultLanguageConfigurationOverrides.title',
-                "Default Language Configuration Overrides"
-            )),
-            properties: {}
-        };
-        this.configurationContributors = [this.defaultLanguageConfigurationOverridesNode];
-        this.resourceLanguageSettingsSchema = {
-            properties: {},
-            patternProperties: {},
-            additionalProperties: true,
-            allowTrailingCommas: true,
-            allowComments: true
-        };
-        this.configurationProperties = {};
-        this.policyConfigurations = ( new Map());
-        this.excludedConfigurationProperties = {};
-        contributionRegistry.registerSchema(resourceLanguageSettingsSchemaId, this.resourceLanguageSettingsSchema);
-        this.registerOverridePropertyPatternKey();
-    }
-    registerConfiguration(configuration, validate = true) {
-        this.registerConfigurations([configuration], validate);
-    }
-    registerConfigurations(configurations, validate = true) {
-        const properties = ( new Set());
-        this.doRegisterConfigurations(configurations, validate, properties);
-        contributionRegistry.registerSchema(resourceLanguageSettingsSchemaId, this.resourceLanguageSettingsSchema);
-        this._onDidSchemaChange.fire();
-        this._onDidUpdateConfiguration.fire({ properties });
-    }
-    deregisterConfigurations(configurations) {
-        const properties = ( new Set());
-        this.doDeregisterConfigurations(configurations, properties);
-        contributionRegistry.registerSchema(resourceLanguageSettingsSchemaId, this.resourceLanguageSettingsSchema);
-        this._onDidSchemaChange.fire();
-        this._onDidUpdateConfiguration.fire({ properties });
-    }
-    updateConfigurations({ add, remove }) {
-        const properties = ( new Set());
-        this.doDeregisterConfigurations(remove, properties);
-        this.doRegisterConfigurations(add, false, properties);
-        contributionRegistry.registerSchema(resourceLanguageSettingsSchemaId, this.resourceLanguageSettingsSchema);
-        this._onDidSchemaChange.fire();
-        this._onDidUpdateConfiguration.fire({ properties });
-    }
-    registerDefaultConfigurations(configurationDefaults) {
-        const properties = ( new Set());
-        this.doRegisterDefaultConfigurations(configurationDefaults, properties);
-        this._onDidSchemaChange.fire();
-        this._onDidUpdateConfiguration.fire({ properties, defaultsOverrides: true });
-    }
-    doRegisterDefaultConfigurations(configurationDefaults, bucket) {
-        const overrideIdentifiers = [];
-        for (const { overrides, source } of configurationDefaults) {
-            for (const key in overrides) {
-                bucket.add(key);
-                if (OVERRIDE_PROPERTY_REGEX.test(key)) {
-                    const configurationDefaultOverride = this.configurationDefaultsOverrides.get(key);
-                    const valuesSources = configurationDefaultOverride?.valuesSources ?? ( new Map());
-                    if (source) {
-                        for (const configuration of ( Object.keys(overrides[key]))) {
-                            valuesSources.set(configuration, source);
-                        }
-                    }
-                    const defaultValue = { ...(configurationDefaultOverride?.value || {}), ...overrides[key] };
-                    this.configurationDefaultsOverrides.set(key, { source, value: defaultValue, valuesSources });
-                    const plainKey = getLanguageTagSettingPlainKey(key);
-                    const property = {
-                        type: 'object',
-                        default: defaultValue,
-                        description: ( localize(
-                            'defaultLanguageConfiguration.description',
-                            "Configure settings to be overridden for the {0} language.",
-                            plainKey
-                        )),
-                        $ref: resourceLanguageSettingsSchemaId,
-                        defaultDefaultValue: defaultValue,
-                        source: isString(source) ? undefined : source,
-                        defaultValueSource: source
-                    };
-                    overrideIdentifiers.push(...overrideIdentifiersFromKey(key));
-                    this.configurationProperties[key] = property;
-                    this.defaultLanguageConfigurationOverridesNode.properties[key] = property;
-                }
-                else {
-                    this.configurationDefaultsOverrides.set(key, { value: overrides[key], source });
-                    const property = this.configurationProperties[key];
-                    if (property) {
-                        this.updatePropertyDefaultValue(key, property);
-                        this.updateSchema(key, property);
-                    }
-                }
-            }
-        }
-        this.doRegisterOverrideIdentifiers(overrideIdentifiers);
-    }
-    deregisterDefaultConfigurations(defaultConfigurations) {
-        const properties = ( new Set());
-        this.doDeregisterDefaultConfigurations(defaultConfigurations, properties);
-        this._onDidSchemaChange.fire();
-        this._onDidUpdateConfiguration.fire({ properties, defaultsOverrides: true });
-    }
-    doDeregisterDefaultConfigurations(defaultConfigurations, bucket) {
-        for (const { overrides, source } of defaultConfigurations) {
-            for (const key in overrides) {
-                const configurationDefaultsOverride = this.configurationDefaultsOverrides.get(key);
-                const id = isString(source) ? source : source?.id;
-                const configurationDefaultsOverrideSourceId = isString(configurationDefaultsOverride?.source) ? configurationDefaultsOverride?.source : configurationDefaultsOverride?.source?.id;
-                if (id !== configurationDefaultsOverrideSourceId) {
-                    continue;
-                }
-                bucket.add(key);
-                this.configurationDefaultsOverrides.delete(key);
-                if (OVERRIDE_PROPERTY_REGEX.test(key)) {
-                    delete this.configurationProperties[key];
-                    delete this.defaultLanguageConfigurationOverridesNode.properties[key];
-                }
-                else {
-                    const property = this.configurationProperties[key];
-                    if (property) {
-                        this.updatePropertyDefaultValue(key, property);
-                        this.updateSchema(key, property);
-                    }
-                }
-            }
-        }
-        this.updateOverridePropertyPatternKey();
-    }
-    deltaConfiguration(delta) {
-        let defaultsOverrides = false;
-        const properties = ( new Set());
-        if (delta.removedDefaults) {
-            this.doDeregisterDefaultConfigurations(delta.removedDefaults, properties);
-            defaultsOverrides = true;
-        }
-        if (delta.addedDefaults) {
-            this.doRegisterDefaultConfigurations(delta.addedDefaults, properties);
-            defaultsOverrides = true;
-        }
-        if (delta.removedConfigurations) {
-            this.doDeregisterConfigurations(delta.removedConfigurations, properties);
-        }
-        if (delta.addedConfigurations) {
-            this.doRegisterConfigurations(delta.addedConfigurations, false, properties);
-        }
-        this._onDidSchemaChange.fire();
-        this._onDidUpdateConfiguration.fire({ properties, defaultsOverrides });
-    }
-    notifyConfigurationSchemaUpdated(...configurations) {
-        this._onDidSchemaChange.fire();
-    }
-    registerOverrideIdentifiers(overrideIdentifiers) {
-        this.doRegisterOverrideIdentifiers(overrideIdentifiers);
-        this._onDidSchemaChange.fire();
-    }
-    doRegisterOverrideIdentifiers(overrideIdentifiers) {
-        for (const overrideIdentifier of overrideIdentifiers) {
-            this.overrideIdentifiers.add(overrideIdentifier);
-        }
-        this.updateOverridePropertyPatternKey();
-    }
-    doRegisterConfigurations(configurations, validate, bucket) {
-        configurations.forEach(configuration => {
-            this.validateAndRegisterProperties(configuration, validate, configuration.extensionInfo, configuration.restrictedProperties, undefined, bucket);
-            this.configurationContributors.push(configuration);
-            this.registerJSONConfiguration(configuration);
-        });
-    }
-    doDeregisterConfigurations(configurations, bucket) {
-        const deregisterConfiguration = (configuration) => {
-            if (configuration.properties) {
-                for (const key in configuration.properties) {
-                    bucket.add(key);
-                    const property = this.configurationProperties[key];
-                    if (property?.policy?.name) {
-                        this.policyConfigurations.delete(property.policy.name);
-                    }
-                    delete this.configurationProperties[key];
-                    this.removeFromSchema(key, configuration.properties[key]);
-                }
-            }
-            configuration.allOf?.forEach(node => deregisterConfiguration(node));
-        };
-        for (const configuration of configurations) {
-            deregisterConfiguration(configuration);
-            const index = this.configurationContributors.indexOf(configuration);
-            if (index !== -1) {
-                this.configurationContributors.splice(index, 1);
-            }
-        }
-    }
-    validateAndRegisterProperties(configuration, validate = true, extensionInfo, restrictedProperties, scope = 3 , bucket) {
-        scope = isUndefinedOrNull(configuration.scope) ? scope : configuration.scope;
-        const properties = configuration.properties;
-        if (properties) {
-            for (const key in properties) {
-                const property = properties[key];
-                if (validate && validateProperty(key, property)) {
-                    delete properties[key];
-                    continue;
-                }
-                property.source = extensionInfo;
-                property.defaultDefaultValue = properties[key].default;
-                this.updatePropertyDefaultValue(key, property);
-                if (OVERRIDE_PROPERTY_REGEX.test(key)) {
-                    property.scope = undefined;
-                }
-                else {
-                    property.scope = isUndefinedOrNull(property.scope) ? scope : property.scope;
-                    property.restricted = isUndefinedOrNull(property.restricted) ? !!restrictedProperties?.includes(key) : property.restricted;
-                }
-                if (properties[key].hasOwnProperty('included') && !properties[key].included) {
-                    this.excludedConfigurationProperties[key] = properties[key];
-                    delete properties[key];
-                    continue;
-                }
-                else {
-                    this.configurationProperties[key] = properties[key];
-                    if (properties[key].policy?.name) {
-                        this.policyConfigurations.set(properties[key].policy.name, key);
-                    }
-                }
-                if (!properties[key].deprecationMessage && properties[key].markdownDeprecationMessage) {
-                    properties[key].deprecationMessage = properties[key].markdownDeprecationMessage;
-                }
-                bucket.add(key);
-            }
-        }
-        const subNodes = configuration.allOf;
-        if (subNodes) {
-            for (const node of subNodes) {
-                this.validateAndRegisterProperties(node, validate, extensionInfo, restrictedProperties, scope, bucket);
-            }
-        }
-    }
-    getConfigurations() {
-        return this.configurationContributors;
-    }
-    getConfigurationProperties() {
-        return this.configurationProperties;
-    }
-    getPolicyConfigurations() {
-        return this.policyConfigurations;
-    }
-    getExcludedConfigurationProperties() {
-        return this.excludedConfigurationProperties;
-    }
-    getConfigurationDefaultsOverrides() {
-        return this.configurationDefaultsOverrides;
-    }
-    registerJSONConfiguration(configuration) {
-        const register = (configuration) => {
-            const properties = configuration.properties;
-            if (properties) {
-                for (const key in properties) {
-                    this.updateSchema(key, properties[key]);
-                }
-            }
-            const subNodes = configuration.allOf;
-            subNodes?.forEach(register);
-        };
-        register(configuration);
-    }
-    updateSchema(key, property) {
-        switch (property.scope) {
-            case 1 :
-                break;
-            case 2 :
-                break;
-            case 6 :
-                break;
-            case 3 :
-                break;
-            case 4 :
-                break;
-            case 5 :
-                this.resourceLanguageSettingsSchema.properties[key] = property;
-                break;
-        }
-    }
-    removeFromSchema(key, property) {
-        switch (property.scope) {
-            case 1 :
-                break;
-            case 2 :
-                break;
-            case 6 :
-                break;
-            case 3 :
-                break;
-            case 4 :
-            case 5 :
-                delete this.resourceLanguageSettingsSchema.properties[key];
-                break;
-        }
-    }
-    updateOverridePropertyPatternKey() {
-        for (const overrideIdentifier of ( this.overrideIdentifiers.values())) {
-            const overrideIdentifierProperty = `[${overrideIdentifier}]`;
-            const resourceLanguagePropertiesSchema = {
-                type: 'object',
-                description: ( localize(
-                    'overrideSettings.defaultDescription',
-                    "Configure editor settings to be overridden for a language."
-                )),
-                errorMessage: ( localize(
-                    'overrideSettings.errorMessage',
-                    "This setting does not support per-language configuration."
-                )),
-                $ref: resourceLanguageSettingsSchemaId,
-            };
-            this.updatePropertyDefaultValue(overrideIdentifierProperty, resourceLanguagePropertiesSchema);
-        }
-    }
-    registerOverridePropertyPatternKey() {
-        this._onDidSchemaChange.fire();
-    }
-    updatePropertyDefaultValue(key, property) {
-        const configurationdefaultOverride = this.configurationDefaultsOverrides.get(key);
-        let defaultValue = configurationdefaultOverride?.value;
-        let defaultSource = configurationdefaultOverride?.source;
-        if (isUndefined(defaultValue)) {
-            defaultValue = property.defaultDefaultValue;
-            defaultSource = undefined;
-        }
-        if (isUndefined(defaultValue)) {
-            defaultValue = getDefaultValue(property.type);
-        }
-        property.default = defaultValue;
-        property.defaultValueSource = defaultSource;
-    }
-}
-const OVERRIDE_IDENTIFIER_PATTERN = `\\[([^\\]]+)\\]`;
-const OVERRIDE_IDENTIFIER_REGEX = ( new RegExp(OVERRIDE_IDENTIFIER_PATTERN, 'g'));
-const OVERRIDE_PROPERTY_PATTERN = `^(${OVERRIDE_IDENTIFIER_PATTERN})+$`;
-const OVERRIDE_PROPERTY_REGEX = ( new RegExp(OVERRIDE_PROPERTY_PATTERN));
-function overrideIdentifiersFromKey(key) {
-    const identifiers = [];
-    if (OVERRIDE_PROPERTY_REGEX.test(key)) {
-        let matches = OVERRIDE_IDENTIFIER_REGEX.exec(key);
-        while (matches?.length) {
-            const identifier = matches[1].trim();
-            if (identifier) {
-                identifiers.push(identifier);
-            }
-            matches = OVERRIDE_IDENTIFIER_REGEX.exec(key);
-        }
-    }
-    return distinct(identifiers);
-}
-function keyFromOverrideIdentifiers(overrideIdentifiers) {
-    return overrideIdentifiers.reduce((result, overrideIdentifier) => `${result}[${overrideIdentifier}]`, '');
-}
-function getDefaultValue(type) {
-    const t = Array.isArray(type) ? type[0] : type;
-    switch (t) {
-        case 'boolean':
-            return false;
-        case 'integer':
-        case 'number':
-            return 0;
-        case 'string':
-            return '';
-        case 'array':
-            return [];
-        case 'object':
-            return {};
-        default:
-            return null;
-    }
-}
-const configurationRegistry = ( new ConfigurationRegistry());
-function validateProperty(property, schema) {
-    if (!property.trim()) {
-        return ( localize('config.property.empty', "Cannot register an empty property"));
-    }
-    if (OVERRIDE_PROPERTY_REGEX.test(property)) {
-        return ( localize(
-            'config.property.languageDefault',
-            "Cannot register '{0}'. This matches property pattern '\\\\[.*\\\\]$' for describing language specific editor settings. Use 'configurationDefaults' contribution.",
-            property
-        ));
-    }
-    if (configurationRegistry.getConfigurationProperties()[property] !== undefined) {
-        return ( localize(
-            'config.property.duplicate',
-            "Cannot register '{0}'. This property is already registered.",
-            property
-        ));
-    }
-    if (schema.policy?.name && configurationRegistry.getPolicyConfigurations().get(schema.policy?.name) !== undefined) {
-        return ( localize(
-            'config.policy.duplicate',
-            "Cannot register '{0}'. The associated policy {1} is already registered with {2}.",
-            property,
-            schema.policy?.name,
-            configurationRegistry.getPolicyConfigurations().get(schema.policy?.name)
-        ));
-    }
-    return null;
-}
-function getScopes() {
-    const scopes = [];
-    const configurationProperties = configurationRegistry.getConfigurationProperties();
-    for (const key of ( Object.keys(configurationProperties))) {
-        scopes.push([key, configurationProperties[key].scope]);
-    }
-    scopes.push(['launch', 4 ]);
-    scopes.push(['task', 4 ]);
-    return scopes;
-}
-export { ConfigurationScope as C, configurationDefaultsSchemaId as c, getScopes as g, keyFromOverrideIdentifiers as k };

package/dist/extensionResourceLoader.js

@@ -1,96 +0,0 @@
-import { generateUuid } from 'monaco-editor/esm/vs/base/common/uuid.js';
-import { VSBuffer } from 'monaco-editor/esm/vs/base/common/buffer.js';
-import { cq as getRemoteServerRootPath, h as format2, s as supportsTelemetry, cr as getTelemetryLevel } from './missing-services.js';
-import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
-import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
-import { RemoteAuthorities } from 'monaco-editor/esm/vs/base/common/network.js';
-import { isWeb } from 'monaco-editor/esm/vs/base/common/platform.js';
-const _UUIDPattern = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-function isUUID(value) {
-    return _UUIDPattern.test(value);
-}
-async function getServiceMachineId(environmentService, fileService, storageService) {
-    let uuid = storageService ? storageService.get('storage.serviceMachineId', -1 ) || null : null;
-    if (uuid) {
-        return uuid;
-    }
-    try {
-        const contents = await fileService.readFile(environmentService.serviceMachineIdResource);
-        const value = ( contents.value.toString());
-        uuid = isUUID(value) ? value : null;
-    }
-    catch (e) {
-        uuid = null;
-    }
-    if (!uuid) {
-        uuid = generateUuid();
-        try {
-            await fileService.writeFile(environmentService.serviceMachineIdResource, VSBuffer.fromString(uuid));
-        }
-        catch (error) {
-        }
-    }
-    storageService?.store('storage.serviceMachineId', uuid, -1 , 1 );
-    return uuid;
-}
-const WEB_EXTENSION_RESOURCE_END_POINT = 'web-extension-resource';
-const IExtensionResourceLoaderService = ( createDecorator('extensionResourceLoaderService'));
-class AbstractExtensionResourceLoaderService {
-    constructor(_fileService, _storageService, _productService, _environmentService, _configurationService) {
-        this._fileService = _fileService;
-        this._storageService = _storageService;
-        this._productService = _productService;
-        this._environmentService = _environmentService;
-        this._configurationService = _configurationService;
-        this._webExtensionResourceEndPoint = `${getRemoteServerRootPath(_productService)}/${WEB_EXTENSION_RESOURCE_END_POINT}/`;
-        if (_productService.extensionsGallery) {
-            this._extensionGalleryResourceUrlTemplate = _productService.extensionsGallery.resourceUrlTemplate;
-            this._extensionGalleryAuthority = this._extensionGalleryResourceUrlTemplate ? this._getExtensionGalleryAuthority(( URI.parse(this._extensionGalleryResourceUrlTemplate))) : undefined;
-        }
-    }
-    get supportsExtensionGalleryResources() {
-        return this._extensionGalleryResourceUrlTemplate !== undefined;
-    }
-    getExtensionGalleryResourceURL(galleryExtension, path) {
-        if (this._extensionGalleryResourceUrlTemplate) {
-            const uri = ( URI.parse(
-                format2(this._extensionGalleryResourceUrlTemplate, { publisher: galleryExtension.publisher, name: galleryExtension.name, version: galleryExtension.version, path: 'extension' })
-            ));
-            return this._isWebExtensionResourceEndPoint(uri) ? uri.with({ scheme: RemoteAuthorities.getPreferredWebSchema() }) : uri;
-        }
-        return undefined;
-    }
-    isExtensionGalleryResource(uri) {
-        return this._extensionGalleryAuthority && this._extensionGalleryAuthority === this._getExtensionGalleryAuthority(uri);
-    }
-    async getExtensionGalleryRequestHeaders() {
-        const headers = {
-            'X-Client-Name': `${this._productService.applicationName}${isWeb ? '-web' : ''}`,
-            'X-Client-Version': this._productService.version
-        };
-        if (supportsTelemetry(this._productService, this._environmentService) && getTelemetryLevel(this._configurationService) === 3 ) {
-            headers['X-Machine-Id'] = await this._getServiceMachineId();
-        }
-        if (this._productService.commit) {
-            headers['X-Client-Commit'] = this._productService.commit;
-        }
-        return headers;
-    }
-    _getServiceMachineId() {
-        if (!this._serviceMachineIdPromise) {
-            this._serviceMachineIdPromise = getServiceMachineId(this._environmentService, this._fileService, this._storageService);
-        }
-        return this._serviceMachineIdPromise;
-    }
-    _getExtensionGalleryAuthority(uri) {
-        if (this._isWebExtensionResourceEndPoint(uri)) {
-            return uri.authority;
-        }
-        const index = uri.authority.indexOf('.');
-        return index !== -1 ? uri.authority.substring(index + 1) : undefined;
-    }
-    _isWebExtensionResourceEndPoint(uri) {
-        return uri.path.startsWith(this._webExtensionResourceEndPoint);
-    }
-}
-export { AbstractExtensionResourceLoaderService as A, IExtensionResourceLoaderService as I };

package/dist/labels.js

@@ -1,14 +0,0 @@
-import { isMacintosh, isWindows } from 'monaco-editor/esm/vs/base/common/platform.js';
-function untildify(path, userHome) {
-    return path.replace(/^~($|\/|\\)/, `${userHome}$1`);
-}
-function mnemonicButtonLabel(label, forceDisableMnemonics) {
-    if (isMacintosh || forceDisableMnemonics) {
-        return label.replace(/\(&&\w\)|&&/g, '');
-    }
-    if (isWindows) {
-        return label.replace(/&&|&/g, m => m === '&' ? '&&' : '&');
-    }
-    return label.replace(/&&/g, '_');
-}
-export { mnemonicButtonLabel as m, untildify as u };