@theia/core 1.65.0-next.6 → 1.65.1

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' }] }
         );

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

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

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

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