@theia/preferences 1.65.0-next.6 → 1.65.1

package/src/browser/preferences-json-schema-contribution.ts

@@ -17,20 +17,17 @@
 import { inject, injectable } from '@theia/core/shared/inversify';
 import URI from '@theia/core/lib/common/uri';
 import { JsonSchemaRegisterContext, JsonSchemaContribution, JsonSchemaDataStore } from '@theia/core/lib/browser/json-schema-store';
-import { PreferenceSchemaProvider } from '@theia/core/lib/browser/preferences/preference-contribution';
-import { PreferenceConfigurations } from '@theia/core/lib/browser/preferences/preference-configurations';
-import { PreferenceScope } from '@theia/core/lib/browser';
 import { WorkspaceService } from '@theia/workspace/lib/browser';
+import { PreferenceSchemaService, PreferenceConfigurations, PreferenceScope } from '@theia/core';
+import { UserStorageUri } from '@theia/userstorage/lib/browser';
 
 const PREFERENCE_URI_PREFIX = 'vscode://schemas/settings/';
-const USER_STORAGE_PREFIX = 'user-storage:/';
 
 @injectable()
 export class PreferencesJsonSchemaContribution implements JsonSchemaContribution {
-    protected serializeSchema = (scope: PreferenceScope) => JSON.stringify(this.schemaProvider.getSchema(scope));
 
-    @inject(PreferenceSchemaProvider)
-    protected readonly schemaProvider: PreferenceSchemaProvider;
+    @inject(PreferenceSchemaService)
+    protected readonly schemaProvider: PreferenceSchemaService;
 
     @inject(PreferenceConfigurations)
     protected readonly preferenceConfigurations: PreferenceConfigurations;
@@ -47,39 +44,39 @@ export class PreferencesJsonSchemaContribution implements JsonSchemaContribution
         this.registerSchema(PreferenceScope.Workspace, context);
         this.registerSchema(PreferenceScope.Folder, context);
 
+        context.registerSchema({
+            fileMatch: `file://**/${this.preferenceConfigurations.getConfigName()}.json`,
+            url: this.getSchemaURIForScope(PreferenceScope.Folder).toString()
+        });
+
+        context.registerSchema({
+            fileMatch: UserStorageUri.resolve(this.preferenceConfigurations.getConfigName() + '.json').toString(),
+            url: this.getSchemaURIForScope(PreferenceScope.User).toString()
+        });
+
         this.workspaceService.updateSchema('settings', { $ref: this.getSchemaURIForScope(PreferenceScope.Workspace).toString() });
-        this.schemaProvider.onDidPreferenceSchemaChanged(() => this.updateInMemoryResources());
+        this.schemaProvider.onDidChangeSchema(() => this.updateInMemoryResources());
     }
 
     protected registerSchema(scope: PreferenceScope, context: JsonSchemaRegisterContext): void {
         const scopeStr = PreferenceScope[scope].toLowerCase();
         const uri = new URI(PREFERENCE_URI_PREFIX + scopeStr);
 
-        this.jsonSchemaData.setSchema(uri, this.serializeSchema(scope));
-
-        context.registerSchema({
-            fileMatch: this.getFileMatch(scopeStr),
-            url: uri.toString()
-        });
+        this.jsonSchemaData.setSchema(uri, (this.schemaProvider.getJSONSchema(scope)));
     }
 
     protected updateInMemoryResources(): void {
         this.jsonSchemaData.setSchema(this.getSchemaURIForScope(PreferenceScope.Default),
-            this.serializeSchema(+PreferenceScope.Default));
+            (this.schemaProvider.getJSONSchema(PreferenceScope.Default)));
         this.jsonSchemaData.setSchema(this.getSchemaURIForScope(PreferenceScope.User),
-            this.serializeSchema(+PreferenceScope.User));
+            this.schemaProvider.getJSONSchema(PreferenceScope.User));
         this.jsonSchemaData.setSchema(this.getSchemaURIForScope(PreferenceScope.Workspace),
-            this.serializeSchema(+PreferenceScope.Workspace));
+            this.schemaProvider.getJSONSchema(PreferenceScope.Workspace));
         this.jsonSchemaData.setSchema(this.getSchemaURIForScope(PreferenceScope.Folder),
-            this.serializeSchema(+PreferenceScope.Folder));
+            this.schemaProvider.getJSONSchema(PreferenceScope.Folder));
     }
 
     protected getSchemaURIForScope(scope: PreferenceScope): URI {
         return new URI(PREFERENCE_URI_PREFIX + PreferenceScope[scope].toLowerCase());
     }
