@theia/preferences 1.65.0-next.6 → 1.65.0

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';
@@ -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, inspection?.defaultValue);
         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, inspection.defaultValue)) {
                         modifiedScopes.push(otherScope);
                     }
                 }

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.
     });

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

@@ -20,21 +20,52 @@
 import * as jsoncparser from 'jsonc-parser';
 import { inject, injectable, postConstruct } from '@theia/core/shared/inversify';
 import { Disposable } from '@theia/core/lib/common/disposable';
-import { PreferenceProvider, PreferenceSchemaProvider, PreferenceScope, PreferenceProviderDataChange } from '@theia/core/lib/browser';
+import {
+    PreferenceProviderImpl, PreferenceScope, PreferenceProviderDataChange, PreferenceSchemaService,
+    PreferenceConfigurations, PreferenceUtils, PreferenceLanguageOverrideService,
+    Listener
+} from '@theia/core/lib/common';
 import URI from '@theia/core/lib/common/uri';
-import { PreferenceConfigurations } from '@theia/core/lib/browser/preferences/preference-configurations';
 import { Deferred } from '@theia/core/lib/common/promise-util';
-import { FileService } from '@theia/filesystem/lib/browser/file-service';
-import { PreferenceContext, PreferenceTransaction, PreferenceTransactionFactory } from './preference-transaction-manager';
 import { Emitter, Event } from '@theia/core';
+import { JSONValue } from '@theia/core/shared/@lumino/coreutils';
+export interface FileContentStatus {
+    content: string;
+    fileOK: boolean
+}
+/**
+ * Abtracts the way to read and write preferences to a given resource
+ */
+export interface PreferenceStorage extends Disposable {
+    /**
+     * Write a value to the underlying preference store
+     * @param key the preference key
+     * @param path the path to the JSON object to change
+     * @param value the new preference value
+     * @returns a promise that will resolve when all "onStored" listeners have finished
+     */
+    writeValue(key: string, path: string[], value: JSONValue): Promise<boolean>;
+    /**
+     * List of listeners that will get a string with the newly stored resource content and should return a promise that resolves when
+     * they are done with their processing
+     */
+    onDidChangeFileContent: Listener.Registration<FileContentStatus, Promise<boolean>>;
+    /**
+     * Reds the content of the underlying resource
+     */
+    read(): Promise<string>;
+};
+
+export const PreferenceStorageFactory = Symbol('PreferenceStorageFactory');
+export type PreferenceStorageFactory = (uri: URI, scope: PreferenceScope) => PreferenceStorage;
 
 @injectable()
