@theia/core 1.65.0-next.6 → 1.65.1

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,51 @@ 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
-                            };
+
+            for (const scope of [...this.schemaService.validScopes].reverse()) {
+                const provider = this.getProvider(scope);
+                if (provider) {
+                    const scopeValue: JSONValue | undefined = provider.get(preferenceName);
+                    // Skip if a more specific scope has this preference defined
+                    if (scope > change.scope && scopeValue !== undefined) {
+                        break;
+                    }
+                    // Handle changes in the same scope
+                    if (scope === change.scope) {
+                        const hasNewValue = change.newValue !== undefined || scope === PreferenceScope.Default;
+                        const isResetToUndefined = change.newValue === undefined && scopeValue === undefined; // is reset to undefined (no default value)
+                        if (hasNewValue || isResetToUndefined) {
                             acceptChange(change);
+                            break;
                         }
                     }
-                } else if (change.newValue === undefined && change.scope === PreferenceScope.Default) {
-                    // preference is removed
-                    acceptChange(change);
-                    break;
+                    // Handle fallback to more general scope when preference is reset
+                    if (scope < change.scope && change.newValue === undefined && scopeValue !== undefined) {
+                        // preference is changed to `undefined`, use the value from a more general scope
+                        change = {
+                            ...change,
+                            newValue: scopeValue,
+                            scope
+                        };
+                        acceptChange(change);
+                        break;
+                    }
                 }
             }
         }
@@ -394,10 +397,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 +545,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 +577,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 +598,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/common/stream.ts

@@ -26,6 +26,7 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
 import { DisposableCollection, Disposable } from './disposable';
