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

package/src/browser/preferences/preference-validation-service.ts

@@ -14,21 +14,18 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import { PreferenceItem } from '../../common/preferences/preference-schema';
 import { JSONObject, JSONValue } from '../../../shared/@lumino/coreutils';
-import { PreferenceSchemaProvider } from './preference-contribution';
-import { PreferenceLanguageOverrideService } from './preference-language-override-service';
 import { inject, injectable } from '../../../shared/inversify';
 import { IJSONSchema, JsonType } from '../../common/json-schema';
 import { deepClone, unreachable } from '../../common';
-import { PreferenceProvider } from './preference-provider';
+import { PreferenceLanguageOverrideService } from '../../common/preferences/preference-language-override-service';
+import { PreferenceSchemaService, PreferenceScope, PreferenceUtils, PreferenceDataProperty } from '../../common/preferences';
 
 export interface PreferenceValidator<T> {
     name: string;
     validate(value: unknown): T;
 }
 
-export interface ValidatablePreference extends IJSONSchema, Pick<PreferenceItem, 'defaultValue'> { }
 export type ValueValidator = (value: JSONValue) => JSONValue;
 
 export interface PreferenceValidationResult<T extends JSONValue> {
@@ -37,11 +34,11 @@ export interface PreferenceValidationResult<T extends JSONValue> {
     messages: string[];
 }
 
-type ValidatablePreferenceTuple = ValidatablePreference & ({ items: ValidatablePreference[] } | { prefixItems: ValidatablePreference[] });
+type ValidatablePreferenceTuple = IJSONSchema & ({ items: IJSONSchema[] } | { prefixItems: IJSONSchema[] });
 
 @injectable()
 export class PreferenceValidationService {
-    @inject(PreferenceSchemaProvider) protected readonly schemaProvider: PreferenceSchemaProvider;
+    @inject(PreferenceSchemaService) protected readonly schemaService: PreferenceSchemaService;
     @inject(PreferenceLanguageOverrideService) protected readonly languageOverrideService: PreferenceLanguageOverrideService;
 
     validateOptions(options: Record<string, JSONValue>): Record<string, JSONValue> {
@@ -71,30 +68,30 @@ export class PreferenceValidationService {
         return this.validateBySchema(preferenceName, value, schema);
     }
 
-    validateBySchema(key: string, value: JSONValue, schema: ValidatablePreference | undefined): JSONValue {
+    validateBySchema(key: string, value: JSONValue, schema: IJSONSchema | undefined): JSONValue {
         try {
             if (!schema) {
                 console.warn('Request to validate preference with no schema registered:', key);
                 return value;
             }
             if (schema.const !== undefined) {
-                return this.validateConst(key, value, schema as ValidatablePreference & { const: JSONValue });
+                return this.validateConst(key, value, schema as IJSONSchema & { const: JSONValue });
             }
             if (Array.isArray(schema.enum)) {
-                return this.validateEnum(key, value, schema as ValidatablePreference & { enum: JSONValue[] });
+                return this.validateEnum(key, value, schema as IJSONSchema & { enum: JSONValue[] });
             }
             if (Array.isArray(schema.anyOf)) {
-                return this.validateAnyOf(key, value, schema as ValidatablePreference & { anyOf: ValidatablePreference[] });
+                return this.validateAnyOf(key, value, schema as IJSONSchema & { anyOf: IJSONSchema[] });
             }
             if (Array.isArray(schema.oneOf)) {
-                return this.validateOneOf(key, value, schema as ValidatablePreference & { oneOf: ValidatablePreference[] });
+                return this.validateOneOf(key, value, schema as IJSONSchema & { oneOf: IJSONSchema[] });
             }
             if (schema.type === undefined) {
                 console.warn('Request to validate preference with no type information:', key);
                 return value;
             }
             if (Array.isArray(schema.type)) {
-                return this.validateMultiple(key, value, schema as ValidatablePreference & { type: JsonType[] });
+                return this.validateMultiple(key, value, schema as IJSONSchema & { type: JsonType[] });
             }
             switch (schema.type) {
                 case 'array':
@@ -120,8 +117,8 @@ export class PreferenceValidationService {
         }
     }
 
-    protected getSchema(name: string): ValidatablePreference | undefined {
-        const combinedSchema = this.schemaProvider.getCombinedSchema().properties;
+    protected getSchema(name: string): IJSONSchema | undefined {
+        const combinedSchema = this.schemaService.getJSONSchema(PreferenceScope.Folder).properties!;
         if (combinedSchema[name]) {
             return combinedSchema[name];
         }
@@ -129,35 +126,35 @@ export class PreferenceValidationService {
         return baseName !== undefined ? combinedSchema[baseName] : undefined;
     }
 
-    protected validateMultiple(key: string, value: JSONValue, schema: ValidatablePreference & { type: JsonType[] }): JSONValue {
-        const validation: ValidatablePreference = deepClone(schema);
+    protected validateMultiple(key: string, value: JSONValue, schema: IJSONSchema & { type: JsonType[] }): JSONValue {
+        const validation: IJSONSchema = deepClone(schema);
         const candidate = this.mapValidators(key, value, (function* (this: PreferenceValidationService): Iterable<ValueValidator> {
             for (const type of schema.type) {
                 validation.type = type as JsonType;
                 yield toValidate => this.validateBySchema(key, toValidate, validation);
             }
         }).bind(this)());
-        if (candidate !== value && (schema.default !== undefined || schema.defaultValue !== undefined)) {
+        if (candidate !== value && (schema.default !== undefined || schema.default !== undefined)) {
             const configuredDefault = this.getDefaultFromSchema(schema);
-            return this.validateMultiple(key, configuredDefault, { ...schema, default: undefined, defaultValue: undefined });
+            return this.validateMultiple(key, configuredDefault, { ...schema, default: undefined });
         }
         return candidate;
     }
 
-    protected validateAnyOf(key: string, value: JSONValue, schema: ValidatablePreference & { anyOf: ValidatablePreference[] }): JSONValue {
+    protected validateAnyOf(key: string, value: JSONValue, schema: IJSONSchema & { anyOf: IJSONSchema[] }): JSONValue {
         const candidate = this.mapValidators(key, value, (function* (this: PreferenceValidationService): Iterable<ValueValidator> {
             for (const option of schema.anyOf) {
                 yield toValidate => this.validateBySchema(key, toValidate, option);
             }
         }).bind(this)());
-        if (candidate !== value && (schema.default !== undefined || schema.defaultValue !== undefined)) {
+        if (candidate !== value && (schema.default !== undefined)) {
             const configuredDefault = this.getDefaultFromSchema(schema);
-            return this.validateAnyOf(key, configuredDefault, { ...schema, default: undefined, defaultValue: undefined });
+            return this.validateAnyOf(key, configuredDefault, { ...schema, default: undefined });
         }
         return candidate;
     }
 
-    protected validateOneOf(key: string, value: JSONValue, schema: ValidatablePreference & { oneOf: ValidatablePreference[] }): JSONValue {
+    protected validateOneOf(key: string, value: JSONValue, schema: IJSONSchema & { oneOf: IJSONSchema[] }): JSONValue {
         let passed = false;
         for (const subSchema of schema.oneOf) {
             const validValue = this.validateBySchema(key, value, subSchema);
@@ -171,9 +168,9 @@ export class PreferenceValidationService {
         if (passed) {
             return value;
         }
-        if (schema.default !== undefined || schema.defaultValue !== undefined) {
+        if (schema.default !== undefined) {
             const configuredDefault = this.getDefaultFromSchema(schema);
-            return this.validateOneOf(key, configuredDefault, { ...schema, default: undefined, defaultValue: undefined });
+            return this.validateOneOf(key, configuredDefault, { ...schema, default: undefined });
         }
         console.log(`While validating ${key}, failed to find a valid value or default value. Using configured value ${value}.`);
         return value;
@@ -190,7 +187,7 @@ export class PreferenceValidationService {
         }
         return candidates[0];
     }
-    protected validateArray(key: string, value: JSONValue, schema: ValidatablePreference): JSONValue[] {
+    protected validateArray(key: string, value: JSONValue, schema: IJSONSchema): JSONValue[] {
         const candidate = Array.isArray(value) ? value : this.getDefaultFromSchema(schema);
         if (!Array.isArray(candidate)) {
             return [];
@@ -211,11 +208,11 @@ export class PreferenceValidationService {
         const defaultValue = this.getDefaultFromSchema(schema);
         const maybeCandidate = Array.isArray(value) ? value : defaultValue;
         // If we find that the provided value is not valid, we immediately bail and try the default value instead.
-        const shouldTryDefault = Array.isArray(schema.defaultValue ?? schema.default) && !PreferenceProvider.deepEqual(defaultValue, maybeCandidate);
+        const shouldTryDefault = Array.isArray(schema.default) && !PreferenceUtils.deepEqual(defaultValue, maybeCandidate);
         const tryDefault = () => this.validateTuple(key, defaultValue, schema);
         const candidate = Array.isArray(maybeCandidate) ? maybeCandidate : [];
         // Only `prefixItems` is officially part of the JSON Schema spec, but `items` as array was part of a draft and was used by VSCode.
-        const tuple = (schema.prefixItems ?? schema.items) as Required<ValidatablePreference>['prefixItems'];
+        const tuple = (schema.prefixItems ?? schema.items) as Required<IJSONSchema>['prefixItems'];
         const lengthIsWrong = candidate.length < tuple.length || (candidate.length > tuple.length && !schema.additionalItems);
         if (lengthIsWrong && shouldTryDefault) { return tryDefault(); }
         let valid = true;
@@ -250,26 +247,26 @@ export class PreferenceValidationService {
         return valid ? candidate : validItems;
     }
 
-    protected validateConst(key: string, value: JSONValue, schema: ValidatablePreference & { const: JSONValue }): JSONValue {
-        if (PreferenceProvider.deepEqual(value, schema.const)) {
+    protected validateConst(key: string, value: JSONValue, schema: IJSONSchema & { const: JSONValue }): JSONValue {
+        if (PreferenceUtils.deepEqual(value, schema.const)) {
             return value;
         }
         return schema.const;
     }
 
-    protected validateEnum(key: string, value: JSONValue, schema: ValidatablePreference & { enum: JSONValue[] }): JSONValue {
+    protected validateEnum(key: string, value: JSONValue, schema: IJSONSchema & { enum: JSONValue[] }): JSONValue {
         const options = schema.enum;
-        if (options.some(option => PreferenceProvider.deepEqual(option, value))) {
+        if (options.some(option => PreferenceUtils.deepEqual(option, value))) {
             return value;
         }
         const configuredDefault = this.getDefaultFromSchema(schema);
-        if (options.some(option => PreferenceProvider.deepEqual(option, configuredDefault))) {
+        if (options.some(option => PreferenceUtils.deepEqual(option, configuredDefault))) {
             return configuredDefault;
         }
         return options[0];
     }
 
-    protected validateBoolean(key: string, value: JSONValue, schema: ValidatablePreference): boolean {
+    protected validateBoolean(key: string, value: JSONValue, schema: IJSONSchema): boolean {
         if (value === true || value === false) {
             return value;
         }
@@ -282,11 +279,11 @@ export class PreferenceValidationService {
         return Boolean(this.getDefaultFromSchema(schema));
     }
 
-    protected validateInteger(key: string, value: JSONValue, schema: ValidatablePreference): number {
+    protected validateInteger(key: string, value: JSONValue, schema: IJSONSchema): number {
         return Math.round(this.validateNumber(key, value, schema));
     }
 
-    protected validateNumber(key: string, value: JSONValue, schema: ValidatablePreference): number {
+    protected validateNumber(key: string, value: JSONValue, schema: IJSONSchema): number {
         let validated = Number(value);
         if (isNaN(validated)) {
             const configuredDefault = Number(this.getDefaultFromSchema(schema));
@@ -301,7 +298,7 @@ export class PreferenceValidationService {
         return validated;
     }
 
-    protected validateObject(key: string, value: JSONValue, schema: ValidatablePreference): JSONObject {
+    protected validateObject(key: string, value: JSONValue, schema: IJSONSchema): JSONObject {
         if (this.objectMatchesSchema(key, value, schema)) {
             return value;
         }
@@ -313,7 +310,7 @@ export class PreferenceValidationService {
     }
 
     // This evaluates most of the fields that commonly appear on PreferenceItem, but it could be improved to evaluate all possible JSON schema specifications.
-    protected objectMatchesSchema(key: string, value: JSONValue, schema: ValidatablePreference): value is JSONObject {
+    protected objectMatchesSchema(key: string, value: JSONValue, schema: IJSONSchema): value is JSONObject {
         if (!value || typeof value !== 'object') {
             return false;
         }
@@ -341,7 +338,7 @@ export class PreferenceValidationService {
         return true;
     }
 
-    protected validateString(key: string, value: JSONValue, schema: ValidatablePreference): string {
+    protected validateString(key: string, value: JSONValue, schema: IJSONSchema): string {
         if (typeof value === 'string') {
             return value;
         }
@@ -352,7 +349,29 @@ export class PreferenceValidationService {
         return (configuredDefault ?? '').toString();
     }
 
-    protected getDefaultFromSchema(schema: ValidatablePreference): JSONValue {
-        return this.schemaProvider.getDefaultValue(schema as PreferenceItem);
+    protected getDefaultFromSchema(schema: IJSONSchema): JSONValue {
+        return this.getDefaultValue(schema);
+    }
+
+    getDefaultValue(property: PreferenceDataProperty): JSONValue {
+        if (property.default !== undefined) {
+            return property.default;
+        }
+        const type = Array.isArray(property.type) ? property.type[0] : property.type;
+        switch (type) {
+            case 'boolean':
+                return false;
+            case 'integer':
+            case 'number':
+                return 0;
+            case 'string':
+                return '';
+            case 'array':
+                return [];
+            case 'object':
+                return {};
+        }
+        // eslint-disable-next-line no-null/no-null
+        return null;
     }
 }

package/src/browser/preferences/test/mock-preference-provider.ts

@@ -17,10 +17,9 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
 import { interfaces } from 'inversify';
-import { PreferenceProvider } from '../preference-provider';
-import { PreferenceScope } from '../preference-scope';
+import { PreferenceProviderImpl, PreferenceScope, PreferenceProvider } from '../../../common/preferences';
 
-export class MockPreferenceProvider extends PreferenceProvider {
+export class MockPreferenceProvider extends PreferenceProviderImpl {
     readonly prefs: { [p: string]: any } = {};
 
     constructor(protected scope: PreferenceScope) {
@@ -42,8 +41,6 @@ export class MockPreferenceProvider extends PreferenceProvider {
 }
 
 export function bindMockPreferenceProviders(bind: interfaces.Bind, unbind: interfaces.Unbind): void {
-    unbind(PreferenceProvider);
-
     bind(PreferenceProvider).toDynamicValue(ctx => new MockPreferenceProvider(PreferenceScope.User)).inSingletonScope().whenTargetNamed(PreferenceScope.User);
     bind(PreferenceProvider).toDynamicValue(ctx => new MockPreferenceProvider(PreferenceScope.Workspace)).inSingletonScope().whenTargetNamed(PreferenceScope.Workspace);
     bind(PreferenceProvider).toDynamicValue(ctx => new MockPreferenceProvider(PreferenceScope.Folder)).inSingletonScope().whenTargetNamed(PreferenceScope.Folder);

package/src/browser/preferences/test/mock-preference-proxy.ts

@@ -14,8 +14,7 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import { Emitter } from '../../../common';
-import { PreferenceChange } from '../preference-service';
+import { Emitter, PreferenceChange } from '../../../common';
 
 /* eslint-disable @typescript-eslint/no-explicit-any */
 export function createMockPreferenceProxy(preferences: { [p: string]: any }): any {

package/src/browser/preferences/test/mock-preference-service.ts

@@ -15,11 +15,8 @@
 // *****************************************************************************
 
 import { injectable } from 'inversify';
-import { Emitter, Event } from '../../../common';
+import { Emitter, Event, OverridePreferenceName, PreferenceChange, PreferenceChanges, PreferenceInspection, PreferenceScope, PreferenceService } from '../../../common';
 import URI from '../../../common/uri';
-import { PreferenceChange, PreferenceChanges, PreferenceInspection, PreferenceService } from '../preference-service';
-import { PreferenceScope } from '../preference-scope';
-import { OverridePreferenceName } from '../preference-language-override-service';
 
 @injectable()
 export class MockPreferenceService implements PreferenceService {

package/src/browser/quick-input/quick-command-service.ts

@@ -18,7 +18,7 @@ import { inject, injectable } from 'inversify';
 import { KeybindingRegistry } from '../keybinding';
 import { Disposable, Command, CommandRegistry, CancellationToken, nls } from '../../common';
 import { ContextKeyService } from '../context-key-service';
-import { CorePreferences } from '../core-preferences';
+import { CorePreferences } from '../../common/core-preferences';
 import { QuickAccessContribution, QuickAccessProvider, QuickAccessRegistry } from './quick-access';
 import { filterItems, QuickPickItem, QuickPicks } from './quick-input-service';
 import { KeySequence } from '../keys';

package/src/browser/request/browser-request-service.ts

@@ -16,7 +16,7 @@
 
 import { inject, injectable, postConstruct } from 'inversify';
 import { BackendRequestService, RequestConfiguration, RequestContext, RequestOptions, RequestService, CancellationToken } from '@theia/request';
-import { PreferenceService } from '../preferences/preference-service';
+import { PreferenceService } from '../../common';
 
 @injectable()
 export abstract class AbstractBrowserRequestService implements RequestService {
@@ -40,9 +40,9 @@ export abstract class AbstractBrowserRequestService implements RequestService {
         });
         this.preferenceService.onPreferencesChanged(e => {
             this.configurePromise.then(() => this.configure({
-                proxyUrl: e['http.proxy']?.newValue,
-                proxyAuthorization: e['http.proxyAuthorization']?.newValue,
-                strictSSL: e['http.proxyStrictSSL']?.newValue
+                proxyUrl: e['http.proxy']?.newValue as string,
+                proxyAuthorization: e['http.proxyAuthorization']?.newValue as string,
+                strictSSL: e['http.proxyStrictSSL']?.newValue as boolean
             }));
         });
     }

package/src/browser/shell/application-shell.ts

@@ -35,7 +35,7 @@ import { TabBarToolbarRegistry, TabBarToolbarFactory } from './tab-bar-toolbar';
 import { ContextKeyService } from '../context-key-service';
 import { Emitter } from '../../common/event';
 import { waitForRevealed, waitForClosed, PINNED_CLASS, UnsafeWidgetUtilities } from '../widgets';
-import { CorePreferences } from '../core-preferences';
+import { CorePreferences } from '../../common/core-preferences';
 import { BreadcrumbsRendererFactory } from '../breadcrumbs/breadcrumbs-renderer';
 import { Deferred } from '../../common/promise-util';
 import { SaveableService } from '../saveable-service';
@@ -1399,22 +1399,23 @@ export class ApplicationShell extends Widget {
         this.toDisposeOnActivationCheck.push(Disposable.create(() => widget.disposed.disconnect(onDispose)));
 
         let start = 0;
-        const step: FrameRequestCallback = timestamp => {
+        const step: FrameRequestCallback = () => {
             const activeElement = widget.node.ownerDocument.activeElement;
             if (activeElement && widget.node.contains(activeElement)) {
                 return;
             }
+            const now = Date.now();
             if (!start) {
-                start = timestamp;
+                start = now;
             }
-            const delta = timestamp - start;
+            const delta = now - start;
             if (delta < this.activationTimeout) {
-                request = window.requestAnimationFrame(step);
+                request = setTimeout(step, 0);
             } else {
                 console.warn(`Widget was activated, but did not accept focus after ${this.activationTimeout}ms: ${widget.id}`);
             }
         };
-        let request = window.requestAnimationFrame(step);
+        let request = setTimeout(step, 0);
         this.toDisposeOnActivationCheck.push(Disposable.create(() => window.cancelAnimationFrame(request)));
     }
 

package/src/browser/shell/tab-bar-toolbar/tab-bar-toolbar-menu-adapters.tsx

@@ -97,11 +97,11 @@ abstract class AbstractToolbarMenuWrapper {
     protected renderMenuItem(widget: Widget): React.ReactNode {
         const icon = this.icon || 'ellipsis';
         const contextMatcher: ContextMatcher = this.contextKeyService;
+        const className = `${icon} ${ACTION_ITEM}`;
         if (CompoundMenuNode.is(this.menuNode) && !this.menuNode.isEmpty(this.effectiveMenuPath, this.contextKeyService, widget.node)) {
-
             return <div key={this.id} className={TabBarToolbar.Styles.TAB_BAR_TOOLBAR_ITEM + ' enabled menu'}>
-                <div className={codicon(icon, true)}
-                    title={this.text}
+                <div className={className}
+                    title={this.tooltip || this.text}
                     onClick={e => this.executeCommand(e)}
                 />
                 <div className={ACTION_ITEM} onClick={event => this.showPopupMenu(widget, this.menuPath!, event, contextMatcher)} >
@@ -110,8 +110,8 @@ abstract class AbstractToolbarMenuWrapper {
             </div>;
         } else {
             return <div key={this.id} className={TabBarToolbar.Styles.TAB_BAR_TOOLBAR_ITEM + ' enabled menu'}>
-                <div className={codicon(icon, true)}
-                    title={this.text}
+                <div className={className}
+                    title={this.tooltip || this.text}
                     onClick={e => this.executeCommand(e)}
                 />
             </div>;

package/src/browser/shell/tab-bars.ts

@@ -32,7 +32,7 @@ import { BreadcrumbsRenderer, BreadcrumbsRendererFactory } from '../breadcrumbs/
 import { NavigatableWidget } from '../navigatable-types';
 import { Drag } from '@lumino/dragdrop';
 import { LOCKED_CLASS, PINNED_CLASS } from '../widgets/widget';
-import { CorePreferences } from '../core-preferences';
+import { CorePreferences } from '../../common/core-preferences';
 import { HoverService } from '../hover-service';
 import { Root, createRoot } from 'react-dom/client';
 import { SelectComponent } from '../widgets/select-component';

package/src/browser/shell/theia-dock-panel.ts

@@ -18,7 +18,7 @@ import { find, toArray } from '@lumino/algorithm';
 import { TabBar, Widget, DockPanel, Title } from '@lumino/widgets';
 import { Signal } from '@lumino/signaling';
 import { Disposable, DisposableCollection } from '../../common/disposable';
-import { CorePreferences } from '../core-preferences';
+import { CorePreferences } from '../../common/core-preferences';
 import { Emitter, Event, environment } from '../../common';
 import { ToolbarAwareTabBar } from './tab-bars';
 

package/src/browser/status-bar/status-bar.tsx

@@ -21,11 +21,12 @@ import { CommandService } from '../../common';
 import { ReactWidget } from '../widgets/react-widget';
 import { FrontendApplicationStateService } from '../frontend-application-state';
 import { LabelParser, LabelIcon } from '../label-parser';
-import { PreferenceService } from '../preferences';
 import { StatusBar, StatusBarEntry, StatusBarAlignment, StatusBarViewEntry } from './status-bar-types';
 import { StatusBarViewModel } from './status-bar-view-model';
 import { HoverService } from '../hover-service';
 import { codicon } from '../widgets';
+import { PreferenceService } from '../../common/preferences';
+import { MarkdownString } from '../../common/markdown-rendering';
 export { StatusBar, StatusBarAlignment, StatusBarEntry };
 
 @injectable()
@@ -122,7 +123,7 @@ export class StatusBarImpl extends ReactWidget implements StatusBar {
             content: entry.tooltip!,
             target: e.currentTarget,
             position: 'top',
-            interactive: entry.tooltip instanceof HTMLElement,
+            interactive: entry.tooltip instanceof HTMLElement || MarkdownString.is(entry.tooltip),
         });
     }
 

package/src/browser/theming.ts

@@ -14,15 +14,16 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import { Emitter, Event } from '../common/event';
-import { Disposable } from '../common/disposable';
-import { FrontendApplicationConfigProvider } from './frontend-application-config-provider';
 import { ApplicationProps, DefaultTheme } from '@theia/application-package/lib/application-props';
-import { Theme, ThemeChangeEvent } from '../common/theme';
 import { inject, injectable, postConstruct } from 'inversify';
+import { Disposable } from '../common/disposable';
+import { Emitter, Event } from '../common/event';
+import { PreferenceSchemaService } from '../common/preferences/preference-schema';
 import { Deferred } from '../common/promise-util';
-import { PreferenceSchemaProvider, PreferenceService } from './preferences';
+import { Theme, ThemeChangeEvent } from '../common/theme';
+import { FrontendApplicationConfigProvider } from './frontend-application-config-provider';
 import debounce = require('lodash.debounce');
+import { PreferenceService } from '../common/preferences';
 
 const COLOR_THEME_PREFERENCE_KEY = 'workbench.colorTheme';
 const NO_THEME = { id: 'no-theme', label: 'Not a real theme.', type: 'dark' } as const;
@@ -32,7 +33,7 @@ export class ThemeService {
     static readonly STORAGE_KEY = 'theme';
 
     @inject(PreferenceService) protected readonly preferences: PreferenceService;
-    @inject(PreferenceSchemaProvider) protected readonly schemaProvider: PreferenceSchemaProvider;
+    @inject(PreferenceSchemaService) protected readonly schemaProvider: PreferenceSchemaService;
 
     protected themes: { [id: string]: Theme } = {};
     protected activeTheme: Theme = NO_THEME;

package/src/browser/tooltip-service.tsx

@@ -18,8 +18,8 @@ import { injectable, inject, optional, postConstruct } from 'inversify';
 import * as React from 'react';
 import ReactTooltip from 'react-tooltip';
 import { ReactRenderer, RendererHost } from './widgets/react-renderer';
-import { CorePreferences } from './core-preferences';
 import { generateUuid } from '../common/uuid';
+import { CorePreferences } from '../common/core-preferences';
 
 export const TooltipService = Symbol('TooltipService');
 

package/src/browser/tree/index.ts

@@ -26,4 +26,3 @@ export * from './tree-container';
 export * from './tree-decorator';
 export * from './tree-search';
 export * from './tree-compression';
-export * from './tree-preference';

package/src/browser/tree/tree-widget.tsx

@@ -41,11 +41,11 @@ import { ElementExt } from '@lumino/domutils';
 import { TreeWidgetSelection } from './tree-widget-selection';
 import { MaybePromise } from '../../common/types';
 import { LabelProvider } from '../label-provider';
-import { CorePreferences } from '../core-preferences';
+import { CorePreferences } from '../../common/core-preferences';
 import { TreeFocusService } from './tree-focus-service';
 import { useEffect } from 'react';
-import { PreferenceService, PreferenceChange } from '../preferences';
-import { PREFERENCE_NAME_TREE_INDENT } from './tree-preference';
+import { PREFERENCE_NAME_TREE_INDENT } from '../../common/tree-preference';
+import { PreferenceService, PreferenceChange } from '../../common/preferences';
 
 const debounce = require('lodash.debounce');
 
@@ -306,7 +306,7 @@ export class TreeWidget extends ReactWidget implements StatefulWidget {
             }),
             this.preferenceService.onPreferenceChanged((event: PreferenceChange) => {
                 if (event.preferenceName === PREFERENCE_NAME_TREE_INDENT) {
-                    this.treeIndent = event.newValue;
+                    this.treeIndent = event.newValue as number;
                     this.update();
                 }
             })

package/src/browser/widgets/widget.ts

@@ -360,17 +360,17 @@ function waitForVisible(widget: Widget, visible: boolean, attached?: boolean): P
     if ((typeof attached !== 'boolean' || widget.isAttached === attached) &&
         (widget.isVisible === visible || (widget.node.style.visibility !== 'hidden') === visible)
     ) {
-        return new Promise(resolve => window.requestAnimationFrame(() => resolve()));
+        return new Promise(resolve => setTimeout(() => resolve(), 0));
     }
     return new Promise(resolve => {
-        const waitFor = () => window.requestAnimationFrame(() => {
+        const waitFor = () => setTimeout(() => {
             if ((typeof attached !== 'boolean' || widget.isAttached === attached) &&
                 (widget.isVisible === visible || (widget.node.style.visibility !== 'hidden') === visible)) {
-                window.requestAnimationFrame(() => resolve());
+                setTimeout(() => resolve(), 0);
             } else {
                 waitFor();
             }
-        });
+        }, 0);
         waitFor();
     });
 }

package/src/browser/window/default-secondary-window-service.ts

@@ -19,8 +19,7 @@ import { WindowService } from './window-service';
 import { ExtractableWidget } from '../widgets';
 import { ApplicationShell } from '../shell';
 import { Saveable } from '../saveable';
-import { PreferenceService } from '../preferences';
-import { Emitter, environment, Event } from '../../common';
+import { Emitter, environment, Event, PreferenceService } from '../../common';
 import { SaveableService } from '../saveable-service';
 
 @injectable()

package/src/browser/window/default-window-service.spec.ts

@@ -16,7 +16,7 @@
 
 import { Container } from 'inversify';
 import { ContributionProvider } from '../../common';
-import { CorePreferences } from '../core-preferences';
+import { CorePreferences } from '../../common/core-preferences';
 import { FrontendApplicationContribution } from '../frontend-application-contribution';
 import { DefaultWindowService } from './default-window-service';
 import assert = require('assert');

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

@@ -16,7 +16,7 @@
 
 import { inject, injectable, named } from 'inversify';
 import { Event, Emitter } from '../../common';
-import { CorePreferences } from '../core-preferences';
+import { CorePreferences } from '../../common/core-preferences';
 import { ContributionProvider } from '../../common/contribution-provider';
 import { FrontendApplicationContribution, OnWillStopAction } from '../frontend-application-contribution';
 import { WindowService } from './window-service';

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

@@ -17,7 +17,7 @@
 import { inject, injectable, named, postConstruct } from 'inversify';
 import { escapeRegExpCharacters } from '../../common/strings';
 import { Emitter, Event } from '../../common/event';
-import { CorePreferences } from '../core-preferences';
+import { CorePreferences } from '../../common/core-preferences';
 import { FrontendApplicationConfigProvider } from '../frontend-application-config-provider';
 import { ContributionProvider } from '../../common';