@theia/core 1.74.0-next.8 → 1.74.0

package/src/browser/widgets/tab-bar-tracker.spec.ts

@@ -0,0 +1,121 @@
+// *****************************************************************************
+// 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 { enableJSDOM } from '../test/jsdom';
+let disableJSDOM = enableJSDOM();
+
+import { expect } from 'chai';
+import { MessageLoop } from '@lumino/messaging';
+import { DockPanel, TabBar, Widget } from '@lumino/widgets';
+import { TabBarTracker } from './tab-bar-tracker';
+
+disableJSDOM();
+
+describe('TabBarTracker', () => {
+
+    before(() => {
+        disableJSDOM = enableJSDOM();
+    });
+
+    after(() => {
+        disableJSDOM();
+    });
+
+    let panel: DockPanel | undefined;
+
+    afterEach(() => {
+        if (panel) {
+            Widget.detach(panel);
+            panel.dispose();
+            panel = undefined;
+        }
+    });
+
+    function attachInDockPanel(): Widget {
+        panel = new DockPanel();
+        Widget.attach(panel, document.body);
+        const widget = new Widget();
+        panel.addWidget(widget);
+        MessageLoop.flush();
+        return widget;
+    }
+
+    it('reports the enclosing tab-bar on the first check', () => {
+        const widget = attachInDockPanel();
+        const events: Array<[TabBar<Widget> | undefined, TabBar<Widget> | undefined]> = [];
+        const tracker = new TabBarTracker(widget, (oldTabBar, newTabBar) => events.push([oldTabBar, newTabBar]));
+        tracker.check();
+        expect(events).lengthOf(1);
+        expect(events[0][0]).undefined;
+        expect(events[0][1]).not.undefined;
+    });
+
+    it('does not report again when the tab-bar has not changed', () => {
+        const widget = attachInDockPanel();
+        let count = 0;
+        const tracker = new TabBarTracker(widget, () => count++);
+        tracker.check();
+        tracker.check();
+        expect(count).equal(1);
+    });
+
+    it('does nothing when the widget is not inside a DockPanel', () => {
+        let count = 0;
+        const tracker = new TabBarTracker(new Widget(), () => count++);
+        tracker.check();
+        expect(count).equal(0);
+    });
+
+    it('stops reporting once disposed', () => {
+        const widget = attachInDockPanel();
+        let count = 0;
+        const tracker = new TabBarTracker(widget, () => count++);
+        tracker.dispose();
+        tracker.check();
+        expect(count).equal(0);
+    });
+
+    it('reports a move between two tab-bars', () => {
+        panel = new DockPanel();
+        Widget.attach(panel, document.body);
+        const other = new Widget();
+        const widget = new Widget();
+        panel.addWidget(other);
+        panel.addWidget(widget, { mode: 'split-right', ref: other });
+        MessageLoop.flush();
+        const events: Array<[TabBar<Widget> | undefined, TabBar<Widget> | undefined]> = [];
+        const tracker = new TabBarTracker(widget, (oldTabBar, newTabBar) => events.push([oldTabBar, newTabBar]));
+        tracker.check();
+        panel.addWidget(widget, { mode: 'tab-after', ref: other });
+        MessageLoop.flush();
+        tracker.check();
+        expect(events).lengthOf(2);
+        expect(events[1][0]).not.undefined;
+        expect(events[1][0]).not.equal(events[1][1]);
+    });
+
+    it('re-reports the current tab-bar after reset', () => {
+        const widget = attachInDockPanel();
+        const events: Array<[TabBar<Widget> | undefined, TabBar<Widget> | undefined]> = [];
+        const tracker = new TabBarTracker(widget, (oldTabBar, newTabBar) => events.push([oldTabBar, newTabBar]));
+        tracker.check();
+        tracker.reset();
+        tracker.check();
+        expect(events).lengthOf(2);
+        expect(events[1][0]).undefined;
+        expect(events[1][1]).not.undefined;
+    });
+});

package/src/browser/widgets/tab-bar-tracker.ts

