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

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

@@ -16,89 +16,181 @@
 
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
-import { JSONValue } from '@lumino/coreutils';
+import { JSONObject, JSONValue } from '@lumino/coreutils';
 import { IJSONSchema } from '../json-schema';
 import { PreferenceScope } from './preference-scope';
-import { isObject, isString } from '../types';
+import { Event } from '../event';
+import { Disposable } from '../disposable';
 
-export interface PreferenceSchema {
-    [name: string]: any,
-    scope?: 'application' | 'window' | 'resource' | PreferenceScope,
-    overridable?: boolean;
+export const PreferenceContribution = Symbol('PreferenceContribution');
+/**
+ * A {@link PreferenceContribution} allows adding additional custom preferences.
+ * For this, the {@link PreferenceContribution} has to provide a valid `PrefernceSchema` specifying which preferences
+ * are available including their types and description.
+ *
+ * ### Example usage
+ * ```typescript
+ * const MyPreferencesSchema: PreferenceSchema = {
+ *     'scope': PreferenceScope.Folder,
+ *     'properties': {
+ *         'myext.decorations.enabled': {
+ *             'type': 'boolean',
+ *             'description': 'Show file status',
+ *             'default': true
+ *         },
+ *         // [...]
+ *     }
+ * }
+ * @injectable()
+ * export class MyPreferenceContribution implements PreferenceContribution{
+ *     schema= MyPreferencesSchema;
+ * }
+ * ```
+ */
+export interface PreferenceContribution {
+    readonly schema?: PreferenceSchema;
     /**
-     * The title of the preference schema.
-     * It is used in the preference UI to associate a localized group of preferences.
+     * Allows to do additional intialisation of the preference schema, for example registering overrides
+     * @param service the preference schema service
      */
-    title?: string;
-    properties: PreferenceSchemaProperties
-}
-export namespace PreferenceSchema {
-    export function is(obj: unknown): obj is PreferenceSchema {
-        return isObject<PreferenceSchema>(obj) && PreferenceSchemaProperties.is(obj.properties);
-    }
-    export function getDefaultScope(schema: PreferenceSchema): PreferenceScope {
-        let defaultScope: PreferenceScope = PreferenceScope.Workspace;
-        if (!PreferenceScope.is(schema.scope)) {
-            defaultScope = PreferenceScope.fromString(<string>schema.scope) || PreferenceScope.Workspace;
-        } else {
-            defaultScope = schema.scope;
-        }
-        return defaultScope;
-    }
+    initSchema?(service: PreferenceSchemaService): Promise<void>
 }
 
-export interface PreferenceSchemaProperties {
-    [name: string]: PreferenceSchemaProperty
-}
-export namespace PreferenceSchemaProperties {
-    export function is(obj: unknown): obj is PreferenceSchemaProperties {
-        return isObject(obj);
-    }
+export interface IndexedAccess<T> {
+    [name: string]: T;
 }
 
-export interface PreferenceDataSchema {
-    [name: string]: any,
+export interface PreferenceSchema {
+    /** The default scope for properties in this schema */
     scope?: PreferenceScope,
-    properties: {
-        [name: string]: PreferenceDataProperty
-    }
-    patternProperties: {
-        [name: string]: PreferenceDataProperty
-    };
+    /** Optional title to be used in UI */
+    title?: string,
+    /** Whether properties in this schema are overridable by default. Defaults to false. */
+    defaultOverridable?: boolean;
+    properties: IndexedAccess<PreferenceDataProperty>;
 }
 
-export interface PreferenceItem extends IJSONSchema {
+export interface PreferenceDataProperty extends IJSONSchema {
     /**
-     * preference default value, if `undefined` then `default`
+     * Whether distinct values can be defined for language override identifers. E.g. values valid when editing typescript files vs.
+     * when editing Java files
      */
-    defaultValue?: JSONValue;
     overridable?: boolean;
-    /** If false, the preference will not be included in the schema or the UI. */
+    /** If false, the preference will not be included in the schema or the UI. E.g. OS-Specific prefs */
     included?: boolean;
     /** If true, this item will registered as part of the preference schema, but hidden in the preference editor UI. */
     hidden?: boolean;
-    [key: string]: any;
-}
-export interface PreferenceSchemaProperty extends PreferenceItem {
-    description?: string;
-    markdownDescription?: string;
-    scope?: 'application' | 'machine' | 'window' | 'resource' | 'language-overridable' | 'machine-overridable' | PreferenceScope;
-    tags?: string[];
-}
-
-export interface PreferenceDataProperty extends PreferenceItem {
-    description?: string;
-    markdownDescription?: string;
+    /** The maximum scope where values for this property can be set. */
     scope?: PreferenceScope;
+    /** Metadata intended for custom renderers */
     typeDetails?: any;
+    /** Tags can be searched for in the UI */
+    tags?: string[]
 }
-export namespace PreferenceDataProperty {
-    export function fromPreferenceSchemaProperty(schemaProps: PreferenceSchemaProperty, defaultScope: PreferenceScope = PreferenceScope.Workspace): PreferenceDataProperty {
-        if (!schemaProps.scope) {
-            schemaProps.scope = defaultScope;
-        } else if (isString(schemaProps.scope)) {
-            return Object.assign(schemaProps, { scope: PreferenceScope.fromString(schemaProps.scope) || defaultScope });
-        }
-        return <PreferenceDataProperty>schemaProps;
-    }
+
+export interface DefaultValueChangedEvent {
+    /** The preference key */
+    key: string;
+    /** The override identifier that the default changed for */
+    overrideIdentifier?: string;
+    /**
+     * When the default for the base property changes, indicates which override identifiers will be affected
+     */
+    otherAffectedOverrides: string[];
+    oldValue: JSONValue | undefined;
+    newValue: JSONValue | undefined;
 }
+
+export const PreferenceSchemaService = Symbol('PreferenceSchemaService');
+
+export interface PreferenceSchemaService {
+    /**
+     * Resolves after static contributions have been processed
+     */
+    readonly ready: Promise<void>;
+    /**
+     * Register an override identifier for language specific preferences
+     * @param overrideIdentifier The identifier to register
+     * @returns A disposable to unregister the identifier
+     */
+    registerOverrideIdentifier(overrideIdentifier: string): Disposable;
+    readonly overrideIdentifiers: ReadonlySet<string>;
+
+    /**
+     * Add a preference schema. It is an error to register the same property in two different schemas
+     * @param schema The schema to add
+     * @returns A disposable to remove the schema
+     */
+    addSchema(schema: PreferenceSchema): Disposable;
+
+    /**
+     * The scopes which this preference schema service handles. Any properties that are not applicable within the
+     * valid scopes will be ignored
+     */
+    readonly validScopes: readonly PreferenceScope[];
+    /**
+     * Check if a preference is valid in a specific scope
+     * @param preferenceName The preference name
+     * @param scope The scope to check
+     * @returns True if the preference is valid in the given scope
+     */
+    isValidInScope(preferenceName: string, scope: PreferenceScope): boolean;
+    getSchemaProperty(key: string): PreferenceDataProperty | undefined;
+    getSchemaProperties(): ReadonlyMap<string, PreferenceDataProperty>;
+
+    /**
+     * Update a property in the schema. The corresponding JSON Schemas, etc. will be updated
+     * @param key The property key
+     * @param property The updated property
+     */
+    updateSchemaProperty(key: string, property: PreferenceDataProperty): void;
+
+    /**
+     * Register an override for a preference default value. If multiple overrides are registered for the same value,
+     * the last override will be in effect. Removing the last override will make the second-to-last override active, etc.
+     * @param key The preference key
+     * @param overrideIdentifier The override identifier, undefined for global default
+     * @param value The default value
+     * @returns A disposable to unregister the override
+     */
+    registerOverride(key: string, overrideIdentifier: string | undefined, value: JSONValue): Disposable;
+    /**
+     * Get the default value for a preference. This is the value a client will see for the given key/override
+     * @param key The preference key
+     * @param overrideIdentifier The override identifier, undefined for global default
+     * @returns The default value or undefined if not found
+     */
+    getDefaultValue(key: string, overrideIdentifier: string | undefined): JSONValue | undefined;
+    /**
+     * Gets the default value for a preference. This method not fall back to the global value if no override is given
+     * @param key The preference key
+     * @param overrideIdentifier The override identifier, undefined for global default
+     * @returns The default value or undefined if not found
+     */
+    inspectDefaultValue(key: string, overrideIdentifier: string | undefined): JSONValue | undefined;
+
+    /**
+     * Gets a JSON schema a preference.json file for the given scope.
+     * @param scope The scope to generate schema for
+     * @returns The JSON schema
+     */
+    getJSONSchema(scope: PreferenceScope): IJSONSchema;
+    /**
+     * Get the collection of all defined default values as JSONObject of the form like in a preferences.json
+     *
+     * #### Example usage
+     * ```json
+     * {
+     *   "my.preference": "a string default",
+     *   "[typescript]": {
+     *      "another.preference": 39
+     *   }
+     * }
+     */
+    getDefaultValues(): JSONObject;
+
+    // Public events
+    onDidChangeDefaultValue: Event<DefaultValueChangedEvent>;
+    onDidChangeSchema: Event<void>;
+}
+

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

@@ -14,6 +14,11 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
+/**
+ * An array of preference scopes that are valid in a given context, sorted from more general to more specific
+ */
+export const ValidPreferenceScopes = Symbol('ValidPreferenceScopes');
+
 export enum PreferenceScope {
     Default,
     User,
@@ -52,17 +57,4 @@ export namespace PreferenceScope {
         }
         return names;
     }
-
-    export function fromString(strScope: string): PreferenceScope | undefined {
-        switch (strScope) {
-            case 'application':
-                return PreferenceScope.User;
-            case 'window':
-                return PreferenceScope.Folder;
-            case 'resource':
-                return PreferenceScope.Folder;
-            case 'language-overridable':
-                return PreferenceScope.Folder;
-        }
-    }
 }

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

@@ -16,18 +16,16 @@
 
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
-import { injectable, inject, postConstruct } from 'inversify';
-import { Event, Emitter, DisposableCollection, Disposable, deepFreeze, unreachable } from '../../common';
+import { JSONExt, JSONValue } from '@lumino/coreutils';
+import { inject, injectable, postConstruct } from 'inversify';
+import { Disposable, DisposableCollection, Emitter, Event, deepFreeze, unreachable } from '../../common';
 import { Deferred } from '../../common/promise-util';
-import { PreferenceProvider, PreferenceProviderDataChange, PreferenceProviderDataChanges, PreferenceResolveResult } from './preference-provider';
-import { PreferenceSchemaProvider } from './preference-contribution';
 import URI from '../../common/uri';
+import { OverridePreferenceName, PreferenceLanguageOverrideService } from './preference-language-override-service';
+import { PreferenceProvider, PreferenceProviderDataChange, PreferenceProviderDataChanges, PreferenceResolveResult, PreferenceUtils } from './preference-provider';
+import { PreferenceSchemaService } from './preference-schema';
 import { PreferenceScope } from './preference-scope';
 import { PreferenceConfigurations } from './preference-configurations';
-import { JSONExt, JSONValue } from '@lumino/coreutils';
-import { OverridePreferenceName, PreferenceLanguageOverrideService } from './preference-language-override-service';
-
-export { PreferenceScope };
 
 /**
  * Representation of a preference change. A preference value can be set to `undefined` for a specific scope.
@@ -50,10 +48,10 @@ export class PreferenceChangeImpl implements PreferenceChange {
     get preferenceName(): string {
         return this.change.preferenceName;
     }
-    get newValue(): string {
+    get newValue(): JSONValue | undefined {
         return this.change.newValue;
     }
-    get oldValue(): string {
+    get oldValue(): JSONValue | undefined {
         return this.change.oldValue;
     }
     get scope(): PreferenceScope {
@@ -272,7 +270,7 @@ export type PreferenceInspectionScope = keyof Omit<PreferenceInspection<unknown>
  * It allows to load them lazily after DI is configured.
  */
 export const PreferenceProviderProvider = Symbol('PreferenceProviderProvider');
-export type PreferenceProviderProvider = (scope: PreferenceScope, uri?: URI) => PreferenceProvider;
+export type PreferenceProviderProvider = (scope: PreferenceScope, uri?: URI) => PreferenceProvider | undefined;
 
 @injectable()
 export class PreferenceServiceImpl implements PreferenceService {
@@ -285,8 +283,8 @@ export class PreferenceServiceImpl implements PreferenceService {
 
     protected readonly toDispose = new DisposableCollection(this.onPreferenceChangedEmitter, this.onPreferencesChangedEmitter);
 
-    @inject(PreferenceSchemaProvider)
-    protected readonly schema: PreferenceSchemaProvider;
+    @inject(PreferenceSchemaService)
+    protected readonly schemaService: PreferenceSchemaService;
 
     @inject(PreferenceProviderProvider)
     protected readonly providerProvider: PreferenceProviderProvider;
@@ -301,13 +299,17 @@ export class PreferenceServiceImpl implements PreferenceService {
 
     protected async initializeProviders(): Promise<void> {
         try {
-            for (const scope of PreferenceScope.getScopes()) {
+            for (const scope of this.schemaService.validScopes) {
                 const provider = this.providerProvider(scope);
-                this.preferenceProviders.set(scope, provider);
-                this.toDispose.push(provider.onDidPreferencesChanged(changes =>
-                    this.reconcilePreferences(changes)
-                ));
-                await provider.ready;
+                if (provider) {
+                    this.preferenceProviders.set(scope, provider);
+                    this.toDispose.push(provider.onDidPreferencesChanged(changes =>
+                        this.reconcilePreferences(changes)
+                    ));
+                    await provider.ready;
+                } else {
+                    console.warn(`No preference provider bound for ${PreferenceScope[scope]}`);
+                }
             }
             this._ready.resolve();
             this._isReady = true;
@@ -338,50 +340,44 @@ export class PreferenceServiceImpl implements PreferenceService {
 
     protected reconcilePreferences(changes: PreferenceProviderDataChanges): void {
         const changesToEmit: PreferenceChanges = {};
-        const acceptChange = (change: PreferenceProviderDataChange) =>
+        const acceptChange = (change: PreferenceProviderDataChange) => {
             this.getAffectedPreferenceNames(change, preferenceName =>
-                changesToEmit[preferenceName] = new PreferenceChangeImpl({ ...change, preferenceName })
-            );
+                changesToEmit[preferenceName] = new PreferenceChangeImpl({ ...change, preferenceName }));
+        };
 
         for (const preferenceName of Object.keys(changes)) {
+
             let change = changes[preferenceName];
+            const overridden = this.overriddenPreferenceName(change.preferenceName);
             if (change.newValue === undefined) {
-                const overridden = this.overriddenPreferenceName(change.preferenceName);
                 if (overridden) {
                     change = {
                         ...change, newValue: this.doGet(overridden.preferenceName)
                     };
                 }
             }
-            if (this.schema.isValidInScope(preferenceName, PreferenceScope.Folder)) {
-                acceptChange(change);
-                continue;
-            }
-            for (const scope of PreferenceScope.getReversedScopes()) {
-                if (this.schema.isValidInScope(preferenceName, scope)) {
-                    const provider = this.getProvider(scope);
-                    if (provider) {
-                        const value = provider.get(preferenceName);
-                        if (scope > change.scope && value !== undefined) {
-                            // preference defined in a more specific scope
-                            break;
-                        } else if (scope === change.scope && change.newValue !== undefined) {
-                            // preference is changed into something other than `undefined`
-                            acceptChange(change);
-                        } else if (scope < change.scope && change.newValue === undefined && value !== undefined) {
-                            // preference is changed to `undefined`, use the value from a more general scope
-                            change = {
-                                ...change,
-                                newValue: value,
-                                scope
-                            };
-                            acceptChange(change);
-                        }
+
+            for (const scope of [...this.schemaService.validScopes].reverse()) {
+                const provider = this.getProvider(scope);
+                if (provider) {
+                    const value: JSONValue | undefined = provider.get(preferenceName);
+                    if (scope > change.scope && value !== undefined) {
+                        // preference defined in a more specific scope
+                        break;
+                    } else if (scope === change.scope && (change.newValue !== undefined || scope === PreferenceScope.Default)) {
+                        // preference is changed into something other than `undefined`
+                        acceptChange(change);
+                        break;
+                    } else if (scope < change.scope && change.newValue === undefined && value !== undefined) {
+                        // preference is changed to `undefined`, use the value from a more general scope
+                        change = {
+                            ...change,
+                            newValue: value,
+                            scope
+                        };
+                        acceptChange(change);
+                        break;
                     }
-                } else if (change.newValue === undefined && change.scope === PreferenceScope.Default) {
-                    // preference is removed
-                    acceptChange(change);
-                    break;
                 }
             }
         }
@@ -394,10 +390,22 @@ export class PreferenceServiceImpl implements PreferenceService {
         changedPreferenceNames.forEach(preferenceName => this.onPreferenceChangedEmitter.fire(changesToEmit[preferenceName]));
     }
     protected getAffectedPreferenceNames(change: PreferenceProviderDataChange, accept: (affectedPreferenceName: string) => void): void {
+        const overridden = this.preferenceOverrideService.overriddenPreferenceName(change.preferenceName);
         accept(change.preferenceName);
-        for (const overridePreferenceName of this.schema.getOverridePreferenceNames(change.preferenceName)) {
-            if (!this.doHas(overridePreferenceName)) {
-                accept(overridePreferenceName);
+        if (!overridden?.overrideIdentifier) { // changes to overrides never affect other overrides
+            const preference = this.schemaService.getSchemaProperty(change.preferenceName);
+            if (preference && preference.overridable) {
+
+                for (const overrideId of this.schemaService.overrideIdentifiers) {
+                    const overridePreferenceName = this.preferenceOverrideService.overridePreferenceName({
+                        overrideIdentifier: overrideId,
+                        preferenceName: change.preferenceName
+                    });
+
+                    if (!this.doHas(overridePreferenceName)) {
+                        accept(overridePreferenceName);
+                    }
+                }
             }
         }
     }
@@ -530,7 +538,7 @@ export class PreferenceServiceImpl implements PreferenceService {
         }
 
         // Scopes in ascending order of scope breadth.
-        const allScopes = PreferenceScope.getReversedScopes();
+        const allScopes = [...this.schemaService.validScopes].reverse();
         // Get rid of Default scope. We can't set anything there.
         allScopes.pop();
 
@@ -562,15 +570,13 @@ export class PreferenceServiceImpl implements PreferenceService {
     }
     protected doResolve<T>(preferenceName: string, defaultValue?: T, resourceUri?: string): PreferenceResolveResult<T> {
         const result: PreferenceResolveResult<T> = {};
-        for (const scope of PreferenceScope.getScopes()) {
-            if (this.schema.isValidInScope(preferenceName, scope)) {
-                const provider = this.getProvider(scope);
-                if (provider?.canHandleScope(scope)) {
-                    const { configUri, value } = provider.resolve<T>(preferenceName, resourceUri);
-                    if (value !== undefined) {
-                        result.configUri = configUri;
-                        result.value = PreferenceProvider.merge(result.value as any, value as any) as any;
-                    }
+        for (const scope of this.schemaService.validScopes) {
+            const provider = this.getProvider(scope);
+            if (provider?.canHandleScope(scope)) {
+                const { configUri, value } = provider.resolve<T>(preferenceName, resourceUri);
+                if (value !== undefined) {
+                    result.configUri = configUri;
+                    result.value = PreferenceUtils.merge(result.value as any, value as any) as any;
                 }
             }
         }
@@ -585,7 +591,7 @@ export class PreferenceServiceImpl implements PreferenceService {
         if (!provider || !this.configurations.isAnyConfig(sectionName)) {
             return undefined;
         }
-        const configUri = provider.getConfigUri(resourceUri, sectionName);
+        const configUri = provider.getConfigUri && provider.getConfigUri(resourceUri, sectionName);
         if (configUri) {
             return configUri;
         }

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

@@ -15,14 +15,12 @@
 // *****************************************************************************
 
 import { interfaces } from 'inversify';
-import { PreferenceProxy, PreferenceContribution, PreferenceSchema } from '../preferences';
-import { PreferenceProxyFactory } from '../preferences/injectable-preference-proxy';
-import { nls } from '../../common/nls';
+import { nls } from './nls';
+import { PreferenceSchema, PreferenceProxy, PreferenceProxyFactory, PreferenceContribution } from './preferences';
 
 export const PREFERENCE_NAME_TREE_INDENT = 'workbench.tree.indent';
 
 export const treePreferencesSchema: PreferenceSchema = {
-    type: 'object',
     properties: {
         [PREFERENCE_NAME_TREE_INDENT]: {
             description: nls.localizeByDefault('Controls tree indentation in pixels.'),

package/src/electron-browser/menu/electron-context-menu-renderer.ts

@@ -18,7 +18,7 @@
 
 import { inject, injectable, postConstruct } from 'inversify';
 import {
-    ContextMenuRenderer, ContextMenuAccess, FrontendApplicationContribution, CommonCommands, coordinateFromAnchor, PreferenceService,
+    ContextMenuRenderer, ContextMenuAccess, FrontendApplicationContribution, CommonCommands, coordinateFromAnchor,
     Anchor
 } from '../../browser';
 import { ElectronMainMenuFactory } from './electron-main-menu-factory';
@@ -26,6 +26,7 @@ import { ContextMenuContext } from '../../browser/menu/context-menu-context';
 import { BrowserContextMenuAccess, BrowserContextMenuRenderer } from '../../browser/menu/browser-context-menu-renderer';
 import { MenuPath, MenuContribution, MenuModelRegistry, CompoundMenuNode } from '../../common/menu';
 import { ContextKeyService, ContextMatcher } from '../../browser/context-key-service';
+import { PreferenceService } from '../../common/preferences';
 
 export class ElectronContextMenuAccess extends ContextMenuAccess {
     constructor(readonly menuHandle: Promise<number>) {

package/src/electron-browser/menu/electron-main-menu-factory.ts

@@ -17,8 +17,8 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
 import { inject, injectable, postConstruct } from 'inversify';
-import { isOSX, MAIN_MENU_BAR, MenuNode, CompoundMenuNode, Group, RenderedMenuNode, CommandMenu, AcceleratorSource, MenuPath } from '../../common';
-import { PreferenceService, CommonCommands } from '../../browser';
+import { isOSX, MAIN_MENU_BAR, MenuNode, CompoundMenuNode, Group, RenderedMenuNode, CommandMenu, AcceleratorSource, MenuPath, PreferenceService } from '../../common';
+import { CommonCommands } from '../../browser';
 import debounce = require('lodash.debounce');
 import { BrowserMainMenuFactory } from '../../browser/menu/browser-menu-plugin';
 import { ContextMatcher } from '../../browser/context-key-service';

package/src/electron-browser/menu/electron-menu-contribution.ts

@@ -15,15 +15,18 @@
 // *****************************************************************************
 
 import { inject, injectable, postConstruct } from 'inversify';
-import { Command, CommandContribution, CommandRegistry, isOSX, isWindows, MenuModelRegistry, MenuContribution, Disposable, nls } from '../../common';
 import {
-    codicon, ConfirmDialog, KeybindingContribution, KeybindingRegistry, PreferenceScope, Widget,
-    FrontendApplication, FrontendApplicationContribution, CommonMenus, CommonCommands, Dialog, Message, ApplicationShell, PreferenceService, animationFrame,
+    Command, CommandContribution, CommandRegistry, isOSX, isWindows, MenuModelRegistry,
+    MenuContribution, Disposable, nls, PreferenceScope, PreferenceService
+} from '../../common';
+import {
+    codicon, ConfirmDialog, KeybindingContribution, KeybindingRegistry, Widget,
+    FrontendApplication, FrontendApplicationContribution, CommonMenus, CommonCommands, Dialog, Message, ApplicationShell, animationFrame,
 } from '../../browser';
 import { ElectronMainMenuFactory } from './electron-main-menu-factory';
 import { FrontendApplicationStateService, FrontendApplicationState } from '../../browser/frontend-application-state';
 import { FrontendApplicationConfigProvider } from '../../browser/frontend-application-config-provider';
-import { ZoomLevel } from '../window/electron-window-preferences';
+import { ZoomLevel } from '../../electron-common/electron-window-preferences';
 import { BrowserMenuBarContribution } from '../../browser/menu/browser-menu-plugin';
 import { WindowService } from '../../browser/window/window-service';
 import { WindowTitleService } from '../../browser/window/window-title-service';
@@ -142,7 +145,7 @@ export class ElectronMenuContribution extends BrowserMenuBarContribution impleme
     protected attachMenuBarVisibilityListener(): void {
         this.preferenceService.onPreferenceChanged(e => {
             if (e.preferenceName === 'window.menuBarVisibility') {
-                this.handleFullScreen(e.newValue);
+                this.handleFullScreen(e.newValue as string);
             }
         });
     }
@@ -164,7 +167,7 @@ export class ElectronMenuContribution extends BrowserMenuBarContribution impleme
         this.preferenceService.onPreferenceChanged(change => {
             if (change.preferenceName === 'window.titleBarStyle') {
                 if (this.titleBarStyleChangeFlag && this.titleBarStyle !== change.newValue) {
-                    window.electronTheiaCore.setTitleBarStyle(change.newValue);
+                    window.electronTheiaCore.setTitleBarStyle(change.newValue as string);
                     this.handleRequiredRestart();
                 }
                 this.titleBarStyleChangeFlag = true;

package/src/electron-browser/window/electron-window-module.ts

@@ -26,7 +26,7 @@ import { ElectronClipboardService } from '../electron-clipboard-service';
 import { ElectronIpcConnectionProvider } from '../messaging/electron-ipc-connection-source';
 import { ElectronFrontendApplicationStateService } from './electron-frontend-application-state';
 import { ElectronSecondaryWindowService } from './electron-secondary-window-service';
-import { bindWindowPreferences } from './electron-window-preferences';
+import { bindWindowPreferences } from '../../electron-common/electron-window-preferences';
 import { ElectronWindowService } from './electron-window-service';
 import { ExternalAppOpenHandler } from './external-app-open-handler';
 import { ElectronUriHandlerContribution } from '../electron-uri-handler';

package/src/electron-browser/window/electron-window-service.ts

@@ -18,7 +18,7 @@ import { injectable, inject, postConstruct } from 'inversify';
 import { NewWindowOptions, WindowSearchParams } from '../../common/window';
 import { DefaultWindowService } from '../../browser/window/default-window-service';
 import { ElectronMainWindowService } from '../../electron-common/electron-main-window-service';
-import { ElectronWindowPreferences } from './electron-window-preferences';
+import { ElectronWindowPreferences } from '../../electron-common/electron-window-preferences';
 import { ConnectionCloseService } from '../../common/messaging/connection-management';
 import { FrontendIdProvider } from '../../browser/messaging/frontend-id-provider';
 import { WindowReloadOptions } from '../../browser/window/window-service';