@theia/core 1.65.0-next.19 → 1.65.0-next.39

package/src/common/preferences/preference-provider.ts

@@ -0,0 +1,164 @@
+// *****************************************************************************
+// Copyright (C) 2023 TypeFox and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { JSONExt, JSONObject, JSONValue } from '@lumino/coreutils';
+import { Event } from '../event';
+import { PreferenceScope } from '../preferences/preference-scope';
+import { URI } from '../uri';
+import { Disposable } from 'vscode-languageserver-protocol';
+
+export interface PreferenceProviderDataChange {
+    /**
+     * The name of the changed preference.
+     */
+    readonly preferenceName: string;
+    /**
+     * The new value of the changed preference.
+     */
+    readonly newValue?: JSONValue;
+    /**
+     * The old value of the changed preference.
+     */
+    readonly oldValue?: JSONValue;
+    /**
+     * The {@link PreferenceScope} of the changed preference.
+     */
+    readonly scope: PreferenceScope;
+    /**
+     * URIs of the scopes in which this change applies.
+     */
+    readonly domain?: string[];
+}
+
+export namespace PreferenceProviderDataChange {
+    export function affects(change: PreferenceProviderDataChange, resourceUri?: string): boolean {
+        const resourcePath = resourceUri && new URI(resourceUri).path;
+        const domain = change.domain;
+        return !resourcePath || !domain || domain.some(uri => new URI(uri).path.relativity(resourcePath) >= 0);
+    }
+}
+
+export interface PreferenceResolveResult<T> {
+    configUri?: URI;
+    value?: T
+}
+
+export interface PreferenceProviderDataChanges {
+    [preferenceName: string]: PreferenceProviderDataChange;
+}
+export const PreferenceProvider = Symbol('PreferenceProvider');
+
+export interface PreferenceProvider extends Disposable {
+    readonly onDidPreferencesChanged: Event<PreferenceProviderDataChanges>;
+    ready: Promise<void>
+
+    /**
+     * Whether t
+     * @param scope the scope to handle
+     */
+    canHandleScope(scope: PreferenceScope): boolean;
+
+    /**
+     * Retrieve the stored value for the given preference and resource URI.
+     *
+     * @param preferenceName the preference identifier.
+     * @param resourceUri the uri of the resource for which the preference is stored. This is used to retrieve
+     * a potentially different value for the same preference for different resources, for example `files.encoding`.
+     *
+     * @returns the value stored for the given preference and resourceUri if it exists, otherwise `undefined`.
+     */
+    get<T>(preferenceName: string, resourceUri?: string): T | undefined;
+    /**
+     * Stores a new value for the given preference key in the provider.
+     * @param key the preference key (typically the name).
+     * @param value the new preference value.
+     * @param resourceUri the URI of the resource for which the preference is stored.
+     *
+     * @returns a promise that only resolves if all changes were delivered.
+     * If changes were made then implementation must either
+     * await on `this.emitPreferencesChangedEvent(...)` or
+     * `this.pendingChanges` if changes are fired indirectly.
+     */
+    setPreference(key: string, value: JSONValue, resourceUri?: string): Promise<boolean>
+    /**
+     * Resolve the value for the given preference and resource URI.
+     *
+     * @param preferenceName the preference identifier.
+     * @param resourceUri the URI of the resource for which this provider should resolve the preference. This is used to retrieve
+     * a potentially different value for the same preference for different resources, for example `files.encoding`.
+     *
+     * @returns an object containing the value stored for the given preference and resourceUri if it exists,
+     * otherwise `undefined`.
+     */
+    resolve<T>(preferenceName: string, resourceUri?: string): PreferenceResolveResult<T>;
+
+    /**
+     * Retrieve the configuration URI for the given resource URI.
+     * @param resourceUri the uri of the resource or `undefined`.
+     * @param sectionName the section to return the URI for, e.g. `tasks` or `launch`. Defaults to settings.
+     *
+     * @returns the corresponding resource URI or `undefined` if there is no valid URI.
+     */
+    getConfigUri?(resourceUri?: string, sectionName?: string): URI | undefined;
+    /**
+     * Retrieves the first valid configuration URI contained by the given resource.
+     * @param resourceUri the uri of the container resource or `undefined`.
+     *
+     * @returns the first valid configuration URI contained by the given resource `undefined`
+     * if there is no valid configuration URI at all.
+     */
+    getContainingConfigUri?(resourceUri?: string, sectionName?: string): URI | undefined;
+
+    /**
+     * Return a JSONObject with all preferences stored in this preference provider
+     */
+    getPreferences(resourceUri?: string): JSONObject;
+}
+
+export namespace PreferenceUtils {
+    export function merge(source: JSONValue | undefined, target: JSONValue): JSONValue {
+        if (source === undefined || !JSONExt.isObject(source)) {
+            return JSONExt.deepCopy(target);
+        }
+        if (JSONExt.isPrimitive(target)) {
+            return {};
+        }
+        for (const [key, value] of Object.entries(target)) {
+            if (key in source) {
+                const sourceValue = source[key];
+                if (JSONExt.isObject(sourceValue) && JSONExt.isObject(value)) {
+                    merge(sourceValue, value);
+                    continue;
+                } else if (JSONExt.isArray(sourceValue) && JSONExt.isArray(value)) {
+                    source[key] = [...JSONExt.deepCopy(sourceValue), ...JSONExt.deepCopy(value)];
+                    continue;
+                }
+            }
+            source[key] = JSONExt.deepCopy(value);
+        }
+        return source;
+    }
+
+    /**
+     * Handles deep equality with the possibility of `undefined`
+     */
+    export function deepEqual(a: JSONValue | undefined, b: JSONValue | undefined): boolean {
+        if (a === b) { return true; }
+        if (a === undefined || b === undefined) { return false; }
+        return JSONExt.deepEqual(a, b);
+    }
+
+}

