@difizen/libro-common 0.3.3 → 1.0.0

package/src/core/keybinding/vs/configuration/configurationRegistry.ts

@@ -0,0 +1,617 @@
+/* eslint-disable @typescript-eslint/no-use-before-define */
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import type { Event, IStringDictionary } from '../../../../common/index.js';
+import { Emitter, types } from '../../../../common/index.js';
+
+import * as nls from '../../../nls';
+import type { IJSONContributionRegistry } from '../jsonContributionRegistry';
+import { Extensions as JSONExtensions } from '../jsonContributionRegistry';
+import type { IJSONSchema } from '../jsonSchema';
+import { Registry } from '../platform';
+
+export const Extensions = {
+  Configuration: 'base.contributions.configuration',
+};
+
+export interface IConfigurationRegistry {
+  /**
+   * Register a configuration to the registry.
+   */
+  registerConfiguration: (configuration: IConfigurationNode) => void;
+
+  /**
+   * Register multiple configurations to the registry.
+   */
+  registerConfigurations: (
+    configurations: IConfigurationNode[],
+    validate?: boolean,
+  ) => void;
+
+  /**
+   * Deregister multiple configurations from the registry.
+   */
+  deregisterConfigurations: (configurations: IConfigurationNode[]) => void;
+
+  /**
+   * Register multiple default configurations to the registry.
+   */
+  registerDefaultConfigurations: (
+    defaultConfigurations: IStringDictionary<any>[],
+  ) => void;
+
+  /**
+   * Deregister multiple default configurations from the registry.
+   */
+  deregisterDefaultConfigurations: (
+    defaultConfigurations: IStringDictionary<any>[],
+  ) => void;
+
+  /**
+   * Signal that the schema of a configuration setting has changes. It is currently only supported to change enumeration values.
+   * Property or default value changes are not allowed.
+   */
+  notifyConfigurationSchemaUpdated: (...configurations: IConfigurationNode[]) => void;
+
+  /**
+   * Event that fires whenver a configuration has been
+   * registered.
+   */
+  onDidSchemaChange: Event<void>;
+
+  /**
+   * Event that fires whenver a configuration has been
+   * registered.
+   */
+  onDidUpdateConfiguration: Event<string[]>;
+
+  /**
+   * Returns all configuration nodes contributed to this registry.
+   */
+  getConfigurations: () => IConfigurationNode[];
+
+  /**
+   * Returns all configurations settings of all configuration nodes contributed to this registry.
+   */
+  getConfigurationProperties: () => Record<string, IConfigurationPropertySchema>;
+
+  /**
+   * Returns all excluded configurations settings of all configuration nodes contributed to this registry.
+   */
+  getExcludedConfigurationProperties: () => Record<
+    string,
+    IConfigurationPropertySchema
+  >;
+
+  /**
+   * Register the identifiers for editor configurations
+   */
+  registerOverrideIdentifiers: (identifiers: string[]) => void;
+}
+
+export enum ConfigurationScope {
+  /**
+   * Application specific configuration, which can be configured only in local user settings.
+   */
+  APPLICATION = 1,
+  /**
+   * Machine specific configuration, which can be configured only in local and remote user settings.
+   */
+  MACHINE,
+  /**
+   * Window specific configuration, which can be configured in the user or workspace settings.
+   */
+  WINDOW,
+  /**
+   * Resource specific configuration, which can be configured in the user, workspace or folder settings.
+   */
+  RESOURCE,
+  /**
+   * Resource specific configuration that can be configured in language specific settings
+   */
+  LANGUAGE_OVERRIDABLE,
+  /**
+   * Machine specific configuration that can also be configured in workspace or folder settings.
+   */
+  MACHINE_OVERRIDABLE,
+}
+
+export interface IConfigurationPropertySchema extends IJSONSchema {
+  scope?: ConfigurationScope | undefined;
+  included?: boolean;
+  tags?: string[];
+  /**
+   * When enabled this setting is ignored during sync and user can override this.
+   */
+  ignoreSync?: boolean;
+  /**
+   * When enabled this setting is ignored during sync and user cannot override this.
+   */
+  disallowSyncIgnore?: boolean;
+  enumItemLabels?: string[];
+}
+
+export interface IConfigurationExtensionInfo {
+  id: string;
+}
+
+export interface IConfigurationNode {
+  id?: string;
+  order?: number;
+  type?: string | string[];
+  title?: string;
+  description?: string;
+  properties?: Record<string, IConfigurationPropertySchema>;
+  allOf?: IConfigurationNode[];
+  scope?: ConfigurationScope;
+  extensionInfo?: IConfigurationExtensionInfo;
+}
+
+type SettingProperties = Record<string, any>;
+
+export const allSettings: {
+  properties: SettingProperties;
+  patternProperties: SettingProperties;
+} = { properties: {}, patternProperties: {} };
+export const applicationSettings: {
+  properties: SettingProperties;
+  patternProperties: SettingProperties;
+} = { properties: {}, patternProperties: {} };
+export const machineSettings: {
+  properties: SettingProperties;
+  patternProperties: SettingProperties;
+} = { properties: {}, patternProperties: {} };
+export const machineOverridableSettings: {
+  properties: SettingProperties;
+  patternProperties: SettingProperties;
+} = { properties: {}, patternProperties: {} };
+export const windowSettings: {
+  properties: SettingProperties;
+  patternProperties: SettingProperties;
+} = { properties: {}, patternProperties: {} };
+export const resourceSettings: {
+  properties: SettingProperties;
+  patternProperties: SettingProperties;
+} = { properties: {}, patternProperties: {} };
+
+export const resourceLanguageSettingsSchemaId =
+  'vscode://schemas/settings/resourceLanguage';
+
+const contributionRegistry = Registry.as<IJSONContributionRegistry>(
+  JSONExtensions.JSONContribution,
+);
+
+class ConfigurationRegistry implements IConfigurationRegistry {
+  private readonly defaultValues: IStringDictionary<any>;
+  private readonly defaultLanguageConfigurationOverridesNode: IConfigurationNode;
+  private readonly configurationContributors: IConfigurationNode[];
+  private readonly configurationProperties: Record<string, IJSONSchema>;
+  private readonly excludedConfigurationProperties: Record<string, IJSONSchema>;
+  private readonly resourceLanguageSettingsSchema: IJSONSchema;
+  private readonly overrideIdentifiers = new Set<string>();
+
+  private readonly _onDidSchemaChange = new Emitter<void>();
+  readonly onDidSchemaChange: Event<void> = this._onDidSchemaChange.event;
+
+  private readonly _onDidUpdateConfiguration: Emitter<string[]> = new Emitter<
+    string[]
+  >();
+  readonly onDidUpdateConfiguration: Event<string[]> =
+    this._onDidUpdateConfiguration.event;
+
+  constructor() {
+    this.defaultValues = {};
+    this.defaultLanguageConfigurationOverridesNode = {
+      id: 'defaultOverrides',
+      title: nls.localize(
+        'defaultLanguageConfigurationOverrides.title',
+        'Default Language Configuration Overrides',
+      ),
+      properties: {},
+    };
+    this.configurationContributors = [this.defaultLanguageConfigurationOverridesNode];
+    this.resourceLanguageSettingsSchema = {
+      properties: {},
+      patternProperties: {},
+      additionalProperties: false,
+      errorMessage: 'Unknown editor configuration setting',
+      allowTrailingCommas: true,
+      allowComments: true,
+    };
+    this.configurationProperties = {};
+    this.excludedConfigurationProperties = {};
+
+    contributionRegistry.registerSchema(
+      resourceLanguageSettingsSchemaId,
+      this.resourceLanguageSettingsSchema,
+    );
+  }
+
+  public registerConfiguration(
+    configuration: IConfigurationNode,
+    validate = true,
+  ): void {
+    this.registerConfigurations([configuration], validate);
+  }
+
+  public registerConfigurations(
+    configurations: IConfigurationNode[],
+    validate = true,
+  ): void {
+    const properties: string[] = [];
+    configurations.forEach((configuration) => {
+      properties.push(...this.validateAndRegisterProperties(configuration, validate)); // fills in defaults
+      this.configurationContributors.push(configuration);
+      this.registerJSONConfiguration(configuration);
+    });
+
+    contributionRegistry.registerSchema(
+      resourceLanguageSettingsSchemaId,
+      this.resourceLanguageSettingsSchema,
+    );
+    this._onDidSchemaChange.fire();
+    this._onDidUpdateConfiguration.fire(properties);
+  }
+
+  public deregisterConfigurations(configurations: IConfigurationNode[]): void {
+    const properties: string[] = [];
+    const deregisterConfiguration = (configuration: IConfigurationNode) => {
+      if (configuration.properties) {
+        for (const key in configuration.properties) {
+          properties.push(key);
+          delete this.configurationProperties[key];
+          this.removeFromSchema(key, configuration.properties[key]);
+        }
+      }
+      if (configuration.allOf) {
+        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);
+      }
+    }
+
+    contributionRegistry.registerSchema(
+      resourceLanguageSettingsSchemaId,
+      this.resourceLanguageSettingsSchema,
+    );
+    this._onDidSchemaChange.fire();
+    this._onDidUpdateConfiguration.fire(properties);
+  }
+
+  public registerDefaultConfigurations(
+    defaultConfigurations: IStringDictionary<any>[],
+  ): void {
+    const properties: string[] = [];
+    const overrideIdentifiers: string[] = [];
+
+    for (const defaultConfiguration of defaultConfigurations) {
+      for (const key in defaultConfiguration) {
+        properties.push(key);
+
+        if (OVERRIDE_PROPERTY_PATTERN.test(key)) {
+          this.defaultValues[key] = {
+            ...(this.defaultValues[key] || {}),
+            ...defaultConfiguration[key],
+          };
+          const property: IConfigurationPropertySchema = {
+            type: 'object',
+            default: this.defaultValues[key],
+            description: nls.localize(
+              'defaultLanguageConfiguration.description',
+              'Configure settings to be overridden for {0} language.',
+              key,
+            ),
+            $ref: resourceLanguageSettingsSchemaId,
+          };
+          overrideIdentifiers.push(overrideIdentifierFromKey(key));
+          this.configurationProperties[key] = property;
+          this.defaultLanguageConfigurationOverridesNode.properties![key] = property;
+        } else {
+          this.defaultValues[key] = defaultConfiguration[key];
+          const property = this.configurationProperties[key];
+          if (property) {
+            this.updatePropertyDefaultValue(key, property);
+            this.updateSchema(key, property);
+          }
+        }
+      }
+    }
+
+    this.registerOverrideIdentifiers(overrideIdentifiers);
+    this._onDidSchemaChange.fire();
+    this._onDidUpdateConfiguration.fire(properties);
+  }
+
+  public deregisterDefaultConfigurations(
+    defaultConfigurations: IStringDictionary<any>[],
+  ): void {
+    const properties: string[] = [];
+    for (const defaultConfiguration of defaultConfigurations) {
+      for (const key in defaultConfiguration) {
+        properties.push(key);
+        delete this.defaultValues[key];
+        if (OVERRIDE_PROPERTY_PATTERN.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();
+    this._onDidSchemaChange.fire();
+    this._onDidUpdateConfiguration.fire(properties);
+  }
+
+  public notifyConfigurationSchemaUpdated(..._configurations: IConfigurationNode[]) {
+    this._onDidSchemaChange.fire();
+  }
+
+  public registerOverrideIdentifiers(overrideIdentifiers: string[]): void {
+    for (const overrideIdentifier of overrideIdentifiers) {
+      this.overrideIdentifiers.add(overrideIdentifier);
+    }
+    this.updateOverridePropertyPatternKey();
+  }
+
+  private validateAndRegisterProperties(
+    configuration: IConfigurationNode,
+    validate = true,
+    scope: ConfigurationScope = ConfigurationScope.WINDOW,
+  ): string[] {
+    scope = types.isUndefinedOrNull(configuration.scope) ? scope : configuration.scope;
+    const propertyKeys: string[] = [];
+    const { properties } = configuration;
+    if (properties) {
+      for (const key in properties) {
+        if (validate && validateProperty(key)) {
+          delete properties[key];
+          continue;
+        }
+
+        const property = properties[key];
+
+        // update default value
+        this.updatePropertyDefaultValue(key, property);
+
+        // update scope
+        if (OVERRIDE_PROPERTY_PATTERN.test(key)) {
+          property.scope = undefined; // No scope for overridable properties `[${identifier}]`
+        } else {
+          property.scope = types.isUndefinedOrNull(property.scope)
+            ? scope
+            : property.scope;
+        }
+
+        // Add to properties maps
+        // Property is included by default if 'included' is unspecified
+        if (
+          Object.prototype.hasOwnProperty.call(properties[key], 'included') &&
+          !properties[key].included
+        ) {
+          this.excludedConfigurationProperties[key] = properties[key];
+          delete properties[key];
+          continue;
+        } else {
+          this.configurationProperties[key] = properties[key];
+        }
+
+        if (
+          !properties[key].deprecationMessage &&
+          properties[key].markdownDeprecationMessage
+        ) {
+          // If not set, default deprecationMessage to the markdown source
+          properties[key].deprecationMessage =
+            properties[key].markdownDeprecationMessage;
+        }
+
+        propertyKeys.push(key);
+      }
+    }
+    const subNodes = configuration.allOf;
+    if (subNodes) {
+      for (const node of subNodes) {
+        propertyKeys.push(...this.validateAndRegisterProperties(node, validate, scope));
+      }
+    }
+    return propertyKeys;
+  }
+
+  getConfigurations(): IConfigurationNode[] {
+    return this.configurationContributors;
+  }
+
+  getConfigurationProperties(): Record<string, IConfigurationPropertySchema> {
+    return this.configurationProperties;
+  }
+
+  getExcludedConfigurationProperties(): Record<string, IConfigurationPropertySchema> {
+    return this.excludedConfigurationProperties;
+  }
+
+  private registerJSONConfiguration(configuration: IConfigurationNode) {
+    const register = (configuration: IConfigurationNode) => {
+      const { properties } = configuration;
+      if (properties) {
+        for (const key in properties) {
+          this.updateSchema(key, properties[key]);
+        }
+      }
+      const subNodes = configuration.allOf;
+      if (subNodes) {
+        subNodes.forEach(register);
+      }
+    };
+    register(configuration);
+  }
+
+  private updateSchema(key: string, property: IConfigurationPropertySchema): void {
+    allSettings.properties[key] = property;
+    switch (property.scope) {
+      case ConfigurationScope.APPLICATION:
+        applicationSettings.properties[key] = property;
+        break;
+      case ConfigurationScope.MACHINE:
+        machineSettings.properties[key] = property;
+        break;
+      case ConfigurationScope.MACHINE_OVERRIDABLE:
+        machineOverridableSettings.properties[key] = property;
+        break;
+      case ConfigurationScope.WINDOW:
+        windowSettings.properties[key] = property;
+        break;
+      case ConfigurationScope.RESOURCE:
+        resourceSettings.properties[key] = property;
+        break;
+      case ConfigurationScope.LANGUAGE_OVERRIDABLE:
+        resourceSettings.properties[key] = property;
+        this.resourceLanguageSettingsSchema.properties![key] = property;
+        break;
+    }
+  }
+
+  private removeFromSchema(key: string, property: IConfigurationPropertySchema): void {
+    delete allSettings.properties[key];
+    switch (property.scope) {
+      case ConfigurationScope.APPLICATION:
+        delete applicationSettings.properties[key];
+        break;
+      case ConfigurationScope.MACHINE:
+        delete machineSettings.properties[key];
+        break;
+      case ConfigurationScope.MACHINE_OVERRIDABLE:
+        delete machineOverridableSettings.properties[key];
+        break;
+      case ConfigurationScope.WINDOW:
+        delete windowSettings.properties[key];
+        break;
+      case ConfigurationScope.RESOURCE:
+      case ConfigurationScope.LANGUAGE_OVERRIDABLE:
+        delete resourceSettings.properties[key];
+        break;
+    }
+  }
+
+  private updateOverridePropertyPatternKey(): void {
+    for (const overrideIdentifier of this.overrideIdentifiers.values()) {
+      const overrideIdentifierProperty = `[${overrideIdentifier}]`;
+      const resourceLanguagePropertiesSchema: IJSONSchema = {
+        type: 'object',
+        description: nls.localize(
+          'overrideSettings.defaultDescription',
+          'Configure editor settings to be overridden for a language.',
+        ),
+        errorMessage: nls.localize(
+          'overrideSettings.errorMessage',
+          'This setting does not support per-language configuration.',
+        ),
+        $ref: resourceLanguageSettingsSchemaId,
+      };
+      this.updatePropertyDefaultValue(
+        overrideIdentifierProperty,
+        resourceLanguagePropertiesSchema,
+      );
+      allSettings.properties[overrideIdentifierProperty] =
+        resourceLanguagePropertiesSchema;
+      applicationSettings.properties[overrideIdentifierProperty] =
+        resourceLanguagePropertiesSchema;
+      machineSettings.properties[overrideIdentifierProperty] =
+        resourceLanguagePropertiesSchema;
+      machineOverridableSettings.properties[overrideIdentifierProperty] =
+        resourceLanguagePropertiesSchema;
+      windowSettings.properties[overrideIdentifierProperty] =
+        resourceLanguagePropertiesSchema;
+      resourceSettings.properties[overrideIdentifierProperty] =
+        resourceLanguagePropertiesSchema;
+    }
+    this._onDidSchemaChange.fire();
+  }
+
+  private updatePropertyDefaultValue(
+    key: string,
+    property: IConfigurationPropertySchema,
+  ): void {
+    let defaultValue = this.defaultValues[key];
+    if (types.isUndefined(defaultValue)) {
+      defaultValue = property.default;
+    }
+    if (types.isUndefined(defaultValue)) {
+      defaultValue = getDefaultValue(property.type);
+    }
+    property.default = defaultValue;
+  }
+}
+
+const OVERRIDE_PROPERTY = '\\[.*\\]$';
+export const OVERRIDE_PROPERTY_PATTERN = new RegExp(OVERRIDE_PROPERTY);
+
+export function overrideIdentifierFromKey(key: string): string {
+  return key.substring(1, key.length - 1);
+}
+
+export function getDefaultValue(type: string | string[] | undefined): any {
+  const t = Array.isArray(type) ? (<string[]>type)[0] : <string>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();
+Registry.add(Extensions.Configuration, configurationRegistry);
+
+export function validateProperty(property: string): string | null {
+  if (!property.trim()) {
+    return nls.localize('config.property.empty', 'Cannot register an empty property');
+  }
+  if (OVERRIDE_PROPERTY_PATTERN.test(property)) {
+    return nls.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 nls.localize(
+      'config.property.duplicate',
+      "Cannot register '{0}'. This property is already registered.",
+      property,
+    );
+  }
+  return null;
+}
+
+export function getScopes(): [string, ConfigurationScope | undefined][] {
+  const scopes: [string, ConfigurationScope | undefined][] = [];
+  const configurationProperties = configurationRegistry.getConfigurationProperties();
+  for (const key of Object.keys(configurationProperties)) {
+    scopes.push([key, configurationProperties[key].scope]);
+  }
+  scopes.push(['launch', ConfigurationScope.RESOURCE]);
+  scopes.push(['task', ConfigurationScope.RESOURCE]);
+  return scopes;
+}