-
-    protected getFileMatch(scope: string): string[] {
-        const baseName = this.preferenceConfigurations.getConfigName() + '.json';
-        return [baseName, new URI(USER_STORAGE_PREFIX + scope).resolve(baseName).toString()];
-    }
 }

package/src/browser/util/preference-scope-command-manager.ts

@@ -15,9 +15,9 @@
 // *****************************************************************************
 
 import { injectable, inject } from '@theia/core/shared/inversify';
-import { PreferenceScope, LabelProvider, codicon } from '@theia/core/lib/browser';
+import { LabelProvider, codicon } from '@theia/core/lib/browser';
 import { FileStat } from '@theia/filesystem/lib/common/files';
-import { CommandRegistry, MenuModelRegistry, Command } from '@theia/core/lib/common';
+import { CommandRegistry, MenuModelRegistry, Command, PreferenceScope } from '@theia/core/lib/common';
 import { Preference, PreferenceMenus } from './preference-types';
 
 /**

package/src/browser/util/preference-tree-generator.ts

@@ -15,9 +15,8 @@
 // *****************************************************************************
 
 import { inject, injectable, postConstruct } from '@theia/core/shared/inversify';
-import { CompositeTreeNode, PreferenceSchemaProvider, OVERRIDE_PROPERTY_PATTERN, PreferenceDataProperty } from '@theia/core/lib/browser';
-import { PreferenceConfigurations } from '@theia/core/lib/browser/preferences/preference-configurations';
-import { Emitter } from '@theia/core';
+import { CompositeTreeNode } from '@theia/core/lib/browser';
+import { Emitter, OVERRIDE_PROPERTY_PATTERN, PreferenceConfigurations, PreferenceDataProperty, PreferenceSchemaService } from '@theia/core';
 import debounce = require('@theia/core/shared/lodash.debounce');
 import { Preference } from './preference-types';
 import { COMMONLY_USED_SECTION_PREFIX, PreferenceLayoutProvider } from './preference-layout';
@@ -35,7 +34,7 @@ export interface CreatePreferencesGroupOptions {
 @injectable()
 export class PreferenceTreeGenerator {
 
-    @inject(PreferenceSchemaProvider) protected readonly schemaProvider: PreferenceSchemaProvider;
+    @inject(PreferenceSchemaService) protected readonly schemaProvider: PreferenceSchemaService;
     @inject(PreferenceConfigurations) protected readonly preferenceConfigs: PreferenceConfigurations;
     @inject(PreferenceLayoutProvider) protected readonly layoutProvider: PreferenceLayoutProvider;
     @inject(PreferenceTreeLabelProvider) protected readonly labelProvider: PreferenceTreeLabelProvider;
@@ -57,15 +56,13 @@ export class PreferenceTreeGenerator {
     }
 
     protected async doInit(): Promise<void> {
-        await this.schemaProvider.ready;
-        this.schemaProvider.onDidPreferenceSchemaChanged(() => this.handleChangedSchema());
+        this.schemaProvider.onDidChangeSchema(() => this.handleChangedSchema());
         this.handleChangedSchema();
     }
 
     generateTree(): CompositeTreeNode {
         this._idCache.clear();
-        const preferencesSchema = this.schemaProvider.getCombinedSchema();
-        const propertyNames = Object.keys(preferencesSchema.properties);
+        const properties = this.schemaProvider.getSchemaProperties();
         const groups = new Map<string, Preference.CompositeTreeNode>();
         const root = this.createRootNode();
 
@@ -88,12 +85,11 @@ export class PreferenceTreeGenerator {
             });
         }
         for (const preference of commonlyUsedLayout.settings ?? []) {
-            if (preference in preferencesSchema.properties) {
-                this.createLeafNode(preference, commonlyUsed, preferencesSchema.properties[preference]);
+            if (properties.has(preference)) {
+                this.createLeafNode(preference, commonlyUsed, properties.get(preference)!);
             }
         }
-        for (const propertyName of propertyNames) {
-            const property = preferencesSchema.properties[propertyName];
+        for (const [propertyName, property] of properties.entries()) {
             if (!property.hidden && !property.deprecationMessage && !this.preferenceConfigs.isSectionName(propertyName) && !OVERRIDE_PROPERTY_PATTERN.test(propertyName)) {
                 if (property.owner) {
                     this.createPluginLeafNode(propertyName, property, root, groups);

package/src/browser/util/preference-types.ts

@@ -15,15 +15,12 @@
 // *****************************************************************************
 
 import {
-    PreferenceDataProperty,
-    PreferenceScope,
     TreeNode as BaseTreeNode,
     CompositeTreeNode as BaseCompositeTreeNode,
     SelectableTreeNode,
-    PreferenceInspection,
     CommonCommands,
-    } from '@theia/core/lib/browser';
-import { Command, MenuPath } from '@theia/core';
+} from '@theia/core/lib/browser';
+import { Command, MenuPath, PreferenceDataProperty, PreferenceInspection, PreferenceScope } from '@theia/core';
 import { JSONValue } from '@theia/core/shared/@lumino/coreutils';
 import { JsonType } from '@theia/core/lib/common/json-schema';
 

package/src/browser/views/components/preference-node-renderer.ts

@@ -16,13 +16,12 @@
 
 import { injectable, inject, postConstruct } from '@theia/core/shared/inversify';
 import {
-    PreferenceService, ContextMenuRenderer, PreferenceInspection,
-    PreferenceScope, PreferenceProvider, codicon, OpenerService, open, PreferenceDataProperty
+    ContextMenuRenderer, codicon, OpenerService, open
 } from '@theia/core/lib/browser';
 import { Preference, PreferenceMenus } from '../../util/preference-types';
 import { PreferenceTreeLabelProvider } from '../../util/preference-tree-label-provider';
 import { PreferencesScopeTabBar } from '../preference-scope-tabbar-widget';
-import { Disposable, nls } from '@theia/core/lib/common';
+import { Disposable, nls, PreferenceDataProperty, PreferenceInspection, PreferenceScope, PreferenceService, PreferenceUtils } from '@theia/core/lib/common';
 import { JSONValue } from '@theia/core/shared/@lumino/coreutils';
 import debounce = require('@theia/core/shared/lodash.debounce');
 import { PreferenceTreeModel } from '../../preference-tree-model';
@@ -260,7 +259,7 @@ export abstract class PreferenceLeafNodeRenderer<ValueType extends JSONValue, In
     }
 
     protected handleCogAction({ currentTarget }: KeyboardEvent | MouseEvent): void {
-        const value = Preference.getValueInScope(this.inspection, this.scopeTracker.currentScope.scope) ?? this.inspection?.defaultValue;
+        const value = Preference.getValueInScope(this.inspection, this.scopeTracker.currentScope.scope) ?? this.getDefaultValue();
         const target = currentTarget as HTMLElement | undefined;
         if (target && value !== undefined) {
             this.showCog();
@@ -295,7 +294,7 @@ export abstract class PreferenceLeafNodeRenderer<ValueType extends JSONValue, In
         const wasModified = this.isModifiedFromDefault;
         const { inspection } = this;
         const valueInCurrentScope = knownCurrentValue ?? Preference.getValueInScope(inspection, this.scopeTracker.currentScope.scope);
-        this.isModifiedFromDefault = valueInCurrentScope !== undefined && !PreferenceProvider.deepEqual(valueInCurrentScope, inspection?.defaultValue);
+        this.isModifiedFromDefault = valueInCurrentScope !== undefined && !PreferenceUtils.deepEqual(valueInCurrentScope, this.getDefaultValue());
         if (wasModified !== this.isModifiedFromDefault) {
             this.gutter.classList.toggle('theia-mod-item-modified', this.isModifiedFromDefault);
         }
@@ -422,7 +421,7 @@ export abstract class PreferenceLeafNodeRenderer<ValueType extends JSONValue, In
             for (const otherScope of [PreferenceScope.User, PreferenceScope.Workspace]) {
                 if (otherScope !== currentScopeInView) {
                     const valueInOtherScope = Preference.getValueInScope(inspection, otherScope);
-                    if (valueInOtherScope !== undefined && !PreferenceProvider.deepEqual(valueInOtherScope, inspection.defaultValue)) {
+                    if (valueInOtherScope !== undefined && !PreferenceUtils.deepEqual(valueInOtherScope, this.getDefaultValue())) {
                         modifiedScopes.push(otherScope);
                     }
                 }
@@ -435,9 +434,9 @@ export abstract class PreferenceLeafNodeRenderer<ValueType extends JSONValue, In
     protected getValue(): ValueType | null {
         let currentValue = Preference.getValueInScope(this.inspection, this.scopeTracker.currentScope.scope);
         if (currentValue === undefined) {
-            currentValue = this.inspection?.defaultValue;
+            currentValue = this.getDefaultValue();
         }
-        return currentValue !== undefined ? currentValue : this.getFallbackValue();
+        return currentValue;
     }
 
     protected setPreferenceWithDebounce = debounce(this.setPreferenceImmediately.bind(this), 500, { leading: false, trailing: true });
@@ -461,6 +460,14 @@ export abstract class PreferenceLeafNodeRenderer<ValueType extends JSONValue, In
         this.updateHeadline();
     }
 
+    /**
+     * Returns the default value for this preference.
+     * @returns The default value from the inspection or the fallback value if no default is specified.
+     */
+    protected getDefaultValue(): ValueType {
+        return this.inspection?.defaultValue ?? this.getFallbackValue();
+    }
+
     /**
      * Should create an HTML element that the user can interact with to change the value of the preference.
      * @param container the parent element for the interactable. This method is responsible for adding the new element to its parent.

package/src/browser/views/components/preference-select-input.ts

@@ -17,13 +17,13 @@
 import { PreferenceLeafNodeRenderer, PreferenceNodeRenderer } from './preference-node-renderer';
 import { injectable, interfaces } from '@theia/core/shared/inversify';
 import { JSONValue } from '@theia/core/shared/@lumino/coreutils';
-import { PreferenceProvider } from '@theia/core/lib/browser/preferences/preference-provider';
 import { SelectComponent, SelectOption } from '@theia/core/lib/browser/widgets/select-component';
 import { Preference } from '../../util/preference-types';
 import { PreferenceLeafNodeRendererContribution } from './preference-node-renderer-creator';
 import * as React from '@theia/core/shared/react';
 import { createRoot } from '@theia/core/shared/react-dom/client';
 import { escapeInvisibleChars } from '@theia/core/lib/common/strings';
+import { PreferenceUtils } from '@theia/core';
 
 @injectable()
 export class PreferenceSelectInputRenderer extends PreferenceLeafNodeRenderer<JSONValue, HTMLDivElement> {
@@ -45,7 +45,7 @@ export class PreferenceSelectInputRenderer extends PreferenceLeafNodeRenderer<JS
             const value = values[i];
             const stringValue = `${value}`;
             const label = escapeInvisibleChars(preferenceData.enumItemLabels?.[i] ?? stringValue);
-            const detail = PreferenceProvider.deepEqual(defaultValue, value) ? 'default' : undefined;
+            const detail = PreferenceUtils.deepEqual(defaultValue, value) ? 'default' : undefined;
             let enumDescription = preferenceData.enumDescriptions?.[i];
             let markdown = false;
             const markdownEnumDescription = preferenceData.markdownEnumDescriptions?.[i];
@@ -80,11 +80,8 @@ export class PreferenceSelectInputRenderer extends PreferenceLeafNodeRenderer<JS
     }
 
     protected getFallbackValue(): JSONValue {
-        const { default: schemaDefault, defaultValue, enum: enumValues } = this.preferenceNode.preference.data;
-        return schemaDefault !== undefined
-            ? schemaDefault : defaultValue !== undefined
-                ? defaultValue
-                : enumValues![0];
+        const { default: schemaDefault, enum: enumValues } = this.preferenceNode.preference.data;
+        return schemaDefault !== undefined ? schemaDefault : enumValues![0];
     }
 
     protected doHandleValueChange(): void {
@@ -102,10 +99,10 @@ export class PreferenceSelectInputRenderer extends PreferenceLeafNodeRenderer<JS
      */
     protected getDataValue(): number {
         const currentValue = this.getValue();
-        let selected = this.enumValues.findIndex(value => PreferenceProvider.deepEqual(value, currentValue));
+        let selected = this.enumValues.findIndex(value => PreferenceUtils.deepEqual(value, currentValue));
         if (selected === -1) {
             const fallback = this.getFallbackValue();
-            selected = this.enumValues.findIndex(value => PreferenceProvider.deepEqual(value, fallback));
+            selected = this.enumValues.findIndex(value => PreferenceUtils.deepEqual(value, fallback));
         }
         return Math.max(selected, 0);
     }

