@theia/core 1.76.0-next.7 → 1.76.0

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

@@ -0,0 +1,245 @@
+// *****************************************************************************
+// Copyright (C) 2026 Safi Seid-Ahmad, K2view 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 { enableJSDOM } from '../test/jsdom';
+
+// The widget module transitively imports `@lumino/widgets`, which touches `document` at load time.
+let disableJSDOM = enableJSDOM();
+
+import { expect } from 'chai';
+import { flushSync } from 'react-dom';
+import { createRoot, Root } from 'react-dom/client';
+import { CompositeTreeNode, TreeNode } from './tree';
+import { ExpandableTreeNode } from './tree-expansion';
+import { TreeFocusService } from './tree-focus-service';
+import { TreeModel } from './tree-model';
+import { defaultTreeProps, TreeWidget } from './tree-widget';
+import { ContextMenuRenderer } from '../context-menu-renderer';
+
+disableJSDOM();
+
+class CountingView extends TreeWidget.View {
+    scrollCount = 0;
+    protected override readonly scrollIntoViewIfNeeded = (): void => {
+        if (this.list && this.props.scrollToRow !== undefined) {
+            this.scrollCount++;
+        }
+    };
+}
+
+class TestTreeWidget extends TreeWidget {
+    focusedNode: TreeNode | undefined;
+    scrollToSelectedCount = 0;
+    override update(): void { }
+    protected override scrollToSelected(): void {
+        this.scrollToSelectedCount++;
+    }
+    get RowRenderer(): typeof this.ScrollingRowRenderer {
+        return this.ScrollingRowRenderer;
+    }
+    get currentScrollToRow(): number | undefined {
+        return this.scrollToRow;
+    }
+    get currentScrollToRowRequestId(): number {
+        return this.scrollToRowRequestId;
+    }
+    requestScrollToFocus(): void {
+        this.updateScrollToRow();
+    }
+    doUpdateRowsNow(): void {
+        this.doUpdateRows();
+    }
+}
+
+function createTreeRoot(...children: TreeNode[]): CompositeTreeNode {
+    const root: CompositeTreeNode = { id: 'root', name: 'root', parent: undefined, visible: false, children: [] };
+    return CompositeTreeNode.addChildren(root, children);
+}
+
+function leaf(id: string): TreeNode {
+    return { id, name: id, parent: undefined, visible: true };
+}
+
+describe('TreeWidget', () => {
+
+    before(() => disableJSDOM = enableJSDOM());
+    after(() => disableJSDOM());
+
+    describe('scroll requests', () => {
+
+        let widget: TestTreeWidget;
+        let model: { root: TreeNode | undefined };
+
+        beforeEach(() => {
+            model = { root: undefined };
+            widget = new TestTreeWidget(defaultTreeProps, model as unknown as TreeModel, {} as ContextMenuRenderer);
+            Object.assign(widget, {
+                focusService: { get focusedNode(): TreeNode | undefined { return widget.focusedNode; } } as TreeFocusService,
+                scheduleUpdateScrollToRow: () => widget.requestScrollToFocus()
+            });
+        });
+
+        afterEach(() => widget.dispose());
+
+        it('scrolls to the focused row when a scroll is requested', () => {
+            const target = leaf('target');
+            model.root = createTreeRoot(leaf('a'), leaf('b'), target);
+            widget.doUpdateRowsNow();
+            widget.focusedNode = target;
+            const requestId = widget.currentScrollToRowRequestId;
+
+            widget.requestScrollToFocus();
+
+            expect(widget.currentScrollToRow).to.equal(2);
+            expect(widget.currentScrollToRowRequestId).to.not.equal(requestId);
+        });
+
+        it('does not scroll again when the rows update after the request was served', () => {
+            const target = leaf('target');
+            model.root = createTreeRoot(leaf('a'), target);
+            widget.doUpdateRowsNow();
+            widget.focusedNode = target;
+            widget.requestScrollToFocus();
+            const requestId = widget.currentScrollToRowRequestId;
+
+            // A file created above the focused node shifts its row.
+            model.root = createTreeRoot(leaf('a'), leaf('new'), target);
+            widget.doUpdateRowsNow();
+
+            expect(widget.currentScrollToRow).to.equal(1);
+            expect(widget.currentScrollToRowRequestId).to.equal(requestId);
+        });
+
+        it('keeps a request pending until the rows contain the focused node', () => {
+            const target = leaf('target');
+            const folder: ExpandableTreeNode = { id: 'folder', name: 'folder', parent: undefined, visible: true, expanded: false, children: [] };
+            CompositeTreeNode.addChild(folder, target);
+            model.root = createTreeRoot(leaf('a'), folder);
+            widget.doUpdateRowsNow();
+            widget.focusedNode = target;
+
+            widget.requestScrollToFocus();
+            expect(widget.currentScrollToRow).to.be.undefined;
+            const requestId = widget.currentScrollToRowRequestId;
+
+            // The reveal expands the collapsed parent.
+            folder.expanded = true;
+            widget.doUpdateRowsNow();
+
+            expect(widget.currentScrollToRow).to.equal(2);
+            expect(widget.currentScrollToRowRequestId).to.not.equal(requestId);
+
+            // Once served, a later rows update does not scroll again.
+            const servedRequestId = widget.currentScrollToRowRequestId;
+            widget.doUpdateRowsNow();
+            expect(widget.currentScrollToRowRequestId).to.equal(servedRequestId);
+        });
+    });
+
+    describe('non-virtualized rows', () => {
+
+        let container: HTMLElement;
+        let root: Root;
+        let widget: TestTreeWidget;
+
+        const render = (scrollToRowRequestId: number): void => flushSync(() => root.render(
+            <widget.RowRenderer rows={[]} scrollToRowRequestId={scrollToRowRequestId} />
+        ));
+
+        beforeEach(() => {
+            widget = new TestTreeWidget({ ...defaultTreeProps, virtualized: false }, { root: undefined } as unknown as TreeModel, {} as ContextMenuRenderer);
+            container = document.createElement('div');
+            document.body.appendChild(container);
+            root = createRoot(container);
+        });
+
+        afterEach(() => {
+            flushSync(() => root.unmount());
+            document.body.removeChild(container);
+            widget.dispose();
+        });
+
+        it('scrolls to the selection once per scroll request, not on every render', () => {
+            render(1);
+            const scrollsAfterMount = widget.scrollToSelectedCount;
+
+            render(1);
+            render(1);
+            expect(widget.scrollToSelectedCount).to.equal(scrollsAfterMount);
+
+            render(2);
+            expect(widget.scrollToSelectedCount).to.equal(scrollsAfterMount + 1);
+        });
+    });
+
+    describe('View', () => {
+
+        let container: HTMLElement;
+        let root: Root;
+        let view: CountingView | undefined;
+        const rows: TreeWidget.NodeRow[] = [0, 1, 2].map(index => ({ index, depth: 0, node: leaf(`node-${index}`) }));
+
+        const render = (props: Partial<TreeWidget.ViewProps>): void => flushSync(() => root.render(
+            <CountingView
+                ref={instance => { view = instance ?? undefined; }}
+                width={100}
+                height={100}
+                rows={rows}
+                renderNodeRow={row => <div>{row.node.id}</div>}
+                {...props}
+            />
+        ));
+
+        beforeEach(() => {
+            container = document.createElement('div');
+            document.body.appendChild(container);
+            root = createRoot(container);
+        });
+
+        afterEach(() => {
+            flushSync(() => root.unmount());
+            document.body.removeChild(container);
+        });
+
+        it('does not scroll again when re-rendered without a new scroll request', () => {
+            render({ scrollToRow: 2, scrollToRowRequestId: 1 });
+            const scrollsAfterMount = view!.scrollCount;
+
+            render({ scrollToRow: 2, scrollToRowRequestId: 1 });
+            render({ scrollToRow: 2, scrollToRowRequestId: 1 });
+
+            expect(view!.scrollCount).to.equal(scrollsAfterMount);
+        });
+
+        it('scrolls again when a new scroll request arrives for the same row', () => {
+            render({ scrollToRow: 2, scrollToRowRequestId: 1 });
+            const scrollsAfterMount = view!.scrollCount;
+
+            render({ scrollToRow: 2, scrollToRowRequestId: 2 });
+
+            expect(view!.scrollCount).to.equal(scrollsAfterMount + 1);
+        });
+
+        it('scrolls when the row to scroll to changes', () => {
+            render({ scrollToRow: 1 });
+            const scrollsAfterMount = view!.scrollCount;
+
+            render({ scrollToRow: 2 });
+
+            expect(view!.scrollCount).to.equal(scrollsAfterMount + 1);
+        });
+    });
+});

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