package/src/{browser → common}/preferences/preference-proxy.ts

@@ -18,9 +18,10 @@
 
 import { Disposable, Event, isObject, MaybePromise } from '../../common';
 import { PreferenceService } from './preference-service';
-import { PreferenceSchema } from './preference-contribution';
 import { PreferenceScope } from './preference-scope';
-import { OverridePreferenceName } from './preference-language-override-service';
+import { IJSONSchema } from '../../common/json-schema';
+import { isThenable } from '../../common/promise-util';
+import { OverridePreferenceName } from '../../common/preferences/preference-language-override-service';
 
 /**
  * It is worth explaining the type for `PreferenceChangeEvent`:
@@ -174,29 +175,29 @@ export interface PreferenceProxyOptions {
  *
  * @deprecated @since 1.23.0 use `PreferenceProxyFactory` instead.
  */
-export function createPreferenceProxy<T>(preferences: PreferenceService, promisedSchema: MaybePromise<PreferenceSchema>, options?: PreferenceProxyOptions): PreferenceProxy<T> {
+export function createPreferenceProxy<T>(preferences: PreferenceService, promisedSchema: MaybePromise<IJSONSchema>, options?: PreferenceProxyOptions): PreferenceProxy<T> {
     const opts = options || {};
     const prefix = opts.prefix || '';
     const style = opts.style || 'flat';
     const isDeep = style === 'deep' || style === 'both';
     const isFlat = style === 'both' || style === 'flat';
-    let schema: PreferenceSchema | undefined;
-    if (PreferenceSchema.is(promisedSchema)) {
-        schema = promisedSchema;
+    let schema: IJSONSchema | undefined;
+    if (!isThenable(promisedSchema)) {
+        schema = promisedSchema as IJSONSchema;
     } else {
-        promisedSchema.then(s => schema = s);
+        promisedSchema.then((s: IJSONSchema) => schema = s);
     }
     const onPreferenceChanged = (listener: (e: PreferenceChangeEvent<T>) => any, thisArgs?: any, disposables?: Disposable[]) => preferences.onPreferencesChanged(changes => {
         if (schema) {
             for (const key of Object.keys(changes)) {
                 const e = changes[key];
                 const overridden = preferences.overriddenPreferenceName(e.preferenceName);
-                const preferenceName: any = overridden ? overridden.preferenceName : e.preferenceName;
+                const preferenceName = overridden ? overridden.preferenceName : e.preferenceName;
                 if (preferenceName.startsWith(prefix) && (!opts.overrideIdentifier || overridden?.overrideIdentifier === opts.overrideIdentifier)) {
-                    if (schema.properties[preferenceName]) {
+                    if (schema.properties && schema.properties[preferenceName]) {
                         const { newValue, oldValue } = e;
                         listener({
-                            newValue, oldValue, preferenceName,
+                            newValue: newValue as T[keyof T], oldValue: oldValue as T[keyof T], preferenceName: preferenceName as keyof T,
                             affects: (resourceUri, overrideIdentifier) => {
                                 if (overrideIdentifier !== overridden?.overrideIdentifier) {
                                     return false;
@@ -223,7 +224,7 @@ export function createPreferenceProxy<T>(preferences: PreferenceService, promise
 
     const ownKeys: () => string[] = () => {
         const properties = [];
-        if (schema) {
+        if (schema && schema.properties) {
             for (const p of Object.keys(schema.properties)) {
                 if (p.startsWith(prefix)) {
                     const idx = p.indexOf('.', prefix.length);
@@ -250,7 +251,7 @@ export function createPreferenceProxy<T>(preferences: PreferenceService, promise
         if (style === 'deep' && property.indexOf('.') !== -1) {
             return false;
         }
-        if (schema) {
+        if (schema && schema.properties) {
             const fullProperty = prefix ? prefix + property : property;
             if (schema.properties[fullProperty]) {
                 preferences.set(fullProperty, value, PreferenceScope.Default);
@@ -279,7 +280,7 @@ export function createPreferenceProxy<T>(preferences: PreferenceService, promise
             throw new Error(`unexpected property: ${String(property)}`);
         }
         const fullProperty = prefix ? prefix + property : property;
-        if (schema) {
+        if (schema && schema.properties) {
             if (isFlat || property.indexOf('.') === -1) {
                 if (schema.properties[fullProperty]) {
                     let value;
@@ -311,7 +312,7 @@ export function createPreferenceProxy<T>(preferences: PreferenceService, promise
         if (property === 'toJSON') {
             return toJSON();
         }
-        if (schema && isDeep) {
+        if (schema && schema.properties && isDeep) {
             const newPrefix = fullProperty + '.';
             for (const p of Object.keys(schema.properties)) {
                 if (p.startsWith(newPrefix)) {

package/src/common/preferences/preference-schema-service.ts

@@ -0,0 +1,434 @@
+// *****************************************************************************
+// Copyright (C) 2025 STMicroelectronics and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { inject, injectable, named, postConstruct } from 'inversify';
+import { Disposable } from '../disposable';
+import { Emitter } from '../event';
+import { IJSONSchema } from '../json-schema';
+import { JSONObject, JSONValue } from '@lumino/coreutils';
+import { PreferenceDataProperty, PreferenceSchema, PreferenceSchemaService, DefaultValueChangedEvent, PreferenceContribution } from './preference-schema';
+import { PreferenceScope, ValidPreferenceScopes } from './preference-scope';
+import { PreferenceUtils } from './preference-provider';
+import { ContributionProvider } from '../contribution-provider';
+import { Deferred } from '../promise-util';
+
+const NO_OVERRIDE = {};
+const OVERRIDE_PROPERTY = '\\[(.*)\\]$';
+
+@injectable()
+export class PreferenceSchemaServiceImpl implements PreferenceSchemaService {
+    // Storage structures
+    protected readonly schemas = new Set<PreferenceSchema>();
+    protected readonly properties = new Map<string, PreferenceDataProperty>();
+    /**
+     * This map stores default overrides. The primary map key is the base preference name.
+     * The preference name maps to a second map keyed by the override identifier or a special object value `NO_OVERRIDE',
+     * representing default overrides for the base property. The value in this second map is an array
+     * of entries in reverse order of their insertion. This is necessary becuaus multiple clients might register
+     * overrides for the same preference key/override combination. The elements in this array consist of a unique, generated
+     * identifier and the actual override value. This allows us to always return the last registerd override even
+     * when overrides are later removed.
+     */
+    protected readonly defaultOverrides = new Map<string, Map<string | object, [number, JSONValue][]>>();
+    protected readonly _overrideIdentifiers = new Set<string>();
+
+    protected readonly jsonSchemas: IJSONSchema[] = [];
+
+    protected readonly _ready = new Deferred();
+
+    get ready(): Promise<void> {
+        return this._ready.promise;
+    }
+
+    get overrideIdentifiers(): ReadonlySet<string> {
+        return this._overrideIdentifiers;
+    }
+
+    getSchemaProperties(): ReadonlyMap<string, PreferenceDataProperty> {
+        return this.properties;
+    }
+
+    protected nextSchemaTitle = 1;
+    protected nextOverrideValueId = 1;
+
+    // Event emitters
+    protected readonly defaultValueChangedEmitter = new Emitter<DefaultValueChangedEvent>();
+    protected readonly schemaChangedEmitter = new Emitter<void>();
+
+    // Public events
+    readonly onDidChangeDefaultValue = this.defaultValueChangedEmitter.event;
+    readonly onDidChangeSchema = this.schemaChangedEmitter.event;
+
+    @inject(ValidPreferenceScopes)
+    readonly validScopes: readonly PreferenceScope[];
+
+    @inject(ContributionProvider) @named(PreferenceContribution)
+    protected readonly preferenceContributions: ContributionProvider<PreferenceContribution>;
+
+    @postConstruct()
+    protected init(): void {
+        for (const scope of this.validScopes) {
+            this.jsonSchemas[scope] = {
+                type: 'object',
+                properties: {},
+                patternProperties: {},
+                additionalProperties: false
+            };
+        }
+        const promises: Promise<void>[] = [];
+        this.preferenceContributions.getContributions().forEach(contrib => {
+            if (contrib.schema) {
+                this.addSchema(contrib.schema);
+            }
+            if (contrib.initSchema) {
+                promises.push(contrib.initSchema(this));
+            }
+        });
+        Promise.all(promises).then(() => this._ready.resolve());
+    }
+
+    dispose(): void {
+        this.defaultValueChangedEmitter.dispose();
+        this.schemaChangedEmitter.dispose();
+    }
+
+    registerOverrideIdentifier(overrideIdentifier: string): Disposable {
+        if (!this._overrideIdentifiers.has(overrideIdentifier)) {
+            this.addOverrideToJsonSchema(overrideIdentifier);
+            this._overrideIdentifiers.add(overrideIdentifier);
+            this.schemaChangedEmitter.fire();
+
+            return Disposable.create(() => {
+                if (this._overrideIdentifiers.delete(overrideIdentifier)) {
+                    this.schemaChangedEmitter.fire();
+                }
+            });
+        }
+        return Disposable.NULL;
+    }
+
+    addSchema(schema: PreferenceSchema): Disposable {
+        this.schemas.add(schema);
+
+        for (const [key, property] of Object.entries(schema.properties)) {
+            if (this.properties.has(key)) {
+                throw new Error(`Property with id '${key}' already exists`);
+            }
+
+            if (property.scope === undefined) {
+                property.scope = schema.scope;
+            }
+
+            if (property.overridable === undefined) {
+                property.overridable = schema.defaultOverridable;
+            }
+
+            this.properties.set(key, property);
+            this.setJSONSchemasProperty(key, property);
+            if (property.default !== undefined) {
+                this.defaultValueChangedEmitter.fire(this.changeFor(key, undefined, this.defaultOverrides.get(key), undefined, property.default!));
+            }
+
+        }
+
+        this.schemaChangedEmitter.fire();
+
+        return Disposable.create(() => {
+            if (this.schemas.delete(schema)) {
+                for (const [key, property] of Object.entries(schema.properties)) {
+                    this.deleteFromJSONSchemas(key, property);
+                    this.properties.delete(key);
+                    const overrides = this.defaultOverrides.get(key);
+
+                    const baseOverride = overrides?.get(NO_OVERRIDE);
+                    if (baseOverride !== undefined) {
+                        this.defaultValueChangedEmitter.fire(this.changeFor(key, undefined, overrides, baseOverride, undefined));
+                    } else if (property.default !== undefined) {
+                        this.defaultValueChangedEmitter.fire(this.changeFor(key, undefined, overrides, property.default, undefined));
+                    }
+                    if (overrides) {
+                        for (const [overrideKey, value] of overrides) {
+                            if (typeof overrideKey === 'string') {
+                                this.defaultValueChangedEmitter.fire(this.changeFor(key, overrideKey, overrides, value[0][1], undefined));
+                            }
+                        }
+                    }
+                }
+
+                this.schemaChangedEmitter.fire();
+            }
+        });
+    }
+
+    isValidInScope(preferenceName: string, scope: PreferenceScope): boolean {
+        const property = this.properties.get(preferenceName);
+
+        if (!property) {
+            return false;
+        }
+
+        // A property is valid in a scope if:
+        // 1. It is included (undefined or true)
+        // 2. Its scope is not defined (valid in all scopes) or its scope includes the given scope
+        return (property.included !== false) &&
+            (property.scope === undefined || property.scope >= scope);
+    }
+
+    getSchemaProperty(key: string): PreferenceDataProperty | undefined {
+        return this.properties.get(key);
+    }
+
+    updateSchemaProperty(key: string, property: PreferenceDataProperty): void {
+        const existing = this.properties.get(key);
+        if (existing) {
+            // Update the property with new values
+            const updatedProperty = { ...existing, ...property };
+            this.properties.set(key, updatedProperty);
+            const hasNoBaseOverrideValue = this.defaultOverrides.get(key)?.get(NO_OVERRIDE) === undefined;
+            if (hasNoBaseOverrideValue && !PreferenceUtils.deepEqual(property.default, existing.default)) {
+                this.defaultValueChangedEmitter.fire(this.changeFor(key, undefined, this.defaultOverrides.get(key), undefined, property.default!));
+            }
+
+            this.setJSONSchemasProperty(key, updatedProperty);
+            this.schemaChangedEmitter.fire();
+        } else {
+            console.warn(`Trying to update non-existent property ${key}`);
+        }
+    }
+
+    registerOverride(key: string, overrideIdentifier: string | undefined, value: JSONValue): Disposable {
+        const overrideId = overrideIdentifier || NO_OVERRIDE;
+        const property = this.properties.get(key);
+        if (!property) {
+            console.warn(`Trying to register default override for non-existent preference: ${key}`);
+        } else if (!property.overridable && overrideIdentifier) {
+            console.warn(`Trying to register default override for identifier ${overrideIdentifier} for non-overridable preference: ${key}`);
+        }
+
+        let overrides = this.defaultOverrides.get(key);
+        if (!overrides) {
+            overrides = new Map();
+            this.defaultOverrides.set(key, overrides);
+        }
+
+        const oldValue = this.getDefaultValue(key, overrideIdentifier);
+
+        const overrideValueId = this.nextOverrideValueId;
+        let override = overrides.get(overrideId);
+        if (!override) {
+            override = [];
+            overrides.set(overrideId, override);
+        }
+        override.unshift([overrideValueId, value]);
+
+        // Fire event only if the value actually changed
+        if (!PreferenceUtils.deepEqual(oldValue, value)) {
+            const evt = this.changeFor(key, overrideIdentifier, overrides, oldValue, value);
+            this.defaultValueChangedEmitter.fire(evt);
+        }
+
+        if (property) {
+            this.setJSONSchemasProperty(key, property);
+        }
+
+        return Disposable.create(() => {
+            this.removeOverride(key, overrideIdentifier, overrideValueId);
+        });
+    }
+
+    protected changeFor(key: string, overrideIdentifier: string | undefined,
+        overrides: Map<string | object, [number, JSONValue][]> | undefined, oldValue: JSONValue | undefined, newValue: JSONValue | undefined): DefaultValueChangedEvent {
+        const affectedOverrides = [];
+        if (!overrideIdentifier) {
+            for (const id of this._overrideIdentifiers) {
+                if (!overrides?.has(id)) {
+                    affectedOverrides.push(id);
+                }
+            }
+        }
+        return {
+            key,
+            overrideIdentifier: overrideIdentifier,
+            otherAffectedOverrides: affectedOverrides,
+            oldValue,
+            newValue
+        };
+    }
+
+    protected removeOverride(key: string, overrideIdentifier: string | undefined, overrideValueId: number): void {
+        const overrideId = overrideIdentifier || NO_OVERRIDE;
+        const overrides = this.defaultOverrides.get(key);
+        if (overrides) {
+            const values = overrides.get(overrideId);
+            if (values) {
+                const index = values.findIndex(v => v[0] === overrideValueId);
+                if (index) {
+                    const oldValue = this.getDefaultValue(key, overrideIdentifier);
+                    values.splice(index, 1);
+                    const newValue = this.getDefaultValue(key, overrideIdentifier);
+                    if (!PreferenceUtils.deepEqual(oldValue, newValue)) {
+
+                        const affectedOverrides = [];
+                        if (!overrideIdentifier) {
+                            for (const id of this._overrideIdentifiers) {
+                                if (!overrides.has(id)) {
+                                    affectedOverrides.push(id);
+                                }
+                            }
+                        }
+
+                        this.defaultValueChangedEmitter.fire({
+                            key,
+                            overrideIdentifier,
+                            otherAffectedOverrides: affectedOverrides,
+                            oldValue,
+                            newValue
+                        });
+                    }
+                }
+                if (values.length === 0) {
+                    overrides.delete(overrideId);
+                }
+            }
+            if (overrides.size === 0) {
+                this.defaultOverrides.delete(key);
+            }
+        }
+    }
+
+    getDefaultValue(key: string, overrideIdentifier: string | undefined): JSONValue | undefined {
+        const overrideId = overrideIdentifier || NO_OVERRIDE;
+        const overrides = this.defaultOverrides.get(key);
+        if (overrides) {
+            const values = overrides.get(overrideId);
+            if (values) {
+                return values[0][1]; // there will be no empty values arrays in the data structure
+            }
+        }
+
+        const property = this.properties.get(key);
+        return property?.default;
+    }
+
+    inspectDefaultValue(key: string, overrideIdentifier: string | undefined): JSONValue | undefined {
+        const overrideId = overrideIdentifier || NO_OVERRIDE;
+        const overrides = this.defaultOverrides.get(key);
+        if (overrides) {
+            const values = overrides.get(overrideId);
+            if (values) {
+                return values[0][1]; // there will be no empty values arrays in the data structure
+            }
+        }
+
+        if (!overrideIdentifier) {
+            const property = this.properties.get(key);
+            return property?.default;
+        }
+        return undefined;
+    }
+
+    getJSONSchema(scope: PreferenceScope): IJSONSchema {
+        return this.jsonSchemas[scope];
+    }
+
+    private setJSONSchemasProperty(key: string, property: PreferenceDataProperty): void {
+        for (const scope of this.validScopes) {
+            if (this.isValidInScope(key, scope)) {
+                this.setJSONSchemaProperty(this.jsonSchemas[scope], key, property);
+            }
+        }
+    }
+    private deleteFromJSONSchemas(key: string, property: PreferenceDataProperty): void {
+        for (const scope of this.validScopes) {
+            if (this.isValidInScope(key, scope)) {
+                const schema = this.jsonSchemas[scope];
+                for (const name of Object.keys(schema.properties!)) {
+                    if (name.match(OVERRIDE_PROPERTY)) {
+                        const value = schema.properties![name] as IJSONSchema;
+                        delete value.properties![key];
+                    } else {
+                        delete schema.properties![key];
+                    }
+                }
+            }
+        }
+    }
+
+    private setJSONSchemaProperty(schema: IJSONSchema, key: string, property: PreferenceDataProperty): void {
+        // Add property to the schema
+        const prop = { ...property, default: this.getDefaultValue(key, undefined) };
+        schema.properties![key] = prop;
+        delete prop['scope'];
+        delete prop['overridable'];
+        if (property.overridable) {
+            for (const overrideIdentifier of this._overrideIdentifiers) {
+                const overrideSchema: IJSONSchema = schema.properties![`[${overrideIdentifier}]`] || {
+                    type: 'object',
+                    properties: {},
+                    patternProperties: {},
+                    additionalProperties: false
+                };
+                schema.properties![`[${overrideIdentifier}]`] = overrideSchema;
+                overrideSchema.properties![key] = { ...property, default: this.getDefaultValue(key, overrideIdentifier) };
+            }
+        }
+    }
+
+    addOverrideToJsonSchema(overrideIdentifier: string): void {
+        for (const scope of this.validScopes) {
+            const schema = this.jsonSchemas[scope];
+            const overrideSchema: IJSONSchema = {
+                type: 'object',
+                properties: {},
+                patternProperties: {},
+                additionalProperties: false
+            };
+            schema.properties![`[${overrideIdentifier}]`] = overrideSchema;
+            for (const [key, property] of this.properties.entries()) {
+                if (property.overridable && this.isValidInScope(key, scope)) {
+                    overrideSchema.properties![key] = { ...property, default: this.getDefaultValue(key, overrideIdentifier) };
+                }
+            }
+        }
+    }
+
+    getDefaultValues(): JSONObject {
+        const result: JSONObject = {};
+
+        for (const [key, property] of this.properties.entries()) {
+            if (this.isValidInScope(key, PreferenceScope.Default)) {
+                if (property.default !== undefined) {
+                    result[key] = property.default;
+                }
+                const overrides = this.defaultOverrides.get(key);
+                if (overrides) {
+                    for (const [overrideId, values] of overrides.entries()) {
+                        if (overrideId === NO_OVERRIDE) {
+                            result[key] = values[0][1];
+                        } else {
+                            const overrideKey = `[${overrideId}]`;
+                            const target: JSONObject = result[overrideKey] as JSONObject || {};
+                            target[key] = values[0][1];
+                            result[overrideKey] = target;
+                        }
+                    }
+                }
+            }
+        }
+
+        return result;
+    }
+}