package/src/browser/views/preference-editor-widget.ts

@@ -19,16 +19,13 @@ import { postConstruct, injectable, inject } from '@theia/core/shared/inversify'
 import throttle = require('@theia/core/shared/lodash.throttle');
 import * as deepEqual from 'fast-deep-equal';
 import {
-    PreferenceService,
     CompositeTreeNode,
     SelectableTreeNode,
     StatefulWidget,
     TopDownTreeIterator,
-    PreferenceChanges,
     ExpandableTreeNode,
-    PreferenceSchemaProvider,
 } from '@theia/core/lib/browser';
-import { unreachable } from '@theia/core/lib/common';
+import { PreferenceChanges, PreferenceSchemaService, PreferenceService, unreachable } from '@theia/core/lib/common';
 import { BaseWidget, DEFAULT_SCROLL_OPTIONS } from '@theia/core/lib/browser/widgets/widget';
 import { PreferenceTreeModel, PreferenceFilterChangeEvent, PreferenceFilterChangeSource } from '../preference-tree-model';
 import { PreferenceNodeRendererFactory, GeneralPreferenceNodeRenderer } from './components/preference-node-renderer';
@@ -68,7 +65,7 @@ export class PreferencesEditorWidget extends BaseWidget implements StatefulWidge
     @inject(PreferenceTreeModel) protected readonly model: PreferenceTreeModel;
     @inject(PreferenceNodeRendererFactory) protected readonly rendererFactory: PreferenceNodeRendererFactory;
     @inject(PreferenceNodeRendererCreatorRegistry) protected readonly rendererRegistry: PreferenceNodeRendererCreatorRegistry;