+import { BinaryBuffer } from './buffer';
 
 export interface ReadableStreamEvents<T> {
 
@@ -205,7 +206,7 @@ export interface ITransformer<Original, Transformed> {
 }
 
 export function newWriteableStream<T>(reducer: Reducer<T>, options?: WriteableStreamOptions): WriteableStream<T> {
-    return new WriteableStreamImpl<T>(reducer);
+    return new WriteableStreamImpl<T>(reducer, options);
 }
 
 export interface WriteableStreamOptions {
@@ -716,3 +717,103 @@ export function transform<Original, Transformed>(stream: ReadableStreamEvents<Or
 
     return target;
 }
+
+/**
+ * Convert File to ReadableStream<BinaryBuffer> for use in services which require ReadableStream
+ */
+export function fileToStream(file: File): ReadableStream<BinaryBuffer> {
+    const ws = newWriteableStream<BinaryBuffer>(BinaryBuffer.concat, { highWaterMark: 0 });
+
+    (async () => {
+        const reader = file.stream().getReader();
+
+        try {
+            while (true) {
+                const { value, done } = await reader.read();
+                if (done) {break;}
+
+                if (value?.byteLength) {
+                    await ws.write(BinaryBuffer.wrap(value));
+                }
+            }
+            ws.end();
+        } catch (e: unknown) {
+            try {
+                await reader.cancel();
+            } catch {}
+
+            ws.error(e instanceof Error ? e : new Error(String(e)));
+        }
+    })();
+
+    return ws as ReadableStream<BinaryBuffer>;
+}
+
+/**
+ * Convert BinaryBufferReadableStream to Web ReadableStream<Uint8Array>
+ */
+export function binaryStreamToWebStream(
+    binaryStream: ReadableStream<BinaryBuffer>,
+    abortSignal?: AbortSignal
+): globalThis.ReadableStream<Uint8Array> {
+    return new globalThis.ReadableStream<Uint8Array>({
+        start(controller) {
+            const cleanup = () => {
+                // Remove all event listeners
+                binaryStream.removeListener('data', onData);
+                binaryStream.removeListener('end', onEnd);
+                binaryStream.removeListener('error', onError);
+            };
+
+            const onAbort = () => {
+                cleanup();
+                controller.error(new Error('Operation aborted'));
+            };
+
+            if (abortSignal?.aborted) {
+                onAbort();
+                return;
+            }
+
+            if (abortSignal) {
+                abortSignal.addEventListener('abort', onAbort, { once: true });
+            }
+
+            const onData = (chunk: BinaryBuffer) => {
+                if (abortSignal?.aborted) {
+                    return;
+                }
+                try {
+                    // Convert BinaryBuffer to Uint8Array efficiently
+                    controller.enqueue(new Uint8Array(chunk.buffer));
+                } catch (error) {
+                    cleanup();
+                    if (abortSignal) {
+                        abortSignal.removeEventListener('abort', onAbort);
+                    }
+                    controller.error(error);
+                }
+            };
+
+            const onEnd = () => {
+                cleanup();
+                if (abortSignal) {
+                    abortSignal.removeEventListener('abort', onAbort);
+                }
+                controller.close();
+            };
+
+            const onError = (error: Error) => {
+                cleanup();
+                if (abortSignal) {
+                    abortSignal.removeEventListener('abort', onAbort);
+                }
+                controller.error(error);
+            };
+
+            binaryStream.on('data', onData);
+            binaryStream.on('end', onEnd);
+            binaryStream.on('error', onError);
+        }
+    });
+}

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';
@@ -175,7 +175,9 @@ export class ElectronMainMenuFactory extends BrowserMainMenuFactory {
         const showDisabled = options?.showDisabled !== false;
         const honorDisabled = options?.honorDisabled !== false;
 
-        if (CompoundMenuNode.is(menu) && menu.children.length && menu.isVisible(menuPath, contextMatcher, options.context, ...args)) {
+        const effectivePath = menu.effectiveMenuPath || menuPath;
+
+        if (CompoundMenuNode.is(menu) && menu.children.length && menu.isVisible(effectivePath, contextMatcher, options.context, ...args)) {
             if (Group.is(menu) && menu.id === 'inline') {
                 return parentItems;
             }
@@ -186,7 +188,7 @@ export class ElectronMainMenuFactory extends BrowserMainMenuFactory {
             }
             const children = menu.children;
             const myItems: MenuDto[] = [];
-            children.forEach(child => this.fillMenuTemplate(myItems, [...menuPath, child.id], child, args, contextMatcher, options, false));
+            children.forEach(child => this.fillMenuTemplate(myItems, [...effectivePath, child.id], child, args, contextMatcher, options, false));
             if (myItems.length === 0) {
                 return parentItems;
             }
@@ -200,12 +202,12 @@ export class ElectronMainMenuFactory extends BrowserMainMenuFactory {
                 parentItems.push({ type: 'separator' });
             }
         } else if (CommandMenu.is(menu)) {
-            if (!menu.isVisible(menuPath, contextMatcher, options.context, ...args)) {
+            if (!menu.isVisible(effectivePath, contextMatcher, options.context, ...args)) {
                 return parentItems;
             }
 
             // We should omit rendering context-menu items which are disabled.
-            if (!showDisabled && !menu.isEnabled(menuPath, ...args)) {
+            if (!showDisabled && !menu.isEnabled(effectivePath, ...args)) {
                 return parentItems;
             }
 
@@ -214,15 +216,15 @@ export class ElectronMainMenuFactory extends BrowserMainMenuFactory {
             const menuItem: MenuDto = {
                 id: menu.id,
                 label: menu.label,
-                type: menu.isToggled(menuPath, ...args) ? 'checkbox' : 'normal',
-                checked: menu.isToggled(menuPath, ...args),
-                enabled: !honorDisabled || menu.isEnabled(menuPath, ...args), // see https://github.com/eclipse-theia/theia/issues/446
+                type: menu.isToggled(effectivePath, ...args) ? 'checkbox' : 'normal',
+                checked: menu.isToggled(effectivePath, ...args),
+                enabled: !honorDisabled || menu.isEnabled(effectivePath, ...args), // see https://github.com/eclipse-theia/theia/issues/446
                 visible: true,
                 accelerator,
                 execute: async () => {
                     const wasToggled = menuItem.checked;
-                    await menu.run(menuPath, ...args);
-                    const isToggled = menu.isToggled(menuPath, ...args);
+                    await menu.run(effectivePath, ...args);
+                    const isToggled = menu.isToggled(effectivePath, ...args);
                     if (isToggled !== wasToggled) {
                         menuItem.type = isToggled ? 'checkbox' : 'normal';
                         menuItem.checked = isToggled;

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/preload.ts

@@ -27,7 +27,7 @@ import {
     CHANNEL_REQUEST_RELOAD, CHANNEL_APP_STATE_CHANGED, CHANNEL_SHOW_ITEM_IN_FOLDER, CHANNEL_READ_CLIPBOARD, CHANNEL_WRITE_CLIPBOARD,
     CHANNEL_KEYBOARD_LAYOUT_CHANGED, CHANNEL_IPC_CONNECTION, InternalMenuDto, CHANNEL_REQUEST_SECONDARY_CLOSE, CHANNEL_SET_BACKGROUND_COLOR,
     CHANNEL_WC_METADATA, CHANNEL_ABOUT_TO_CLOSE, CHANNEL_OPEN_WITH_SYSTEM_APP,
-    CHANNEL_OPEN_URL, CHANNEL_SET_THEME
+    CHANNEL_OPEN_URL, CHANNEL_SET_THEME, CHANNEL_OPEN_DEVTOOLS_FOR_WINDOW
 } from '../electron-common/electron-api';
 
 // eslint-disable-next-line import/no-extraneous-dependencies
@@ -200,6 +200,9 @@ const api: TheiaCoreAPI = {
     toggleDevTools: function (): void {
         ipcRenderer.send(CHANNEL_TOGGLE_DEVTOOLS);
     },
+    openDevToolsForWindow: function (windowName: string): void {
+        ipcRenderer.send(CHANNEL_OPEN_DEVTOOLS_FOR_WINDOW, windowName);
+    },
     getZoomLevel: function (): Promise<number> {
         return ipcRenderer.invoke(CHANNEL_GET_ZOOM_LEVEL);
     },

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

@@ -48,10 +48,13 @@ export class ElectronSecondaryWindowService extends DefaultSecondaryWindowServic
 
     protected override windowCreated(newWindow: Window, widget: ExtractableWidget, shell: ApplicationShell): void {
         window.electronTheiaCore.setMenuBarVisible(false, newWindow.name);
-        window.electronTheiaCore.setSecondaryWindowCloseRequestHandler(newWindow.name, () => this.canClose(widget, shell));
+        window.electronTheiaCore.setSecondaryWindowCloseRequestHandler(newWindow.name, () => this.canClose(widget, shell, newWindow));
+
+        // Below code may be used to debug contents of secondary window
+        // window.electronTheiaCore.openDevToolsForWindow(newWindow.name);
     }
-    private async canClose(widget: ExtractableWidget, shell: ApplicationShell): Promise<boolean> {
-        await shell.closeWidget(widget.id);
-        return widget.isDisposed;
+    private async canClose(extractableWidget: ExtractableWidget, shell: ApplicationShell, newWindow: Window): Promise<boolean> {
+        return this.restoreWidgets(newWindow, extractableWidget, shell);
     }
+
 }

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';

package/src/electron-common/electron-api.ts

@@ -83,6 +83,7 @@ export interface TheiaCoreAPI {
     setSecondaryWindowCloseRequestHandler(windowName: string, handler: () => Promise<boolean>): void;
 
     toggleDevTools(): void;
+    openDevToolsForWindow(windowName: string): void;
     getZoomLevel(): Promise<number>;
     setZoomLevel(desired: number): void;
 
@@ -141,6 +142,7 @@ export const CHANNEL_OPEN_URL = 'OpenUrl';
 export const CHANNEL_UNMAXIMIZE = 'UnMaximize';
 export const CHANNEL_ON_WINDOW_EVENT = 'OnWindowEvent';
 export const CHANNEL_TOGGLE_DEVTOOLS = 'ToggleDevtools';
+export const CHANNEL_OPEN_DEVTOOLS_FOR_WINDOW = 'OpenDevtoolsForWindow';
 export const CHANNEL_GET_ZOOM_LEVEL = 'GetZoomLevel';
 export const CHANNEL_SET_ZOOM_LEVEL = 'SetZoomLevel';
 export const CHANNEL_IS_FULL_SCREENABLE = 'IsFullScreenable';

package/src/{electron-browser/window → electron-common}/electron-window-preferences.ts

@@ -15,9 +15,10 @@
 // *****************************************************************************
 
 import { interfaces } from 'inversify';
-import { nls } from '../../common/nls';
-import { createPreferenceProxy, PreferenceContribution, PreferenceProxy, PreferenceSchema, PreferenceService } from '../../browser/preferences';
-import { isOSX, isWindows } from '../../common';
+import { nls } from '../common/nls';
+import { isOSX, isWindows } from '../common';
+import { PreferenceContribution, PreferenceSchema } from '../common/preferences/preference-schema';
+import { createPreferenceProxy, PreferenceProxy, PreferenceScope, PreferenceService } from '../common/preferences';
 
 export namespace ZoomLevel {
     export const DEFAULT = 0;
@@ -29,14 +30,13 @@ export namespace ZoomLevel {
 }
 
 export const electronWindowPreferencesSchema: PreferenceSchema = {
-    type: 'object',
     properties: {
         'window.zoomLevel': {
             'type': 'number',
             'default': ZoomLevel.DEFAULT,
             'minimum': ZoomLevel.MIN,
             'maximum': ZoomLevel.MAX,
-            'scope': 'application',
+            'scope': PreferenceScope.User,
             // eslint-disable-next-line max-len
             'description': nls.localizeByDefault("Adjust the default zoom level for all windows. Each increment above `0` (e.g. `1`) or below (e.g. `-1`) represents zooming `20%` larger or smaller. You can also enter decimals to adjust the zoom level with a finer granularity. See {0} for configuring if the 'Zoom In' and 'Zoom Out' commands apply the zoom level to all windows or only the active window.")
         },
@@ -44,7 +44,7 @@ export const electronWindowPreferencesSchema: PreferenceSchema = {
             type: 'string',
             enum: ['native', 'custom'],
             default: isWindows ? 'custom' : 'native',
-            scope: 'application',
+            scope: PreferenceScope.User,
             // eslint-disable-next-line max-len
             description: nls.localizeByDefault('Adjust the appearance of the window title bar to be native by the OS or custom. On Linux and Windows, this setting also affects the application and context menu appearances. Changes require a full restart to apply.'),
             included: !isOSX