@@ -373,7 +373,9 @@ export class TreeWidget extends ReactWidget implements StatefulWidget {
         }
         this.rows = new Map(rowsToUpdate);
         this.update();
-        this.scheduleUpdateScrollToRow();
+        if (this.scrollToRowPending) {
+            this.scheduleUpdateScrollToRow();
+        }
     }
 
     protected getDepthForNode(node: TreeNode, depths: Map<CompositeTreeNode | undefined, number>): number {
@@ -395,11 +397,24 @@ export class TreeWidget extends ReactWidget implements StatefulWidget {
      */
     protected scrollToRow: number | undefined;
     /**
-     * Update the `scrollToRow`.
-     * @param updateOptions the tree widget force update options.
+     * Identifies the latest scroll request, so that the view scrolls to `scrollToRow` once per request
+     * rather than on every render.
+     */
+    protected scrollToRowRequestId = 0;
+    /**
+     * `true` while the latest scroll request has no target row yet, for example when a reveal selects a node
+     * whose parent is still collapsed. The request is served on the first rows update that contains the target.
+     */
+    protected scrollToRowPending = false;
+    /**
+     * Update the `scrollToRow` and request the view to scroll to it.
      */
     protected updateScrollToRow(): void {
         this.scrollToRow = this.getScrollToRow();
+        this.scrollToRowPending = this.scrollToRow === undefined;
+        if (!this.scrollToRowPending) {
+            this.scrollToRowRequestId++;
+        }
         this.update();
     }
 
@@ -510,8 +525,8 @@ export class TreeWidget extends ReactWidget implements StatefulWidget {
         return this.model.root;
     }
 
-    protected ScrollingRowRenderer: React.FC<{ rows: TreeWidget.NodeRow[] }> = ({ rows }) => {
-        useEffect(() => this.scrollToSelected());
+    protected ScrollingRowRenderer: React.FC<{ rows: TreeWidget.NodeRow[], scrollToRowRequestId?: number }> = ({ rows, scrollToRowRequestId }) => {
+        useEffect(() => this.scrollToSelected(), [scrollToRowRequestId]);
         return <>{rows.map(row => <div key={row.index}>{this.renderNodeRow(row)}</div>)}</>;
     };
 
@@ -524,7 +539,7 @@ export class TreeWidget extends ReactWidget implements StatefulWidget {
         if (model.root) {
             const rows = Array.from(this.rows.values());
             if (this.props.virtualized === false) {
-                return <this.ScrollingRowRenderer rows={rows} />;
+                return <this.ScrollingRowRenderer rows={rows} scrollToRowRequestId={this.scrollToRowRequestId} />;
             }
             return <TreeWidget.View
                 ref={view => { this.view = (view || undefined); }}
@@ -533,6 +548,7 @@ export class TreeWidget extends ReactWidget implements StatefulWidget {
                 rows={rows}
                 renderNodeRow={this.renderNodeRow}
                 scrollToRow={this.scrollToRow}
+                scrollToRowRequestId={this.scrollToRowRequestId}
                 onAtBottomStateChangeEmitter={this.onAtBottomStateChangeEmitter}
                 {...this.props.viewProps}
             />;
@@ -1599,6 +1615,10 @@ export namespace TreeWidget {
          * The scroll to row value.
          */
         scrollToRow?: number
+        /**
+         * Changes with every scroll request, so that the view scrolls to `scrollToRow` again even if the row did not change.
+         */
+        scrollToRowRequestId?: number
         /**
          * The list of node rows.
          */
@@ -1615,6 +1635,13 @@ export namespace TreeWidget {
     export class View extends React.Component<ViewProps> {
         list: VirtuosoHandle | undefined;
 
+        /**
+         * Only stores the handle. A new callback on every render would make React detach and re-attach the ref on every commit.
+         */
+        protected readonly setList = (list: VirtuosoHandle | null): void => {
+            this.list = list || undefined;
+        };
+
         /**
          * Ensure the selected row is scrolled into view when virtualization finishes updating.
          */
@@ -1633,18 +1660,15 @@ export namespace TreeWidget {
         }
 
         override componentDidUpdate(prevProps: ViewProps): void {
-            if (this.props.scrollToRow !== prevProps.scrollToRow) {
+            if (this.props.scrollToRow !== prevProps.scrollToRow || this.props.scrollToRowRequestId !== prevProps.scrollToRowRequestId) {
                 this.scrollIntoViewIfNeeded();
             }
         }
 
         override render(): React.ReactNode {
-            const { rows, width, height, scrollToRow, renderNodeRow, onAtBottomStateChangeEmitter, ...other } = this.props;
+            const { rows, width, height, scrollToRow, scrollToRowRequestId, renderNodeRow, onAtBottomStateChangeEmitter, ...other } = this.props;
             return <Virtuoso
-                ref={(list: VirtuosoHandle | null) => {
-                    this.list = (list || undefined);
-                    this.scrollIntoViewIfNeeded();
-                }}
+                ref={this.setList}
                 atBottomStateChange={(atBottom: boolean) => {
                     onAtBottomStateChangeEmitter?.fire(atBottom);
                 }}

package/src/browser/view-container.ts

@@ -38,7 +38,7 @@ import { Drag } from '@lumino/dragdrop';
 import { MimeData } from '@lumino/coreutils';
 import { ElementExt } from '@lumino/domutils';
 import { TabBarDecoratorService } from './shell/tab-bar-decorator';
-import { ContextKeyService } from './context-key-service';
+import { ContextKeyService, ContextMatcher } from './context-key-service';
 import { KeybindingRegistry } from './keybinding';
 import { SubmenuAsToolbarItemWrapper } from './shell/tab-bar-toolbar/tab-bar-toolbar-menu-adapters';
 import { TheiaSplitPanel } from './shell/theia-split-panel';
@@ -109,8 +109,8 @@ class PartsMenuToolbarItem extends SubmenuAsToolbarItemWrapper {
         super(effectiveMenuPath, commandRegistry, menuRegistry, contextKeyService, contextMenuRenderer, menuNode, group);
     }
 
-    override isVisible(widget: Widget): boolean {
-        return widget === this.target() && super.isVisible(widget);
+    override isVisible(widget: Widget, contextMatcher: ContextMatcher): boolean {
+        return widget === this.target() && super.isVisible(widget, contextMatcher);
     }
 }
 

package/src/browser/widget-context-key-contribution.ts

@@ -0,0 +1,34 @@
+// *****************************************************************************
+// Copyright (C) 2026 JuliaHub, Inc. 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 { Widget } from '@lumino/widgets';
+
+export const WidgetContextKeyContribution = Symbol('WidgetContextKeyContribution');
+
+/**
+ * Contributes the context key values that describe a particular widget, so that `when` clauses about
+ * that widget - such as the ones of its tab bar toolbar items - can be evaluated without consulting the
+ * ambient context, which describes whichever widget currently has focus.
+ */
+export interface WidgetContextKeyContribution {
+    /**
+     * @param widget the widget to describe.
+     * @returns the values to overlay over the ambient context, or `undefined` if this contribution does not
+     * describe the given widget. A contribution owning a key should return an explicit "unset" value for the
+     * widgets the key does not apply to, so that the ambient value of another widget cannot leak in.
+     */
+    getContextKeyValues(widget: Widget): Iterable<[string, unknown]> | undefined;
+}

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

@@ -25,6 +25,7 @@ import { DefaultSecondaryWindowService } from './default-secondary-window-servic
 import { bindRootContributionProvider } from '../../common';
 import { WindowTitleContribution } from './window-title-service';
 import { WindowFocusService } from './window-focus-service';
+import { DefaultWindowLaunchArgs, WindowLaunchArgs } from './window-launch-args';
 
 export default new ContainerModule(bind => {
     bind(DefaultWindowService).toSelf().inSingletonScope();
@@ -33,5 +34,7 @@ export default new ContainerModule(bind => {
     bind(ClipboardService).to(BrowserClipboardService).inSingletonScope();
     bind(SecondaryWindowService).to(DefaultSecondaryWindowService).inSingletonScope();
     bind(WindowFocusService).toSelf().inSingletonScope();
+    bind(DefaultWindowLaunchArgs).toSelf().inSingletonScope();
+    bind(WindowLaunchArgs).toService(DefaultWindowLaunchArgs);
     bindRootContributionProvider(bind, WindowTitleContribution);
 });

package/src/browser/window/window-launch-args.ts

@@ -0,0 +1,53 @@
+// *****************************************************************************
+// Copyright (C) 2026 EclipseSource GmbH 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 { injectable } from 'inversify';
+import { LaunchArguments } from '../../common/launch-arguments';
+
+export const WindowLaunchArgs = Symbol('WindowLaunchArgs');
+
+/**
+ * Provides the CLI options a window was launched with, when it was opened by a *forwarded*
+ * (second-instance) launch. See the `second-instance` handling in `ElectronMainApplication`, and
+ * `LaunchArgsStore` for why the options are provided over a trusted channel rather than the URL.
+ *
+ * @experimental
+ */
+export interface WindowLaunchArgs {
+
+    /**
+     * The parsed launch options of the current window, or `undefined` when the window was not opened
+     * by a forwarded launch (a cold-start window, or any browser deployment). Synchronous, so a
+     * contribution can act on it from the first paint.
+     */
+    getLaunchArgs(): LaunchArguments | undefined;
+}
+
+/**
+ * Default (browser) implementation: there is no trusted per-window launch channel in a plain
+ * browser deployment, and the window URL must never be treated as one, so this always reports "no
+ * launch options". Electron rebinds {@link WindowLaunchArgs} to an implementation backed by the
+ * per-window metadata the preload script provides.
+ *
+ * @experimental
+ */
+@injectable()
+export class DefaultWindowLaunchArgs implements WindowLaunchArgs {
+
+    getLaunchArgs(): LaunchArguments | undefined {
+        return undefined;
+    }
+}

package/src/browser-only/frontend-only-application-module.ts

@@ -93,8 +93,11 @@ export const frontendOnlyApplicationModule = new ContainerModule((bind, unbind,
         getExecPath: async (): Promise<string> => '',
         getVariables: async (): Promise<EnvVariable[]> => [],
         getValue: async (_key: string): Promise<EnvVariable | undefined> => undefined,
-        getConfigDirUri: async (): Promise<string> => '',
-        getHomeDirUri: async (): Promise<string> => '',
+        // Matches the backend's default '.theia' configuration folder.
+        getConfigDirUri: async (): Promise<string> => 'file:///.theia',
+        // Has to be a directory that already exists: consumers such as the file dialog only
+        // resolve this, they never create it, and nothing seeds a home folder in OPFS.
+        getHomeDirUri: async (): Promise<string> => 'file:///',
         getDrives: async (): Promise<string[]> => []
     };
     if (isBound(EnvVariablesServer)) {

package/src/browser-only/messaging/frontend-only-service-connection-provider.ts

@@ -13,7 +13,9 @@
 //
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
-import { Event, RpcProxy, Channel, RpcProxyFactory, Emitter } from '../../common';
+import { Emitter, Event } from '../../common/event';
+import { Channel } from '../../common/message-rpc/channel';
+import { RpcProxy, RpcProxyFactory } from '../../common/messaging/proxy-factory';
 import { injectable, inject, named } from 'inversify';
 import { ServiceConnectionProvider } from '../../browser/messaging/service-connection-provider';
 import { ILogger } from '../../common/logger';