-    @inject(PreferenceSchemaProvider) protected readonly schemaProvider: PreferenceSchemaProvider;
+    @inject(PreferenceSchemaService) protected readonly schemaProvider: PreferenceSchemaService;
     @inject(PreferencesScopeTabBar) protected readonly tabbar: PreferencesScopeTabBar;
 
     @postConstruct()

package/src/browser/views/preference-scope-tabbar-widget.tsx

@@ -16,13 +16,13 @@
 
 import { inject, injectable, postConstruct } from '@theia/core/shared/inversify';
 import { TabBar, Widget, Title } from '@theia/core/shared/@lumino/widgets';
-import { PreferenceScope, Message, ContextMenuRenderer, LabelProvider, StatefulWidget, codicon } from '@theia/core/lib/browser';
+import { Message, ContextMenuRenderer, LabelProvider, StatefulWidget, codicon } from '@theia/core/lib/browser';
 import { WorkspaceService } from '@theia/workspace/lib/browser/workspace-service';
 import URI from '@theia/core/lib/common/uri';
 import { FileStat } from '@theia/filesystem/lib/common/files';
 import { PreferenceScopeCommandManager } from '../util/preference-scope-command-manager';
 import { Preference, PreferenceMenus } from '../util/preference-types';
-import { CommandRegistry, DisposableCollection, Emitter, MenuModelRegistry } from '@theia/core/lib/common';
+import { CommandRegistry, DisposableCollection, Emitter, MenuModelRegistry, PreferenceScope } from '@theia/core/lib/common';
 import { nls } from '@theia/core/lib/common/nls';
 
 const USER_TAB_LABEL = nls.localizeByDefault('User');

