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

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

@@ -16,12 +16,12 @@
 
 import { interfaces } from 'inversify';
 import { environment } from '@theia/application-package/lib/environment';
-import { createPreferenceProxy, PreferenceProxy, PreferenceService, PreferenceContribution, PreferenceSchema } from './preferences';
 import { SUPPORTED_ENCODINGS } from './supported-encodings';
-import { FrontendApplicationConfigProvider } from './frontend-application-config-provider';
 import { isOSX } from '../common/os';
 import { nls } from '../common/nls';
-import { DefaultTheme } from '@theia/application-package/lib/application-props';
+import { PreferenceContribution, PreferenceSchema } from '../common/preferences/preference-schema';
+import { createPreferenceProxy, PreferenceProxy, PreferenceService } from '../common/preferences';
+import { PreferenceScope } from '../common/preferences/preference-scope';
 
 /* eslint-disable max-len */
 const windowTitleDescription = [
@@ -43,7 +43,6 @@ const windowTitleDescription = [
 ].join('\n- ');
 
 export const corePreferenceSchema: PreferenceSchema = {
-    'type': 'object',
     properties: {
         'application.confirmExit': {
             type: 'string',
@@ -59,7 +58,7 @@ export const corePreferenceSchema: PreferenceSchema = {
             'type': 'boolean',
             'default': true,
             'description': nls.localizeByDefault('Enable/disable navigation breadcrumbs.'),
-            'scope': 'application'
+            'scope': PreferenceScope.User
         },
         'files.encoding': {
             'type': 'string',
@@ -67,7 +66,7 @@ export const corePreferenceSchema: PreferenceSchema = {
             'default': 'utf8',
             'description': nls.localizeByDefault(
                 'The default character set encoding to use when reading and writing files. This setting can also be configured per language.'),
-            'scope': 'language-overridable',
+            'scope': PreferenceScope.Folder,
             'enumDescriptions': Object.keys(SUPPORTED_ENCODINGS).map(key => SUPPORTED_ENCODINGS[key].labelLong),
             'included': Object.keys(SUPPORTED_ENCODINGS).length > 1
         },
@@ -103,7 +102,7 @@ export const corePreferenceSchema: PreferenceSchema = {
                     : nls.localizeByDefault('Menu is displayed as a compact button in the side bar.')
             ],
             default: 'classic',
-            scope: 'application',
+            scope: PreferenceScope.User,
             markdownDescription: nls.localizeByDefault("Control the visibility of the menu bar. A setting of 'toggle' means that the menu bar is hidden and a single press of the Alt key will show it. A setting of 'compact' will move the menu into the side bar."),
             included: !(isOSX && environment.electron.is())
         },
@@ -112,13 +111,13 @@ export const corePreferenceSchema: PreferenceSchema = {
             default: isOSX
                 ? '${activeEditorShort}${separator}${rootName}'
                 : '${dirty} ${activeEditorShort}${separator}${rootName}${separator}${appName}',
-            scope: 'application',
+            scope: PreferenceScope.User,
             markdownDescription: windowTitleDescription
         },
         'window.titleSeparator': {
             type: 'string',
             default: ' - ',
-            scope: 'application',
+            scope: PreferenceScope.User,
             markdownDescription: nls.localizeByDefault('Separator used by {0}.', '`#window.title#`')
         },
         'window.tabCloseIconPlacement': {
@@ -129,7 +128,7 @@ export const corePreferenceSchema: PreferenceSchema = {
                 nls.localize('theia/core/window/tabCloseIconPlacement/start', 'Place the close icon at the start of the label. In left-to-right languages, this is the left side of the tab.'),
             ],
             default: 'end',
-            scope: 'application',
+            scope: PreferenceScope.User,
             description: nls.localize('theia/core/window/tabCloseIconPlacement/description', 'Place the close icons on tab titles at the start or end of the tab. The default is end on all platforms.'),
             included: isOSX
         },
@@ -153,18 +152,18 @@ export const corePreferenceSchema: PreferenceSchema = {
             type: 'string',
             pattern: '^https?://([^:]*(:[^@]*)?@)?([^:]+|\\[[:0-9a-fA-F]+\\])(:\\d+)?/?$|^$',
             markdownDescription: nls.localizeByDefault('The proxy setting to use. If not set, will be inherited from the `http_proxy` and `https_proxy` environment variables. When during [remote development](https://aka.ms/vscode-remote) the {0} setting is disabled this setting can be configured in the local and the remote settings separately.'),
-            scope: 'application'
+            scope: PreferenceScope.User
         },
         'http.proxyStrictSSL': {
             type: 'boolean',
             default: true,
             description: nls.localizeByDefault('Controls whether the proxy server certificate should be verified against the list of supplied CAs. When during [remote development](https://aka.ms/vscode-remote) the {0} setting is disabled this setting can be configured in the local and the remote settings separately.'),
-            scope: 'application'
+            scope: PreferenceScope.User
         },
         'http.proxyAuthorization': {
             type: 'string',
             markdownDescription: nls.localizeByDefault('The value to send as the `Proxy-Authorization` header for every network request. When during [remote development](https://aka.ms/vscode-remote) the {0} setting is disabled this setting can be configured in the local and the remote settings separately.'),
-            scope: 'application'
+            scope: PreferenceScope.User
         },
         'http.proxySupport': {
             type: 'string',
@@ -177,13 +176,13 @@ export const corePreferenceSchema: PreferenceSchema = {
             ],
             default: 'override',
             description: nls.localizeByDefault('Use the proxy support for extensions. When during [remote development](https://aka.ms/vscode-remote) the {0} setting is disabled this setting can be configured in the local and the remote settings separately.'),
-            scope: 'application'
+            scope: PreferenceScope.User
         },
         'http.systemCertificates': {
             type: 'boolean',
             default: true,
             description: nls.localizeByDefault('Controls whether CA certificates should be loaded from the OS. On Windows and macOS, a reload of the window is required after turning this off. When during [remote development](https://aka.ms/vscode-remote) the {0} setting is disabled this setting can be configured in the local and the remote settings separately.'),
-            scope: 'application'
+            scope: PreferenceScope.User
         },
         'workbench.list.openMode': {
             type: 'string',
@@ -229,14 +228,14 @@ export const corePreferenceSchema: PreferenceSchema = {
             type: 'string',
             enum: ['dark', 'light', 'hc-theia'],
             enumItemLabels: ['Dark (Theia)', 'Light (Theia)', 'High Contrast (Theia)'],
-            default: DefaultTheme.defaultForOSTheme(FrontendApplicationConfigProvider.get().defaultTheme),
+            default: 'light',
             description: nls.localizeByDefault('Specifies the color theme used in the workbench when {0} is not enabled.', '`#window.autoDetectColorScheme#`')
         },
         'workbench.iconTheme': {
             type: ['string'],
             enum: ['none', 'theia-file-icons'],
             enumItemLabels: [nls.localizeByDefault('None'), 'File Icons (Theia)'],
-            default: FrontendApplicationConfigProvider.get().defaultIconTheme,
+            default: 'none',
             description: nls.localizeByDefault("Specifies the file icon theme used in the workbench or 'null' to not show any file icons.")
         },
         'workbench.silentNotifications': {

package/src/common/index.ts

@@ -20,8 +20,10 @@ export * from './cancellation';
 export * from './command';
 export * from './contribution-filter';
 export * from './contribution-provider';
+export * from './core-preferences';
 export * from './disposable';
 export * from './event';
+export * from './inversify-utils';
 export * from './listener';
 export * from './logger';
 export * from './lsp-types';
@@ -36,6 +38,7 @@ export * from './objects';
 export * from './os';
 export * from './path';
 export * from './performance';
+export * from './preferences';
 export * from './progress-service';
 export * from './progress-service-protocol';
 export * from './quick-pick-service';
@@ -45,6 +48,7 @@ export * from './selection';
 export * from './selection-service';
 export * from './strings';
 export * from './telemetry';
+export * from './tree-preference';
 export * from './types';
 export { default as URI } from './uri';
 export * from './uuid';

package/src/common/inversify-utils.ts

@@ -0,0 +1,63 @@
+// *****************************************************************************
+// 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 { interfaces, Container } from 'inversify';
+
+/**
+ * This utility creates a factory function that accepts runtime arguments which are bound as constant
+ * values in a child container, allowing for dependency injection of both static dependencies
+ * (resolved as usual from the factory's container) and dynamic parameters (provided at factory invocation time).
+ *
+ * @example
+ * ```typescript
+ * // Factory interface
+ * interface UserPreferenceProviderFactory {
+ *     (uri: URI, section: string): UserPreferenceProvider;
+ * }
+ * // Factory symbol
+ * const UserPreferenceProviderFactory = Symbol('UserPreferenceProviderFactory');
+ *
+ * // Bind the factory
+ * bindFactory(
+ *     bind,
+ *     UserPreferenceProviderFactory,   // Service identifier of the factory
+ *     UserPreferenceProvider,          // Service identifier of the entity to be constructed
+ *     SectionPreferenceProviderUri,    // The first factory argument will be bound to this identifier (uri)
+ *     SectionPreferenceProviderSection // The second factory argument will be bound to this identifier  (section)
+ * );
+ *
+ * // Usage: factory(uri, section) creates UserPreferenceProvider with injected dependencies
+ * const factory = container.get(UserPreferenceProviderFactory);
+ * const provider = factory(myUri, 'settings');
+ * ```
+ */
+
+export function bindFactory<F, C>(bind: interfaces.Bind,
+    factoryId: interfaces.ServiceIdentifier<F>,
+    constructor: interfaces.Newable<C>,
+    ...parameterBindings: interfaces.ServiceIdentifier<unknown>[]): void {
+    bind(factoryId).toFactory(ctx =>
+        (...args: unknown[]) => {
+            const child = new Container({ defaultScope: 'Singleton' });
+            child.parent = ctx.container;
+            for (let i = 0; i < parameterBindings.length; i++) {
+                child.bind(parameterBindings[i]).toConstantValue(args[i]);
+            }
+            child.bind(constructor).to(constructor);
+            return child.get(constructor);
+        }
+    );
+}

package/src/common/json-schema.ts

@@ -87,6 +87,7 @@ export interface IJSONSchema {
     errorMessage?: string; // VSCode extension
     patternErrorMessage?: string; // VSCode extension
     deprecationMessage?: string; // VSCode extension
+    markdownDeprecationMessage?: string; // VS code extension
     enumItemLabels?: string[]; // VSCode extension
     enumDescriptions?: string[]; // VSCode extension
     markdownEnumDescriptions?: string[]; // VSCode extension

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

@@ -0,0 +1,91 @@
+// *****************************************************************************
+// 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 { JSONObject, JSONValue } from '@lumino/coreutils';
+import { PreferenceScope } from './preference-scope';
+import { PreferenceProvider, PreferenceProviderDataChange, PreferenceProviderDataChanges, PreferenceResolveResult } from './preference-provider';
+import { inject, injectable, postConstruct } from 'inversify';
+import { PreferenceSchemaService } from './preference-schema';
+import { Deferred } from '../promise-util';
+import { PreferenceLanguageOverrideService } from './preference-language-override-service';
+import { PreferenceProviderBase } from './preference-provider-impl';
+
+// *****************************************************************************
+
+@injectable()
+export class DefaultsPreferenceProvider extends PreferenceProviderBase implements PreferenceProvider {
+
+    @inject(PreferenceSchemaService)
+    protected readonly preferenceSchemaService: PreferenceSchemaService;
+
+    @inject(PreferenceLanguageOverrideService)
+    protected readonly preferenceOverrideService: PreferenceLanguageOverrideService;
+
+    protected readonly _ready = new Deferred<void>();
+    ready: Promise<void> = this._ready.promise;
+
+    @postConstruct()
+    init(): void {
+        this.toDispose.push(this.preferenceSchemaService.onDidChangeDefaultValue(e => {
+            const changes: PreferenceProviderDataChanges = {};
+            if (e.overrideIdentifier) {
+                changes[e.key] = this.changeFor(e.key, e.overrideIdentifier, e.oldValue, e.newValue);
+            } else {
+                changes[e.key] = this.changeFor(e.key, undefined, e.oldValue, e.newValue);
+                for (const override of e.otherAffectedOverrides) {
+                    const change = this.changeFor(e.key, override, e.oldValue, e.newValue);
+                    changes[change.preferenceName] = change;
+                }
+            }
+            this.emitPreferencesChangedEvent(changes);
+        }));
+        this._ready.resolve();
+    }
+
+    protected changeFor(key: string, overrideIdentifier: string | undefined, oldValue: JSONValue | undefined, newValue: JSONValue | undefined): PreferenceProviderDataChange {
+        const preferenceName = overrideIdentifier ? this.preferenceOverrideService.overridePreferenceName({ preferenceName: key, overrideIdentifier }) : key;
+
+        return {
+            preferenceName: preferenceName,
+            newValue: newValue,
+            oldValue: oldValue,
+            scope: PreferenceScope.Default
+        };
+    }
+
+    canHandleScope(scope: PreferenceScope): boolean {
+        return scope === PreferenceScope.Default;
+    }
+    get<T>(preferenceName: string, resourceUri?: string): T | undefined {
+        const overrideInfo = this.preferenceOverrideService.overriddenPreferenceName(preferenceName);
+        return this.preferenceSchemaService.getDefaultValue(overrideInfo?.preferenceName ?? preferenceName, overrideInfo?.overrideIdentifier) as T;
+    }
+
+    setPreference(key: string, value: JSONValue, resourceUri?: string): Promise<boolean> {
+        return Promise.resolve(false);
+    }
+
+    resolve<T>(preferenceName: string, resourceUri?: string): PreferenceResolveResult<T> {
+        const overrideInfo = this.preferenceOverrideService.overriddenPreferenceName(preferenceName);
+        return {
+            value: this.preferenceSchemaService.inspectDefaultValue(overrideInfo?.preferenceName ?? preferenceName, overrideInfo?.overrideIdentifier) as T,
+            configUri: undefined
+        };
+    }
+
+    getPreferences(): JSONObject {
+        return this.preferenceSchemaService.getDefaultValues();
+    }
+}

package/src/common/preferences/index.ts

@@ -0,0 +1,27 @@
+// *****************************************************************************
+// 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
+// *****************************************************************************
+
+export * from './defaults-preference-provider';
+export * from './preference-language-override-service';
+export * from './preference-provider-impl';
+export * from './preference-provider';
+export * from './preference-schema-service';
+export * from './preference-schema';
+export * from './preference-scope';
+export * from './preference-service';
+export * from './injectable-preference-proxy';
+export * from './preference-proxy';
+export * from './preference-configurations';

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

@@ -16,12 +16,12 @@
 
 import { inject, injectable, postConstruct } from 'inversify';
 import { PreferenceSchema } from '../../common/preferences/preference-schema';
-import { Disposable, DisposableCollection, Emitter, Event, isObject, MaybePromise } from '../../common';
+import { Disposable, DisposableCollection, Emitter, Event, isObject, MaybePromise, PreferenceScope } from '../../common';
 import { PreferenceChangeEvent, PreferenceEventEmitter, PreferenceProxy, PreferenceProxyOptions, PreferenceRetrieval } from './preference-proxy';
-import { PreferenceChange, PreferenceChangeImpl, PreferenceChanges, PreferenceScope, PreferenceService } from './preference-service';
+import { PreferenceChange, PreferenceChangeImpl, PreferenceChanges, PreferenceService } from './preference-service';
 import { JSONValue } from '@lumino/coreutils';
 import { PreferenceProviderDataChange } from './preference-provider';
-import { OverridePreferenceName } from './preference-language-override-service';
+import { OverridePreferenceName } from '../../common/preferences/preference-language-override-service';
 
 export const PreferenceProxySchema = Symbol('PreferenceProxySchema');
 export interface PreferenceProxyFactory {

package/src/{browser → common}/preferences/preference-language-override-service.ts

@@ -14,9 +14,11 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import { injectable } from 'inversify';
-import { escapeRegExpCharacters, isObject } from '../../common';
-import { PreferenceSchemaProperties } from '../../common/preferences/preference-schema';
+import { inject, injectable } from 'inversify';
+import { isObject } from '../types';
+import { IndexedAccess, PreferenceSchemaService } from './preference-schema';
+import { escapeRegExpCharacters } from '../strings';
+import { JSONValue } from '@lumino/coreutils';
 
 export interface OverridePreferenceName {
     preferenceName: string
@@ -34,10 +36,11 @@ export const getOverridePattern = (identifier: string) => `\\[(${identifier})\\]
 
 @injectable()
 export class PreferenceLanguageOverrideService {
-    protected readonly overrideIdentifiers = new Set<string>();
+    @inject(PreferenceSchemaService)
+    protected readonly preferenceSchemaService: PreferenceSchemaService;
 
-    testOverrideValue(name: string, value: unknown): value is PreferenceSchemaProperties {
-        return PreferenceSchemaProperties.is(value) && OVERRIDE_PROPERTY_PATTERN.test(name);
+    static testOverrideValue(name: string, value: unknown): value is IndexedAccess<JSONValue> {
+        return isObject(value) && OVERRIDE_PROPERTY_PATTERN.test(name);
     }
 
     /**
@@ -65,7 +68,7 @@ export class PreferenceLanguageOverrideService {
         }
         const matches = name.substring(0, index).match(OVERRIDE_PROPERTY_PATTERN);
         const overrideIdentifier = matches && matches[1];
-        if (!overrideIdentifier || !this.overrideIdentifiers.has(overrideIdentifier)) {
+        if (!overrideIdentifier || !this.preferenceSchemaService.overrideIdentifiers.has(overrideIdentifier)) {
             return undefined;
         }
         const preferenceName = name.substring(index + 1);
@@ -74,7 +77,7 @@ export class PreferenceLanguageOverrideService {
 
     computeOverridePatternPropertiesKey(): string | undefined {
         let param: string = '';
-        for (const overrideIdentifier of this.overrideIdentifiers) {
+        for (const overrideIdentifier of this.preferenceSchemaService.overrideIdentifiers) {
             if (param.length) {
                 param += '|';
             }
@@ -84,28 +87,8 @@ export class PreferenceLanguageOverrideService {
     }
 
     *getOverridePreferenceNames(preferenceName: string): IterableIterator<string> {
-        for (const overrideIdentifier of this.overrideIdentifiers) {
+        for (const overrideIdentifier of this.preferenceSchemaService.overrideIdentifiers) {
             yield this.overridePreferenceName({ preferenceName, overrideIdentifier });
         }
     }
-
-    /**
-     * @param overrideIdentifier
-     * @returns true if the addition caused a change, i.e. if the identifier was not already present in the set of identifiers, false otherwise.
-     */
-    addOverrideIdentifier(overrideIdentifier: string): boolean {
-        const alreadyPresent = this.overrideIdentifiers.has(overrideIdentifier);
-        if (!alreadyPresent) {
-            this.overrideIdentifiers.add(overrideIdentifier);
-        }
-        return !alreadyPresent;
-    }
-
-    /**
-     * @param overrideIdentifier
-     * @returns true if the deletion caused a change, i.e. if the identifier was present in the set, false otherwise.
-     */
-    removeOverrideIdentifier(overrideIdentifier: string): boolean {
-        return this.overrideIdentifiers.delete(overrideIdentifier);
-    }
 }

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

@@ -0,0 +1,165 @@
+// *****************************************************************************
+// Copyright (C) 2018 Ericsson 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 debounce = require('p-debounce');
+import { injectable } from 'inversify';
+import { JSONObject } from '@lumino/coreutils';
+import URI from '../../common/uri';
+import { DisposableCollection, Emitter, Event, isObject, PreferenceLanguageOverrideService } from '../../common';
+import { Deferred } from '../../common/promise-util';
+import { PreferenceScope } from './preference-scope';
+import { PreferenceProvider, PreferenceProviderDataChange, PreferenceProviderDataChanges, PreferenceResolveResult } from './preference-provider';
+
+export abstract class PreferenceProviderBase {
+
+    protected readonly onDidPreferencesChangedEmitter = new Emitter<PreferenceProviderDataChanges>();
+    readonly onDidPreferencesChanged: Event<PreferenceProviderDataChanges> = this.onDidPreferencesChangedEmitter.event;
+
+    protected readonly toDispose = new DisposableCollection();
+
+    protected deferredChanges: PreferenceProviderDataChanges | undefined;
+
+    constructor() {
+        this.toDispose.push(this.onDidPreferencesChangedEmitter);
+    }
+
+    /**
+     * Informs the listeners that one or more preferences of this provider are changed.
+     * The listeners are able to find what was changed from the emitted event.
+     */
+    protected emitPreferencesChangedEvent(changes: PreferenceProviderDataChanges | PreferenceProviderDataChange[]): Promise<boolean> {
+        if (Array.isArray(changes)) {
+            for (const change of changes) {
+                this.mergePreferenceProviderDataChange(change);
+            }
+        } else {
+            for (const preferenceName of Object.keys(changes)) {
+                this.mergePreferenceProviderDataChange(changes[preferenceName]);
+            }
+        }
+        return this.fireDidPreferencesChanged();
+    }
+
+    protected mergePreferenceProviderDataChange(change: PreferenceProviderDataChange): void {
+        if (!this.deferredChanges) {
+            this.deferredChanges = {};
+        }
+        const current = this.deferredChanges[change.preferenceName];
+        const { newValue, scope, domain } = change;
+        if (!current) {
+            // new
+            this.deferredChanges[change.preferenceName] = change;
+        } else if (current.oldValue === newValue) {
+            // delete
+            delete this.deferredChanges[change.preferenceName];
+        } else {
+            // update
+            Object.assign(current, { newValue, scope, domain });
+        }
+    }
+
+    protected fireDidPreferencesChanged = debounce(() => {
+        const changes = this.deferredChanges;
+        this.deferredChanges = undefined;
+        if (changes && Object.keys(changes).length) {
+            this.onDidPreferencesChangedEmitter.fire(changes);
+            return true;
+        }
+        return false;
+    }, 0);
+
+    dispose(): void {
+        this.toDispose.dispose();
+    }
+
+}
+
+/**
+ * The {@link PreferenceProvider} is used to store and retrieve preference values. A {@link PreferenceProvider} does not operate in a global scope but is
+ * configured for one or more {@link PreferenceScope}s. The (default implementation for the) {@link PreferenceService} aggregates all {@link PreferenceProvider}s and
+ * serves as a common facade for manipulating preference values.
+ */
+@injectable()
+export abstract class PreferenceProviderImpl extends PreferenceProviderBase implements PreferenceProvider {
+
+    protected readonly _ready = new Deferred<void>();
+
+    constructor() {
+        super();
+    }
+
+    get<T>(preferenceName: string, resourceUri?: string): T | undefined {
+        return this.resolve<T>(preferenceName, resourceUri).value;
+    }
+
+    resolve<T>(preferenceName: string, resourceUri?: string): PreferenceResolveResult<T> {
+        const value = this.getPreferences(resourceUri)[preferenceName];
+        if (value !== undefined) {
+            return {
+                value: value as T,
+                configUri: this.getConfigUri(resourceUri)
+            };
+        }
+        return {};
+    }
+
+    abstract getPreferences(resourceUri?: string): JSONObject;
+    abstract setPreference(key: string, value: unknown, resourceUri?: string): Promise<boolean>;
+
+    /**
+     * Resolved when the preference provider is ready to provide preferences
+     * It should be resolved by subclasses.
+     */
+    get ready(): Promise<void> {
+        return this._ready.promise;
+    }
+
+    /**
+     * Retrieve the domain for this provider.
+     *
+     * @returns the domain or `undefined` if this provider is suitable for all domains.
+     */
+    getDomain(): string[] | undefined {
+        return undefined;
+    }
+
+    getConfigUri(resourceUri?: string, sectionName?: string): URI | undefined {
+        return undefined;
+    }
+
+    getContainingConfigUri?(resourceUri?: string, sectionName?: string): URI | undefined;
+
+    protected getParsedContent(jsonData: unknown): { [key: string]: unknown } {
+        const preferences: { [key: string]: unknown } = {};
+        if (!isObject(jsonData)) {
+            return preferences;
+        }
+        for (const [preferenceName, preferenceValue] of Object.entries(jsonData)) {
+            if (PreferenceLanguageOverrideService.testOverrideValue(preferenceName, preferenceValue)) {
+                for (const [overriddenPreferenceName, overriddenValue] of Object.entries(preferenceValue)) {
+                    preferences[`${preferenceName}.${overriddenPreferenceName}`] = overriddenValue;
+                }
+            } else {
+                preferences[preferenceName] = preferenceValue;
+            }
+        }
+        return preferences;
+    }
+
+    canHandleScope(scope: PreferenceScope): boolean {
+        return true;
+    }
+}

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

@@ -14,20 +14,21 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import { PreferenceProvider } from './preference-provider';
+import { PreferenceUtils } from './preference-provider';
+
 const { expect } = require('chai');
 
-describe('PreferenceProvider', () => {
+describe('PreferenceProviderImpl', () => {
     it('should preserve extra source fields on merge', () => {
-        const result = PreferenceProvider.merge({ 'configurations': [], 'compounds': [] }, { 'configurations': [] });
+        const result = PreferenceUtils.merge({ 'configurations': [], 'compounds': [] }, { 'configurations': [] });
         expect(result).deep.equals({ 'configurations': [], 'compounds': [] });
     });
     it('should preserve extra target fields on merge', () => {
-        const result = PreferenceProvider.merge({ 'configurations': [] }, { 'configurations': [], 'compounds': [] });
+        const result = PreferenceUtils.merge({ 'configurations': [] }, { 'configurations': [], 'compounds': [] });
         expect(result).deep.equals({ 'configurations': [], 'compounds': [] });
     });
     it('should merge array values', () => {
-        const result = PreferenceProvider.merge(
+        const result = PreferenceUtils.merge(
             { 'configurations': [{ 'name': 'test1', 'request': 'launch' }], 'compounds': [] },
             { 'configurations': [{ 'name': 'test2' }] }
         );