@@ -0,0 +1,68 @@
+// *****************************************************************************
+// 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 { find } from '@lumino/algorithm';
+import { DockPanel, TabBar, Widget } from '@lumino/widgets';
+import { Disposable, DisposableCollection } from '../../common';
+
+/**
+ * Detects when a widget is moved between the tab-bars of its enclosing {@link DockPanel} and
+ * notifies a callback with the previous and current tab-bar. Call {@link check} from the host
+ * widget's `onAfterAttach`.
+ */
+export class TabBarTracker implements Disposable {
+
+    protected currentTabBar: TabBar<Widget> | undefined;
+    protected isDisposed = false;
+    protected readonly toDisposeOnTabBarChange = new DisposableCollection();
+
+    constructor(
+        protected readonly widget: Widget,
+        protected readonly onTabBarChange: (oldTabBar?: TabBar<Widget>, newTabBar?: TabBar<Widget>) => void
+    ) { }
+
+    check(): void {
+        if (this.isDisposed) {
+            return;
+        }
+        const parent = this.widget.parent;
+        if (parent instanceof DockPanel) {
+            const newTabBar = find(parent.tabBars(), tabBar => !!tabBar.titles.find(title => title === this.widget.title));
+            if (this.currentTabBar !== newTabBar) {
+                this.toDisposeOnTabBarChange.dispose();
+                const listener = () => this.check();
+                parent.layoutModified.connect(listener);
+                this.toDisposeOnTabBarChange.push(Disposable.create(() => parent.layoutModified.disconnect(listener)));
+                const last = this.currentTabBar;
+                this.currentTabBar = newTabBar;
+                this.onTabBarChange(last, newTabBar);
+            }
+        }
+    }
+
+    /**
+     * Forgets the current tab-bar so that the next {@link check} reports it again as
+     * `(undefined, currentTabBar)`. Listeners on the enclosing panel stay connected.
+     */
+    reset(): void {
+        this.currentTabBar = undefined;
+    }
+
+    dispose(): void {
+        this.isDisposed = true;
+        this.toDisposeOnTabBarChange.dispose();
+    }
+}

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

@@ -24,6 +24,33 @@ export class FrontendOnlyConnectionSource implements ConnectionSource {
     onConnectionDidOpen = new Emitter<Channel>().event;
 }
 
+/**
+ * Proxy factory for services without a frontend-only implementation. There is no backend,
+ * so no channel will ever open and requests would otherwise be queued forever, blocking
+ * any caller that awaits the result, e.g. during application startup.
+ * Instead, requests fail immediately and notifications (fire-and-forget) resolve silently.
+ */
+export class FrontendOnlyRpcProxyFactory<T extends object> extends RpcProxyFactory<T> {
+
+    constructor(protected readonly path: string, target?: object) {
+        super(target);
+    }
+
+    override get(target: T, p: PropertyKey, receiver: unknown): unknown {
+        if (typeof p !== 'string') {
+            return undefined;
+        }
+        // members handled by the base proxy without a connection
+        if (['setClient', 'getClient', 'onDidOpenConnection', 'onDidCloseConnection', 'then', 'toJSON'].includes(p)) {
+            return super.get(target, p, receiver);
+        }
+        if (this.isNotification(p)) {
+            return () => Promise.resolve();
+        }
+        return () => Promise.reject(new Error(`Request '${p}' on service '${this.path}' is unavailable: no backend in frontend-only mode.`));
+    }
+}
+
 @injectable()
 export class FrontendOnlyServiceConnectionProvider extends ServiceConnectionProvider {
 
@@ -33,10 +60,12 @@ export class FrontendOnlyServiceConnectionProvider extends ServiceConnectionProv
     onSocketDidOpen = Event.None;
     onSocketDidClose = Event.None;
     onIncomingMessageActivity = Event.None;
-    override createProxy<T extends object>(path: unknown, target?: unknown): RpcProxy<T> {
+    override createProxy<T extends object>(path: string, target?: object): RpcProxy<T> {
         this.logger.debug(`[Frontend-Only Fallback] Created proxy connection for ${path}`);
-        const factory = target instanceof RpcProxyFactory ? target : new RpcProxyFactory<T>(target);
-        return factory.createProxy();
+        if (target instanceof RpcProxyFactory) {
+            return target.createProxy();
+        }
+        return new FrontendOnlyRpcProxyFactory<T>(path, target).createProxy();
     }
     override listen(path: string, handler: ServiceConnectionProvider.ConnectionHandler, reconnect: boolean): void {
         this.logger.debug('[Frontend-Only Fallback] Listen to websocket connection requested');