package/src/browser/views/preference-widget.tsx

@@ -15,7 +15,7 @@
 // *****************************************************************************
 
 import { postConstruct, injectable, inject } from '@theia/core/shared/inversify';
-import { Panel, Widget, Message, StatefulWidget, PreferenceScope, codicon } from '@theia/core/lib/browser';
+import { Panel, Widget, Message, StatefulWidget, codicon } from '@theia/core/lib/browser';
 import { PreferencesEditorState, PreferencesEditorWidget } from './preference-editor-widget';
 import { PreferencesTreeWidget } from './preference-tree-widget';
 import { PreferencesSearchbarState, PreferencesSearchbarWidget } from './preference-searchbar-widget';
@@ -23,6 +23,7 @@ import { PreferencesScopeTabBar, PreferencesScopeTabBarState } from './preferenc
 import { Preference } from '../util/preference-types';
 import URI from '@theia/core/lib/common/uri';
 import { nls } from '@theia/core/lib/common/nls';
+import { PreferenceScope } from '@theia/core';
 
 interface PreferencesWidgetState {
     scopeTabBarState: PreferencesScopeTabBarState,

package/src/browser/workspace-file-preference-provider.ts

@@ -16,9 +16,9 @@
 
 import { inject, injectable } from '@theia/core/shared/inversify';
 import URI from '@theia/core/lib/common/uri';
-import { PreferenceScope } from '@theia/core/lib/browser/preferences';
+import { PreferenceScope } from '@theia/core/lib/common/preferences';
 import { WorkspaceService, WorkspaceData } from '@theia/workspace/lib/browser/workspace-service';
-import { AbstractResourcePreferenceProvider } from './abstract-resource-preference-provider';
+import { AbstractResourcePreferenceProvider } from '../common/abstract-resource-preference-provider';
 
 @injectable()
 export class WorkspaceFilePreferenceProviderOptions {

package/src/browser/workspace-preference-provider.ts

@@ -16,15 +16,17 @@
 
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
-import { inject, injectable, postConstruct, named } from '@theia/core/shared/inversify';
+import { inject, injectable, postConstruct } from '@theia/core/shared/inversify';
 import URI from '@theia/core/lib/common/uri';
 import { DisposableCollection } from '@theia/core/lib/common/disposable';
-import { PreferenceScope, PreferenceProvider } from '@theia/core/lib/browser/preferences';
 import { WorkspaceService } from '@theia/workspace/lib/browser/workspace-service';
 import { WorkspaceFilePreferenceProviderFactory, WorkspaceFilePreferenceProvider } from './workspace-file-preference-provider';
+import { Deferred } from '@theia/core/lib/common/promise-util';
+import { Emitter, Event, PreferenceProvider, PreferenceProviderDataChanges, PreferenceProviderProvider, PreferenceScope } from '@theia/core';
+import { JSONObject } from '@theia/core/shared/@lumino/coreutils';
 
 @injectable()
-export class WorkspacePreferenceProvider extends PreferenceProvider {
+export class WorkspacePreferenceProvider implements PreferenceProvider {
 
     @inject(WorkspaceService)
     protected readonly workspaceService: WorkspaceService;
@@ -32,11 +34,19 @@ export class WorkspacePreferenceProvider extends PreferenceProvider {
     @inject(WorkspaceFilePreferenceProviderFactory)
     protected readonly workspaceFileProviderFactory: WorkspaceFilePreferenceProviderFactory;
 
-    @inject(PreferenceProvider) @named(PreferenceScope.Folder)
-    protected readonly folderPreferenceProvider: PreferenceProvider;
+    @inject(PreferenceProviderProvider)
+    protected readonly preferenceProviderProvider: PreferenceProviderProvider;
+
+    protected readonly onDidPreferencesChangedEmitter = new Emitter<PreferenceProviderDataChanges>();
+    readonly onDidPreferencesChanged: Event<PreferenceProviderDataChanges> = this.onDidPreferencesChangedEmitter.event;
 
     protected readonly toDisposeOnEnsureDelegateUpToDate = new DisposableCollection();
 
+    protected _ready = new Deferred<void>();
+    readonly ready = this._ready.promise;
+
+    protected readonly disposables = new DisposableCollection();
+
     @postConstruct()
     protected init(): void {
         this.workspaceService.ready.then(() => {
@@ -46,15 +56,23 @@ export class WorkspacePreferenceProvider extends PreferenceProvider {
                 this._ready.resolve();
             }
         });
-        this.workspaceService.onWorkspaceLocationChanged(() => this.ensureDelegateUpToDate());
-        this.workspaceService.onWorkspaceChanged(() => this.ensureDelegateUpToDate());
+        this.disposables.push(this.workspaceService.onWorkspaceLocationChanged(() => this.ensureDelegateUpToDate()));
+        this.disposables.push(this.workspaceService.onWorkspaceChanged(() => this.ensureDelegateUpToDate()));
+    }
+
+    dispose(): void {
+        this.disposables.dispose();
+    }
+
+    canHandleScope(scope: PreferenceScope): boolean {
+        return true;
     }
 
-    override getConfigUri(resourceUri: string | undefined = this.ensureResourceUri(), sectionName?: string): URI | undefined {
-        return this.delegate?.getConfigUri(resourceUri, sectionName);
+    getConfigUri(resourceUri: string | undefined = this.ensureResourceUri(), sectionName?: string): URI | undefined {
+        return this.delegate?.getConfigUri && this.delegate?.getConfigUri(resourceUri, sectionName);
     }
 
-    override getContainingConfigUri(resourceUri: string | undefined = this.ensureResourceUri(), sectionName?: string): URI | undefined {
+    getContainingConfigUri(resourceUri: string | undefined = this.ensureResourceUri(), sectionName?: string): URI | undefined {
         return this.delegate?.getContainingConfigUri?.(resourceUri, sectionName);
     }
 
@@ -67,7 +85,7 @@ export class WorkspacePreferenceProvider extends PreferenceProvider {
         const delegate = this.createDelegate();
         if (this._delegate !== delegate) {
             this.toDisposeOnEnsureDelegateUpToDate.dispose();
-            this.toDispose.push(this.toDisposeOnEnsureDelegateUpToDate);
+            this.disposables.push(this.toDisposeOnEnsureDelegateUpToDate);
 
             this._delegate = delegate;
 
@@ -91,7 +109,7 @@ export class WorkspacePreferenceProvider extends PreferenceProvider {
             return undefined;
         }
         if (!this.workspaceService.isMultiRootWorkspaceOpened) {
-            return this.folderPreferenceProvider;
+            return this.preferenceProviderProvider(PreferenceScope.Folder);
         }
         if (this._delegate instanceof WorkspaceFilePreferenceProvider && this._delegate.getConfigUri().isEqual(workspace.resource)) {
             return this._delegate;
@@ -101,21 +119,16 @@ export class WorkspacePreferenceProvider extends PreferenceProvider {
         });
     }
 
-    override get<T>(preferenceName: string, resourceUri: string | undefined = this.ensureResourceUri()): T | undefined {
+    get<T>(preferenceName: string, resourceUri: string | undefined = this.ensureResourceUri()): T | undefined {
         const delegate = this.delegate;
         return delegate ? delegate.get<T>(preferenceName, resourceUri) : undefined;
     }
 
-    override resolve<T>(preferenceName: string, resourceUri: string | undefined = this.ensureResourceUri()): { value?: T, configUri?: URI } {
+    resolve<T>(preferenceName: string, resourceUri: string | undefined = this.ensureResourceUri()): { value?: T, configUri?: URI } {
         const delegate = this.delegate;
         return delegate ? delegate.resolve<T>(preferenceName, resourceUri) : {};
     }
 
-    getPreferences(resourceUri: string | undefined = this.ensureResourceUri()): { [p: string]: any } {
-        const delegate = this.delegate;
-        return delegate ? delegate.getPreferences(resourceUri) : {};
-    }
-
     async setPreference(preferenceName: string, value: any, resourceUri: string | undefined = this.ensureResourceUri()): Promise<boolean> {
         const delegate = this.delegate;
         if (delegate) {
@@ -124,6 +137,11 @@ export class WorkspacePreferenceProvider extends PreferenceProvider {
         return false;
     }
 
+    getPreferences(resourceUri: string | undefined = this.ensureResourceUri()): JSONObject {
+        const delegate = this.delegate;
+        return delegate ? delegate.getPreferences(resourceUri) : {};
+    }
+
     protected ensureResourceUri(): string | undefined {
         if (this.workspaceService.workspace && !this.workspaceService.isMultiRootWorkspaceOpened) {
             return this.workspaceService.workspace.resource.toString();

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

@@ -24,32 +24,31 @@ FrontendApplicationConfigProvider.set({});
 
 import { expect } from 'chai';
 import { Container } from '@theia/core/shared/inversify';
-import { AbstractResourcePreferenceProvider } from './abstract-resource-preference-provider';
-import { FileService } from '@theia/filesystem/lib/browser/file-service';
+import { AbstractResourcePreferenceProvider, FileContentStatus, PreferenceStorage, PreferenceStorageFactory } from './abstract-resource-preference-provider';
 import { bindPreferenceService } from '@theia/core/lib/browser/frontend-application-bindings';
 import { bindMockPreferenceProviders } from '@theia/core/lib/browser/preferences/test';
 import { Deferred } from '@theia/core/lib/common/promise-util';
-import { Disposable, MessageService } from '@theia/core/lib/common';
+import { Listener, MessageService, PreferenceSchemaService } from '@theia/core/lib/common';
 import { MonacoWorkspace } from '@theia/monaco/lib/browser/monaco-workspace';
-import { PreferenceSchemaProvider } from '@theia/core/lib/browser';
 import { EditorManager } from '@theia/editor/lib/browser';
-import { PreferenceTransactionFactory } from './preference-transaction-manager';
+import { PreferenceTransactionFactory } from '../browser/preference-transaction-manager';
+import { JSONValue } from '@theia/core/shared/@lumino/coreutils';
 
 disableJSDOM();
 
-class MockFileService {
+class MockPreferenceStorage implements PreferenceStorage {
+    onDidChangeFileContent: Listener.Registration<FileContentStatus, Promise<boolean>> = Listener.None as unknown as Listener.Registration<FileContentStatus, Promise<boolean>>;
+    writeValue(key: string, path: string[], value: JSONValue): Promise<boolean> {
+        throw new Error('Method not implemented.');
+    }
+    dispose(): void { }
     releaseContent = new Deferred();
-    async read(): Promise<{ value: string }> {
+    async read(): Promise<string> {
         await this.releaseContent.promise;
-        return { value: JSON.stringify({ 'editor.fontSize': 20 }) };
+        return JSON.stringify({ 'editor.fontSize': 20 });
     }
-    watch = RETURN_DISPOSABLE;
-    onDidFilesChange = RETURN_DISPOSABLE;
 }
-
-const RETURN_DISPOSABLE = () => Disposable.NULL;
-
-const mockSchemaProvider = { getCombinedSchema: () => ({ properties: {} }) };
+const mockSchemaProvider = { getSchemaProperty: () => undefined };
 
 class LessAbstractPreferenceProvider extends AbstractResourcePreferenceProvider {
     getUri(): any { }
@@ -58,15 +57,15 @@ class LessAbstractPreferenceProvider extends AbstractResourcePreferenceProvider
 
 describe('AbstractResourcePreferenceProvider', () => {
     let provider: AbstractResourcePreferenceProvider;
-    let fileService: MockFileService;
+    let preferenceStorage: MockPreferenceStorage;
 
     beforeEach(() => {
-        fileService = new MockFileService();
+        preferenceStorage = new MockPreferenceStorage();
         const testContainer = new Container();
         bindPreferenceService(testContainer.bind.bind(testContainer));
         bindMockPreferenceProviders(testContainer.bind.bind(testContainer), testContainer.unbind.bind(testContainer));
-        testContainer.rebind(<any>PreferenceSchemaProvider).toConstantValue(mockSchemaProvider);
-        testContainer.bind(<any>FileService).toConstantValue(fileService);
+        testContainer.rebind(<any>PreferenceSchemaService).toConstantValue(mockSchemaProvider);
+        testContainer.bind(<any>PreferenceStorageFactory).toFactory(() => () => preferenceStorage);
         testContainer.bind(<any>MessageService).toConstantValue(undefined);
         testContainer.bind(<any>MonacoWorkspace).toConstantValue(undefined);
         testContainer.bind(<any>EditorManager).toConstantValue(undefined);
@@ -81,14 +80,14 @@ describe('AbstractResourcePreferenceProvider', () => {
         expect(provider.get('editor.fontSize')).to.be.undefined;
 
         resolveWhenFinished.resolve();
-        fileService.releaseContent.resolve(); // Allow the initialization to run
+        preferenceStorage.releaseContent.resolve(); // Allow the initialization to run
 
         // This promise would reject if the provider had declared itself ready before we resolve `resolveWhenFinished`
         await Promise.race([resolveWhenFinished.promise, errorIfReadyFirst]);
     });
 
     it('should report values in file when `ready` resolves.', async () => {
-        fileService.releaseContent.resolve();
+        preferenceStorage.releaseContent.resolve();
         await provider.ready;
         expect(provider.get('editor.fontSize')).to.equal(20); // The value provided by the mock FileService implementation.
     });