@theia/core 1.65.0-next.6 → 1.65.0

package/src/browser/view-container.ts

@@ -23,7 +23,7 @@ import {
 import { Event as CommonEvent, Emitter } from '../common/event';
 import { Disposable, DisposableCollection } from '../common/disposable';
 import { CommandRegistry } from '../common/command';
-import { MenuModelRegistry, MenuPath, MenuAction, SubmenuImpl, ActionMenuNode, MenuNode, RenderedMenuNode } from '../common/menu';
+import { MenuModelRegistry, MenuPath, MenuAction, SubmenuImpl, ActionMenuNode, Submenu } from '../common/menu';
 import { ApplicationShell, StatefulWidget, SplitPositionHandler, SplitPositionOptions, SIDE_PANEL_TOOLBAR_CONTEXT_MENU } from './shell';
 import { MAIN_AREA_ID, BOTTOM_AREA_ID } from './shell/theia-dock-panel';
 import { FrontendApplicationStateService } from './frontend-application-state';
@@ -40,7 +40,7 @@ import { ElementExt } from '@lumino/domutils';
 import { TabBarDecoratorService } from './shell/tab-bar-decorator';
 import { ContextKeyService } from './context-key-service';
 import { KeybindingRegistry } from './keybinding';
-import { ToolbarMenuNodeWrapper } from './shell/tab-bar-toolbar/tab-bar-toolbar-menu-adapters';
+import { SubmenuAsToolbarItemWrapper } from './shell/tab-bar-toolbar/tab-bar-toolbar-menu-adapters';
 import { TheiaSplitPanel } from './shell/theia-split-panel';
 
 export interface ViewContainerTitleOptions {
@@ -94,7 +94,7 @@ export namespace DynamicToolbarWidget {
     }
 }
 
-class PartsMenuToolbarItem extends ToolbarMenuNodeWrapper {
+class PartsMenuToolbarItem extends SubmenuAsToolbarItemWrapper {
     constructor(
         protected readonly target: () => Widget | undefined,
         effectiveMenuPath: MenuPath,
@@ -102,11 +102,11 @@ class PartsMenuToolbarItem extends ToolbarMenuNodeWrapper {
         menuRegistry: MenuModelRegistry,
         contextKeyService: ContextKeyService,
         contextMenuRenderer: ContextMenuRenderer,
-        menuNode: MenuNode & RenderedMenuNode,
+        menuNode: Submenu,
         group: string | undefined,
         menuPath?: MenuPath,
     ) {
-        super(effectiveMenuPath, commandRegistry, menuRegistry, contextKeyService, contextMenuRenderer, menuNode, group, menuPath);
+        super(effectiveMenuPath, commandRegistry, menuRegistry, contextKeyService, contextMenuRenderer, menuNode, group);
     }
 
     override isVisible(widget: Widget): boolean {

package/src/browser/widgets/extractable-widget.ts

@@ -14,6 +14,7 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
+import { ApplicationShell } from '../shell';
 import { Widget } from './widget';
 
 /**
@@ -24,6 +25,8 @@ export interface ExtractableWidget extends Widget {
     isExtractable: boolean;
     /** The secondary window that the window was extracted to or `undefined` if it is not yet extracted. */
     secondaryWindow: Window | undefined;
+    /** Stores the area which contained the widget before being extracted. This is undefined if the widget wasn't extracted or if the area could not be determined */
+    previousArea?: ApplicationShell.Area;
 }
 
 export namespace ExtractableWidget {

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

@@ -14,14 +14,14 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 import { inject, injectable, postConstruct } from 'inversify';
-import { SecondaryWindowService } from './secondary-window-service';
+import { SecondaryWindow, SecondaryWindowService } from './secondary-window-service';
 import { WindowService } from './window-service';
-import { ExtractableWidget } from '../widgets';
+import { ExtractableWidget, Widget } 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';
+import { getAllWidgetsFromSecondaryWindow, getDefaultRestoreArea } from '../secondary-window-handler';
 
 @injectable()
 export class DefaultSecondaryWindowService implements SecondaryWindowService {
@@ -29,6 +29,8 @@ export class DefaultSecondaryWindowService implements SecondaryWindowService {
     readonly onWindowOpened: Event<Window> = this.onWindowOpenedEmitter.event;
     protected readonly onWindowClosedEmitter = new Emitter<Window>;
     readonly onWindowClosed: Event<Window> = this.onWindowClosedEmitter.event;
+    protected readonly beforeWidgetRestoreEmitter = new Emitter<[Widget, Window]>;
+    readonly beforeWidgetRestore: Event<[Widget, Window]> = this.beforeWidgetRestoreEmitter.event;
     // secondary-window.html is part of Theia's generated code. It is generated by dev-packages/application-manager/src/generator/frontend-generator.ts
     protected static SECONDARY_WINDOW_URL = 'secondary-window.html';
 
@@ -93,7 +95,7 @@ export class DefaultSecondaryWindowService implements SecondaryWindowService {
         });
     }
 
-    createSecondaryWindow(widget: ExtractableWidget, shell: ApplicationShell): Window | undefined {
+    createSecondaryWindow(widget: ExtractableWidget, shell: ApplicationShell): Window | SecondaryWindow | undefined {
         const [height, width, left, top] = this.findSecondaryWindowCoordinates(widget);
         let options = `popup=1,width=${width},height=${height},left=${left},top=${top}`;
         if (this.preferenceService.get('window.secondaryWindowAlwaysOnTop')) {
@@ -105,21 +107,19 @@ export class DefaultSecondaryWindowService implements SecondaryWindowService {
             this.onWindowOpenedEmitter.fire(newWindow);
             newWindow.addEventListener('DOMContentLoaded', () => {
                 newWindow.addEventListener('beforeunload', evt => {
-                    const saveable = Saveable.get(widget);
-                    const wouldLoseState = !!saveable && saveable.dirty && this.saveResourceService.autoSave === 'off';
-                    if (wouldLoseState) {
-                        evt.returnValue = '';
-                        evt.preventDefault();
-                        return 'non-empty';
+                    const widgets = getAllWidgetsFromSecondaryWindow(newWindow) ?? [widget];
+                    for (const w of widgets) {
+                        const saveable = Saveable.get(w);
+                        const wouldLoseState = !!saveable && saveable.dirty && this.saveResourceService.autoSave === 'off';
+                        if (wouldLoseState) {
+                            evt.returnValue = '';
+                            evt.preventDefault();
+                            return 'non-empty';
+                        }
                     }
                 }, { capture: true });
 
                 newWindow.addEventListener('unload', () => {
-                    const saveable = Saveable.get(widget);
-                    shell.closeWidget(widget.id, {
-                        save: !!saveable && saveable.dirty && this.saveResourceService.autoSave !== 'off'
-                    });
-
                     const extIndex = this.secondaryWindows.indexOf(newWindow);
                     if (extIndex > -1) {
                         this.onWindowClosedEmitter.fire(newWindow);
@@ -129,12 +129,13 @@ export class DefaultSecondaryWindowService implements SecondaryWindowService {
                 this.windowCreated(newWindow, widget, shell);
             });
         }
+        (newWindow as SecondaryWindow).rootWidget = undefined;
         return newWindow;
     }
 
     protected windowCreated(newWindow: Window, widget: ExtractableWidget, shell: ApplicationShell): void {
         newWindow.addEventListener('unload', () => {
-            shell.closeWidget(widget.id);
+            this.restoreWidgets(newWindow, widget, shell);
         });
     }
 
@@ -200,4 +201,40 @@ export class DefaultSecondaryWindowService implements SecondaryWindowService {
     protected nextWindowId(): string {
         return `${this.prefix}-secondaryWindow-${this.nextId++}`;
     }
+
+    /**
+     * Restore the widgets back to the main window. SecondaryWindowHandler needs to get informated about this.
+     */
+    protected async restoreWidgets(newWindow: Window, extractableWidget: ExtractableWidget, shell: ApplicationShell): Promise<boolean> {
+        const widgets = getAllWidgetsFromSecondaryWindow(newWindow) ?? new Set([extractableWidget]);
+        const defaultRestoreArea = getDefaultRestoreArea(newWindow);
+
+        let allMovedOrDisposed = true;
+        for (const widget of widgets) {
+            if (widget.isDisposed) {
+                continue;
+            }
+            try {
+                const preferredRestoreArea = ExtractableWidget.is(widget) ? widget.previousArea : defaultRestoreArea;
+                const area = (preferredRestoreArea === undefined || preferredRestoreArea === 'top' || preferredRestoreArea === 'secondaryWindow') ? 'main' : preferredRestoreArea;
+                // fire removed event before adding it to shell
+                this.beforeWidgetRestoreEmitter.fire([widget, newWindow]);
+                // reset ExtractableWidget properties before moving back so that handler evaluation is correct immediately
+                if (ExtractableWidget.is(widget)) {
+                    widget.secondaryWindow = undefined;
+                    widget.previousArea = undefined;
+                }
+                await shell.addWidget(widget, { area });
+                await shell.activateWidget(widget.id);
+            } catch (e) {
+                // we can't move back, close instead
+                // otherwise the window will just stay open with no way to close it
+                await shell.closeWidget(widget.id);
+                if (!widget.isDisposed) {
+                    allMovedOrDisposed = false;
+                }
+            }
+        }
+        return allMovedOrDisposed;
+    }
 }

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/secondary-window-service.ts

@@ -16,7 +16,27 @@
 
 import { Event } from '../../common';
 import { ApplicationShell } from '../shell';
-import { ExtractableWidget } from '../widgets';
+import { TheiaDockPanel } from '../shell/theia-dock-panel';
+import { ExtractableWidget, TabBar, Widget } from '../widgets';
+
+export abstract class SecondaryWindowRootWidget extends Widget {
+    secondaryWindow: Window | SecondaryWindow;
+    defaultRestoreArea?: ApplicationShell.Area;
+    abstract widgets: ReadonlyArray<Widget>;
+    abstract addWidget(widget: Widget, disposeCallback: () => void, options?: TheiaDockPanel.AddOptions): void;
+    getTabBar?(widget: Widget): TabBar<Widget> | undefined;
+}
+
+export interface SecondaryWindow extends Window {
+    rootWidget: SecondaryWindowRootWidget | undefined;
+}
+
+export function isSecondaryWindow(window: unknown): window is SecondaryWindow {
+    if (!window) {
+        return false;
+    }
+    return typeof window === 'object' && 'rootWidget' in window;
+}
 
 export const SecondaryWindowService = Symbol('SecondaryWindowService');
 
@@ -33,9 +53,10 @@ export interface SecondaryWindowService {
      * @param onClose optional callback that is invoked when the secondary window is closed
      * @returns the created window or `undefined` if it could not be created
      */
-    createSecondaryWindow(widget: ExtractableWidget, shell: ApplicationShell): Window | undefined;
+    createSecondaryWindow(widget: ExtractableWidget, shell: ApplicationShell): SecondaryWindow | Window | undefined;
     readonly onWindowOpened: Event<Window>;
     readonly onWindowClosed: Event<Window>;
+    readonly beforeWidgetRestore: Event<[Widget, Window]>;
 
     /** Handles focussing the given secondary window in the browser and on Electron. */
     focus(win: Window): void;

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

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

@@ -16,12 +16,12 @@
 
 import { interfaces } from 'inversify';
 import { environment } from '@theia/application-package/lib/environment';
-import { createPreferenceProxy, PreferenceProxy, PreferenceService, PreferenceContribution, PreferenceSchema } from './preferences';
 import { SUPPORTED_ENCODINGS } from './supported-encodings';
-import { FrontendApplicationConfigProvider } from './frontend-application-config-provider';
 import { isOSX } from '../common/os';
 import { nls } from '../common/nls';
-import { DefaultTheme } from '@theia/application-package/lib/application-props';
+import { PreferenceContribution, PreferenceSchema } from '../common/preferences/preference-schema';
+import { createPreferenceProxy, PreferenceProxy, PreferenceService } from '../common/preferences';
+import { PreferenceScope } from '../common/preferences/preference-scope';
 
 /* eslint-disable max-len */
 const windowTitleDescription = [
@@ -43,7 +43,6 @@ const windowTitleDescription = [
 ].join('\n- ');
 
 export const corePreferenceSchema: PreferenceSchema = {
-    'type': 'object',
     properties: {
         'application.confirmExit': {
             type: 'string',
@@ -59,7 +58,7 @@ export const corePreferenceSchema: PreferenceSchema = {
             'type': 'boolean',
             'default': true,
             'description': nls.localizeByDefault('Enable/disable navigation breadcrumbs.'),
-            'scope': 'application'
+            'scope': PreferenceScope.User
         },
         'files.encoding': {
             'type': 'string',
@@ -67,7 +66,7 @@ export const corePreferenceSchema: PreferenceSchema = {
             'default': 'utf8',
             'description': nls.localizeByDefault(
                 'The default character set encoding to use when reading and writing files. This setting can also be configured per language.'),
-            'scope': 'language-overridable',
+            'scope': PreferenceScope.Folder,
             'enumDescriptions': Object.keys(SUPPORTED_ENCODINGS).map(key => SUPPORTED_ENCODINGS[key].labelLong),
             'included': Object.keys(SUPPORTED_ENCODINGS).length > 1
         },
@@ -103,7 +102,7 @@ export const corePreferenceSchema: PreferenceSchema = {
                     : nls.localizeByDefault('Menu is displayed as a compact button in the side bar.')
             ],
             default: 'classic',
-            scope: 'application',
+            scope: PreferenceScope.User,
             markdownDescription: nls.localizeByDefault("Control the visibility of the menu bar. A setting of 'toggle' means that the menu bar is hidden and a single press of the Alt key will show it. A setting of 'compact' will move the menu into the side bar."),
             included: !(isOSX && environment.electron.is())
         },
@@ -112,13 +111,13 @@ export const corePreferenceSchema: PreferenceSchema = {
             default: isOSX
                 ? '${activeEditorShort}${separator}${rootName}'
                 : '${dirty} ${activeEditorShort}${separator}${rootName}${separator}${appName}',
-            scope: 'application',
+            scope: PreferenceScope.User,
             markdownDescription: windowTitleDescription
         },
         'window.titleSeparator': {
             type: 'string',
             default: ' - ',
-            scope: 'application',
+            scope: PreferenceScope.User,
             markdownDescription: nls.localizeByDefault('Separator used by {0}.', '`#window.title#`')
         },
         'window.tabCloseIconPlacement': {
@@ -129,7 +128,7 @@ export const corePreferenceSchema: PreferenceSchema = {
                 nls.localize('theia/core/window/tabCloseIconPlacement/start', 'Place the close icon at the start of the label. In left-to-right languages, this is the left side of the tab.'),
             ],
             default: 'end',
-            scope: 'application',
+            scope: PreferenceScope.User,
             description: nls.localize('theia/core/window/tabCloseIconPlacement/description', 'Place the close icons on tab titles at the start or end of the tab. The default is end on all platforms.'),
             included: isOSX
         },
@@ -153,18 +152,18 @@ export const corePreferenceSchema: PreferenceSchema = {
             type: 'string',
             pattern: '^https?://([^:]*(:[^@]*)?@)?([^:]+|\\[[:0-9a-fA-F]+\\])(:\\d+)?/?$|^$',
             markdownDescription: nls.localizeByDefault('The proxy setting to use. If not set, will be inherited from the `http_proxy` and `https_proxy` environment variables. When during [remote development](https://aka.ms/vscode-remote) the {0} setting is disabled this setting can be configured in the local and the remote settings separately.'),
-            scope: 'application'
+            scope: PreferenceScope.User
         },
         'http.proxyStrictSSL': {
             type: 'boolean',
             default: true,
             description: nls.localizeByDefault('Controls whether the proxy server certificate should be verified against the list of supplied CAs. When during [remote development](https://aka.ms/vscode-remote) the {0} setting is disabled this setting can be configured in the local and the remote settings separately.'),
-            scope: 'application'
+            scope: PreferenceScope.User
         },
         'http.proxyAuthorization': {
             type: 'string',
             markdownDescription: nls.localizeByDefault('The value to send as the `Proxy-Authorization` header for every network request. When during [remote development](https://aka.ms/vscode-remote) the {0} setting is disabled this setting can be configured in the local and the remote settings separately.'),
-            scope: 'application'
+            scope: PreferenceScope.User
         },
         'http.proxySupport': {
             type: 'string',
@@ -177,13 +176,13 @@ export const corePreferenceSchema: PreferenceSchema = {
             ],
             default: 'override',
             description: nls.localizeByDefault('Use the proxy support for extensions. When during [remote development](https://aka.ms/vscode-remote) the {0} setting is disabled this setting can be configured in the local and the remote settings separately.'),
-            scope: 'application'
+            scope: PreferenceScope.User
         },
         'http.systemCertificates': {
             type: 'boolean',
             default: true,
             description: nls.localizeByDefault('Controls whether CA certificates should be loaded from the OS. On Windows and macOS, a reload of the window is required after turning this off. When during [remote development](https://aka.ms/vscode-remote) the {0} setting is disabled this setting can be configured in the local and the remote settings separately.'),
-            scope: 'application'
+            scope: PreferenceScope.User
         },
         'workbench.list.openMode': {
             type: 'string',
@@ -229,14 +228,14 @@ export const corePreferenceSchema: PreferenceSchema = {
             type: 'string',
             enum: ['dark', 'light', 'hc-theia'],
             enumItemLabels: ['Dark (Theia)', 'Light (Theia)', 'High Contrast (Theia)'],
-            default: DefaultTheme.defaultForOSTheme(FrontendApplicationConfigProvider.get().defaultTheme),
+            default: 'light',
             description: nls.localizeByDefault('Specifies the color theme used in the workbench when {0} is not enabled.', '`#window.autoDetectColorScheme#`')
         },
         'workbench.iconTheme': {
             type: ['string'],
             enum: ['none', 'theia-file-icons'],
             enumItemLabels: [nls.localizeByDefault('None'), 'File Icons (Theia)'],
-            default: FrontendApplicationConfigProvider.get().defaultIconTheme,
+            default: 'none',
             description: nls.localizeByDefault("Specifies the file icon theme used in the workbench or 'null' to not show any file icons.")
         },
         'workbench.silentNotifications': {

package/src/common/index.ts

@@ -20,8 +20,10 @@ export * from './cancellation';
 export * from './command';
 export * from './contribution-filter';
 export * from './contribution-provider';
+export * from './core-preferences';
 export * from './disposable';
 export * from './event';
+export * from './inversify-utils';
 export * from './listener';
 export * from './logger';
 export * from './lsp-types';
@@ -36,6 +38,7 @@ export * from './objects';
 export * from './os';
 export * from './path';
 export * from './performance';
+export * from './preferences';
 export * from './progress-service';
 export * from './progress-service-protocol';
 export * from './quick-pick-service';
@@ -45,6 +48,7 @@ export * from './selection';
 export * from './selection-service';
 export * from './strings';
 export * from './telemetry';
+export * from './tree-preference';
 export * from './types';
 export { default as URI } from './uri';
 export * from './uuid';

package/src/common/inversify-utils.ts

@@ -0,0 +1,63 @@
+// *****************************************************************************
+// Copyright (C) 2025 STMicroelectronics and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { interfaces, Container } from 'inversify';
+
+/**
+ * This utility creates a factory function that accepts runtime arguments which are bound as constant
+ * values in a child container, allowing for dependency injection of both static dependencies
+ * (resolved as usual from the factory's container) and dynamic parameters (provided at factory invocation time).
+ *
+ * @example
+ * ```typescript
+ * // Factory interface
+ * interface UserPreferenceProviderFactory {
+ *     (uri: URI, section: string): UserPreferenceProvider;
+ * }
+ * // Factory symbol
+ * const UserPreferenceProviderFactory = Symbol('UserPreferenceProviderFactory');
+ *
+ * // Bind the factory
+ * bindFactory(
+ *     bind,
+ *     UserPreferenceProviderFactory,   // Service identifier of the factory
+ *     UserPreferenceProvider,          // Service identifier of the entity to be constructed
+ *     SectionPreferenceProviderUri,    // The first factory argument will be bound to this identifier (uri)
+ *     SectionPreferenceProviderSection // The second factory argument will be bound to this identifier  (section)
+ * );
+ *
+ * // Usage: factory(uri, section) creates UserPreferenceProvider with injected dependencies
+ * const factory = container.get(UserPreferenceProviderFactory);
+ * const provider = factory(myUri, 'settings');
+ * ```
+ */
+
+export function bindFactory<F, C>(bind: interfaces.Bind,
+    factoryId: interfaces.ServiceIdentifier<F>,
+    constructor: interfaces.Newable<C>,
+    ...parameterBindings: interfaces.ServiceIdentifier<unknown>[]): void {
+    bind(factoryId).toFactory(ctx =>
+        (...args: unknown[]) => {
+            const child = new Container({ defaultScope: 'Singleton' });
+            child.parent = ctx.container;
+            for (let i = 0; i < parameterBindings.length; i++) {
+                child.bind(parameterBindings[i]).toConstantValue(args[i]);
+            }
+            child.bind(constructor).to(constructor);
+            return child.get(constructor);
+        }
+    );
+}

package/src/common/json-schema.ts

@@ -87,6 +87,7 @@ export interface IJSONSchema {
     errorMessage?: string; // VSCode extension
     patternErrorMessage?: string; // VSCode extension
     deprecationMessage?: string; // VSCode extension
+    markdownDeprecationMessage?: string; // VS code extension
     enumItemLabels?: string[]; // VSCode extension
     enumDescriptions?: string[]; // VSCode extension
     markdownEnumDescriptions?: string[]; // VSCode extension

package/src/common/menu/menu-types.ts

@@ -39,6 +39,8 @@ export interface MenuNode {
      * Menu nodes are sorted in ascending order based on their `sortString`.
      */
     readonly sortString: string;
+
+    readonly effectiveMenuPath?: string[]; // override the path to be passed as the effectiveMenuPath
     isVisible<T>(effectiveMenuPath: MenuPath, contextMatcher: ContextExpressionMatcher<T>, context: T | undefined, ...args: unknown[]): boolean;
     onDidChange?: Event<void>;
 }

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

@@ -0,0 +1,91 @@
+// *****************************************************************************
+// Copyright (C) 2025 STMicroelectronics and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+
+import { JSONObject, JSONValue } from '@lumino/coreutils';
+import { PreferenceScope } from './preference-scope';
+import { PreferenceProvider, PreferenceProviderDataChange, PreferenceProviderDataChanges, PreferenceResolveResult } from './preference-provider';
+import { inject, injectable, postConstruct } from 'inversify';
+import { PreferenceSchemaService } from './preference-schema';
+import { Deferred } from '../promise-util';
+import { PreferenceLanguageOverrideService } from './preference-language-override-service';
+import { PreferenceProviderBase } from './preference-provider-impl';
+
+// *****************************************************************************
+
+@injectable()
+export class DefaultsPreferenceProvider extends PreferenceProviderBase implements PreferenceProvider {
+
+    @inject(PreferenceSchemaService)
+    protected readonly preferenceSchemaService: PreferenceSchemaService;
+
+    @inject(PreferenceLanguageOverrideService)
+    protected readonly preferenceOverrideService: PreferenceLanguageOverrideService;
+
+    protected readonly _ready = new Deferred<void>();
+    ready: Promise<void> = this._ready.promise;
+
+    @postConstruct()
+    init(): void {
+        this.toDispose.push(this.preferenceSchemaService.onDidChangeDefaultValue(e => {
+            const changes: PreferenceProviderDataChanges = {};
+            if (e.overrideIdentifier) {
+                changes[e.key] = this.changeFor(e.key, e.overrideIdentifier, e.oldValue, e.newValue);
+            } else {
+                changes[e.key] = this.changeFor(e.key, undefined, e.oldValue, e.newValue);
+                for (const override of e.otherAffectedOverrides) {
+                    const change = this.changeFor(e.key, override, e.oldValue, e.newValue);
+                    changes[change.preferenceName] = change;
+                }
+            }
+            this.emitPreferencesChangedEvent(changes);
+        }));
+        this._ready.resolve();
+    }
+
+    protected changeFor(key: string, overrideIdentifier: string | undefined, oldValue: JSONValue | undefined, newValue: JSONValue | undefined): PreferenceProviderDataChange {
+        const preferenceName = overrideIdentifier ? this.preferenceOverrideService.overridePreferenceName({ preferenceName: key, overrideIdentifier }) : key;
+
+        return {
+            preferenceName: preferenceName,
+            newValue: newValue,
+            oldValue: oldValue,
+            scope: PreferenceScope.Default
+        };
+    }
+
+    canHandleScope(scope: PreferenceScope): boolean {
+        return scope === PreferenceScope.Default;
+    }
+    get<T>(preferenceName: string, resourceUri?: string): T | undefined {
+        const overrideInfo = this.preferenceOverrideService.overriddenPreferenceName(preferenceName);
+        return this.preferenceSchemaService.getDefaultValue(overrideInfo?.preferenceName ?? preferenceName, overrideInfo?.overrideIdentifier) as T;
+    }
+
+    setPreference(key: string, value: JSONValue, resourceUri?: string): Promise<boolean> {
+        return Promise.resolve(false);
+    }
+
+    resolve<T>(preferenceName: string, resourceUri?: string): PreferenceResolveResult<T> {
+        const overrideInfo = this.preferenceOverrideService.overriddenPreferenceName(preferenceName);
+        return {
+            value: this.preferenceSchemaService.inspectDefaultValue(overrideInfo?.preferenceName ?? preferenceName, overrideInfo?.overrideIdentifier) as T,
+            configUri: undefined
+        };
+    }
+
+    getPreferences(): JSONObject {
+        return this.preferenceSchemaService.getDefaultValues();
+    }
+}

package/src/common/preferences/index.ts

@@ -0,0 +1,27 @@
+// *****************************************************************************
+// Copyright (C) 2025 STMicroelectronics and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+export * from './defaults-preference-provider';
+export * from './preference-language-override-service';
+export * from './preference-provider-impl';
+export * from './preference-provider';
+export * from './preference-schema-service';
+export * from './preference-schema';
+export * from './preference-scope';
+export * from './preference-service';
+export * from './injectable-preference-proxy';
+export * from './preference-proxy';
+export * from './preference-configurations';