-export abstract class AbstractResourcePreferenceProvider extends PreferenceProvider {
+export abstract class AbstractResourcePreferenceProvider extends PreferenceProviderImpl {
+    protected preferenceStorage: PreferenceStorage;
 
     protected preferences: Record<string, any> = {};
     protected _fileExists = false;
     protected readonly loading = new Deferred();
-    protected transaction: PreferenceTransaction | undefined;
     protected readonly onDidChangeValidityEmitter = new Emitter<boolean>();
 
     set fileExists(exists: boolean) {
@@ -48,10 +79,14 @@ export abstract class AbstractResourcePreferenceProvider extends PreferenceProvi
         return this.onDidChangeValidityEmitter.event;
     }
 
-    @inject(PreferenceTransactionFactory) protected readonly transactionFactory: PreferenceTransactionFactory;
-    @inject(PreferenceSchemaProvider) protected readonly schemaProvider: PreferenceSchemaProvider;
-    @inject(FileService) protected readonly fileService: FileService;
-    @inject(PreferenceConfigurations) protected readonly configurations: PreferenceConfigurations;
+    @inject(PreferenceSchemaService)
+    protected readonly schemaProvider: PreferenceSchemaService;
+    @inject(PreferenceConfigurations)
+    protected readonly configurations: PreferenceConfigurations;
+    @inject(PreferenceLanguageOverrideService)
+    protected readonly preferenceOverrideService: PreferenceLanguageOverrideService;
+    @inject(PreferenceStorageFactory)
+    protected readonly preferenceStorageFactory: PreferenceStorageFactory;
 
     @postConstruct()
     protected init(): void {
@@ -61,17 +96,19 @@ export abstract class AbstractResourcePreferenceProvider extends PreferenceProvi
     protected async doInit(): Promise<void> {
         const uri = this.getUri();
         this.toDispose.push(Disposable.create(() => this.loading.reject(new Error(`Preference provider for '${uri}' was disposed.`))));
+
+        this.preferenceStorage = this.preferenceStorageFactory(uri, this.getScope());
+        this.preferenceStorage.onDidChangeFileContent(async ({ content, fileOK }) => {
+            this.fileExists = fileOK;
+            this.readPreferencesFromContent(content);
+            await this.fireDidPreferencesChanged(); // Ensure all consumers of the event have received it.¨
+            return true;
+        });
         await this.readPreferencesFromFile();
         this._ready.resolve();
         this.loading.resolve();
-        const storageUri = this.toFileManager().getConfigUri();
+
         this.toDispose.pushAll([
-            this.fileService.watch(storageUri),
-            this.fileService.onDidFilesChange(e => {
-                if (e.contains(storageUri)) {
-                    this.readPreferencesFromFile();
-                }
-            }),
             Disposable.create(() => this.reset()),
         ]);
     }
@@ -116,30 +153,8 @@ export abstract class AbstractResourcePreferenceProvider extends PreferenceProvi
         return this.doSetPreference(key, path, value);
     }
 
-    protected async doSetPreference(key: string, path: string[], value: unknown): Promise<boolean> {
-        if (!this.transaction?.open) {
-            const current = this.transaction;
-            this.transaction = this.transactionFactory(this.toFileManager(), current?.result);
-            this.transaction.onWillConclude(({ status, waitUntil }) => {
-                if (status) {
-                    waitUntil((async () => {
-                        await this.readPreferencesFromFile();
-                        await this.fireDidPreferencesChanged(); // Ensure all consumers of the event have received it.
-                    })());
-                }
-            });
-            this.toDispose.push(this.transaction);
-        }
-        return this.transaction.enqueueAction(key, path, value);
-    }
-
-    /**
-     * Use this method as intermediary for interactions with actual files.
-     * Allows individual providers to modify where they store their files without disrupting the preference system's
-     * conventions about scope and file location.
-     */
-    protected toFileManager(): PreferenceContext {
-        return this;
+    protected doSetPreference(key: string, path: string[], value: JSONValue): Promise<boolean> {
+        return this.preferenceStorage.writeValue(key, path, value);
     }
 
     protected getPath(preferenceName: string): string[] | undefined {
@@ -150,19 +165,16 @@ export abstract class AbstractResourcePreferenceProvider extends PreferenceProvi
         return [preferenceName];
     }
 
-    protected async readPreferencesFromFile(): Promise<void> {
-        const content = await this.fileService.read(this.toFileManager().getConfigUri())
-            .then(value => {
-                this.fileExists = true;
-                return value;
-            })
-            .catch(() => {
-                this.fileExists = false;
-                return { value: '' };
-            });
-        this.readPreferencesFromContent(content.value);
-    }
+    protected readPreferencesFromFile(): Promise<void> {
+        return this.preferenceStorage.read().then(value => {
+            this.fileExists = true;
+            this.readPreferencesFromContent(value);
+        }).catch(() => {
+            this.fileExists = false;
+            this.readPreferencesFromContent('');
+        });
 
+    }
     protected readPreferencesFromContent(content: string): void {
         let preferencesInJson;
         try {
@@ -192,16 +204,16 @@ export abstract class AbstractResourcePreferenceProvider extends PreferenceProvi
         for (const prefName of prefNames.values()) {
             const oldValue = oldPrefs[prefName];
             const newValue = newPrefs[prefName];
-            const schemaProperties = this.schemaProvider.getCombinedSchema().properties[prefName];
-            if (schemaProperties) {
-                const scope = schemaProperties.scope;
+            const schemaProperty = this.schemaProvider.getSchemaProperty(prefName);
+            if (schemaProperty) {
+                const scope = schemaProperty.scope;
                 // do not emit the change event if the change is made out of the defined preference scope
                 if (!this.schemaProvider.isValidInScope(prefName, this.getScope())) {
                     console.warn(`Preference ${prefName} in ${uri} can only be defined in scopes: ${PreferenceScope.getScopeNames(scope).join(', ')}.`);
                     continue;
                 }
             }
-            if (!PreferenceProvider.deepEqual(newValue, oldValue)) {
+            if (!PreferenceUtils.deepEqual(newValue, oldValue)) {
                 prefChanges.push({
                     preferenceName: prefName, newValue, oldValue, scope: this.getScope(), domain: this.getDomain()
                 });

package/src/common/jsonc-editor.ts

@@ -0,0 +1,65 @@
+// *****************************************************************************
+// Copyright (C) 2021 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 * as jsoncparser from 'jsonc-parser';
+import { inject, injectable } from '@theia/core/shared/inversify';
+import { JSONValue } from '@theia/core/shared/@lumino/coreutils';
+import { isWindows, PreferenceService } from '@theia/core';
+
+@injectable()
+export class JSONCEditor {
+    @inject(PreferenceService)
+    protected readonly preferenceService: PreferenceService;
+
+    setValue(model: string, path: jsoncparser.JSONPath, value: JSONValue): string {
+        const edits = this.getEditOperations(model, path, value);
+        return jsoncparser.applyEdits(model, edits);
+    }
+
+    protected getEditOperations(content: string, path: jsoncparser.JSONPath, value: JSONValue): jsoncparser.Edit[] {
+        // Everything is already undefined - no need for changes.
+        if (!content && value === undefined) {
+            return [];
+        }
+        // Delete the entire document.
+        if (!path.length && value === undefined) {
+            return [{
+                offset: 0,
+                length: content.length,
+                content: ''
+            }];
+        }
+        const tabSize = this.preferenceService.get('[json].editor.tabSize', 4);
+        const insertSpaces = this.preferenceService.get('[json].editor.insertSpaces', true);
+
+        const jsonCOptions = {
+            formattingOptions: {
+                insertSpaces,
+                tabSize,
+                eol: this.getEOL()
+            }
+        };
+        return jsoncparser.modify(content, path, value, jsonCOptions);
+    }
+
+    getEOL(): string {
+        const eol = this.preferenceService.get('[json].files.eol');
+        if (eol && typeof eol === 'string' && eol !== 'auto') {
+            return eol;
+        }
+        return isWindows ? '\r\n' : '\n';
+    }
+}