@theia/core 1.77.0-next.4 → 1.77.0-next.47

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

@@ -1655,13 +1655,73 @@ export namespace TreeWidget {
             }
         };
 
+        /**
+         * `true` once Virtuoso has measured the list. Before that, `scrollIntoView` sees every row as visible and does nothing.
+         */
+        protected measured = false;
+        /**
+         * `true` while a scroll request made before the list was measured waits to be served.
+         */
+        protected scrollHeld = false;
+        /**
+         * The latest list height reported by Virtuoso. It can still change after the first report, as more rows are measured.
+         */
+        protected listHeight = 0;
+        /**
+         * How many frames a held scroll request waits for the list to be rendered at its height, about half a second at 60 Hz.
+         */
+        protected readonly maxRenderWaitFrames = 30;
+        protected scroller: HTMLElement | undefined;
+
+        /**
+         * Scroll now, or hold the request until the list is measured, e.g. for the focus restored when the view mounts.
+         */
+        protected requestScroll(): void {
+            if (this.measured) {
+                this.scrollIntoViewIfNeeded();
+            } else {
+                this.scrollHeld = this.props.scrollToRow !== undefined;
+            }
+        }
+
+        protected readonly onTotalListHeightChanged = (height: number): void => {
+            this.listHeight = height;
+            if (!this.measured && height > 0) {
+                this.measured = true;
+                if (this.scrollHeld) {
+                    this.scrollHeld = false;
+                    this.scrollWhenRendered();
+                }
+            }
+            this.props.totalListHeightChanged?.(height);
+        };
+
+        protected readonly setScroller = (scroller: HTMLElement | Window | null): void => {
+            this.scroller = scroller instanceof HTMLElement ? scroller : undefined;
+            this.props.scrollerRef?.(scroller);
+        };
+
+        /**
+         * Virtuoso reports the list height before React renders the list at it, and a scroll before that is clamped
+         * to the old height. Wait for the rendered height, at most `maxRenderWaitFrames` frames.
+         */
+        protected scrollWhenRendered(framesLeft = this.maxRenderWaitFrames): void {
+            window.requestAnimationFrame(() => {
+                if (this.scroller && this.scroller.scrollHeight < this.listHeight && framesLeft > 0) {
+                    this.scrollWhenRendered(framesLeft - 1);
+                } else {
+                    this.scrollIntoViewIfNeeded();
+                }
+            });
+        }
+
         override componentDidMount(): void {
-            this.scrollIntoViewIfNeeded();
+            this.requestScroll();
         }
 
         override componentDidUpdate(prevProps: ViewProps): void {
             if (this.props.scrollToRow !== prevProps.scrollToRow || this.props.scrollToRowRequestId !== prevProps.scrollToRowRequestId) {
-                this.scrollIntoViewIfNeeded();
+                this.requestScroll();
             }
         }
 
@@ -1681,6 +1741,8 @@ export namespace TreeWidget {
                 // Higher value provides smoother scrolling experience especially during inference, but uses more memory
                 overscan={800}
                 {...other}
+                totalListHeightChanged={this.onTotalListHeightChanged}
+                scrollerRef={this.setScroller}
             />;
         }
     }

package/src/browser/widgets/select-component.spec.ts

@@ -0,0 +1,77 @@
+// *****************************************************************************
+// Copyright (C) 2026 EclipseSource GmbH.
+//
+// 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 * as React from 'react';
+import * as sinon from 'sinon';
+import * as browser from '../browser';
+import { SelectComponent, SelectOption } from './select-component';
+
+disableJSDOM();
+
+class TestSelectComponent extends SelectComponent {
+    dropdown(): React.ReactElement<{ style: React.CSSProperties }> {
+        this.state = { ...this.state, dimensions: new DOMRect(20, 20, 90, 23) };
+        return this.renderDropdown() as React.ReactElement<{ style: React.CSSProperties }>;
+    }
+}
+
+describe('SelectComponent dropdown width', () => {
+    let component: TestSelectComponent;
+    let textWidth: sinon.SinonStub;
+
+    before(() => disableJSDOM = enableJSDOM());
+    after(() => disableJSDOM());
+
+    beforeEach(() => {
+        textWidth = sinon.stub(browser, 'measureTextWidth').returns(84);
+        sinon.stub(document.documentElement, 'getBoundingClientRect').returns(new DOMRect(0, 0, 800, 600));
+    });
+
+    afterEach(() => {
+        component.componentWillUnmount();
+        sinon.restore();
+    });
+
+    function dropdown(options: SelectOption[], alignment?: 'left' | 'right'): React.ReactElement<{ style: React.CSSProperties }> {
+        component = new TestSelectComponent({ options, alignment });
+        return component.dropdown();
+    }
+
+    it('keeps label-based sizing when no option has a description', () => {
+        expect(dropdown([{ label: 'Off' }, { label: 'None', description: '' }]).props.style.width).to.equal(100);
+    });
+
+    it('reserves readable space even when only an unselected option has a description', () => {
+        expect(dropdown([{ label: 'Auto' }, { label: 'Off', description: 'Uses provider defaults.' }]).props.style.width).to.equal(300);
+    });
+
+    it('keeps enough space for labels wider than the description minimum', () => {
+        textWidth.returns(384);
+        expect(dropdown([{ label: 'A long label', description: 'Description' }]).props.style.width).to.equal(400);
+    });
+
+    it('caps the description width at the available space for either alignment', () => {
+        (document.documentElement.getBoundingClientRect as sinon.SinonStub).returns(new DOMRect(0, 0, 200, 600));
+        const options = [{ label: 'Off', description: 'Uses provider defaults.' }];
+        expect(dropdown(options).props.style.width).to.equal(180);
+        component.componentWillUnmount();
+        expect(dropdown(options, 'right').props.style.width).to.equal(110);
+    });
+});

package/src/browser/widgets/select-component.tsx

@@ -163,7 +163,8 @@ export class SelectComponent extends React.Component<SelectComponentProps, Selec
 
     protected getOptimalWidth(): number {
         const textWidth = measureTextWidth(this.props.options.map(e => e.label || e.value || '' + (e.detail || '')));
-        return Math.ceil(textWidth + 16);
+        const minWidth = this.props.options.some(option => option.description) ? 300 : 0;
+        return Math.max(Math.ceil(textWidth + 16), minWidth);
     }
 
     protected getOptimalHeight(maxWidth?: number): number {
@@ -320,15 +321,10 @@ export class SelectComponent extends React.Component<SelectComponentProps, Selec
         if (!this.fieldRef.current) {
             return;
         }
-        if (ev.key === 'ArrowUp') {
-            const selected = this.nextNotSeparator('backwards', this.state.hover);
-            this.setState({
-                selected,
-                hover: selected
-            });
-        } else if (ev.key === 'ArrowDown') {
+        if (ev.key === 'ArrowUp' || ev.key === 'ArrowDown') {
+            const direction = ev.key === 'ArrowUp' ? 'backwards' : 'forwards';
             if (this.state.dimensions) {
-                const selected = this.nextNotSeparator('forwards', this.state.hover);
+                const selected = this.nextNotSeparator(direction, this.state.hover);
                 this.setState({
                     selected,
                     hover: selected
@@ -337,7 +333,7 @@ export class SelectComponent extends React.Component<SelectComponentProps, Selec
                 this.toggleVisibility();
                 // Start on the first selectable option (startFrom -1 evaluates index 0 first), so a
                 // leading separator or disabled option is skipped instead of becoming the active row.
-                const selected = this.nextNotSeparator('forwards', -1);
+                const selected = this.nextNotSeparator(direction, -1);
                 this.setState({
                     selected,
                     hover: selected,

package/src/common/core-preferences.ts

@@ -153,18 +153,18 @@ export const corePreferenceSchema: PreferenceSchema = {
         'http.proxy': {
             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.'),
+            markdownDescription: nls.localize('theia/core/http/proxy', 'The proxy setting to use. If not set, will be inherited from the `http_proxy` and `https_proxy` environment variables.'),
             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.'),
+            description: nls.localize('theia/core/http/proxyStrictSSL', 'Controls whether the proxy server certificate should be verified against the list of supplied CAs.'),
             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.'),
+            markdownDescription: nls.localize('theia/core/http/proxyAuthorization', 'The value to send as the `Proxy-Authorization` header for every network request.'),
             scope: PreferenceScope.User
         },
         'http.proxySupport': {
@@ -177,13 +177,13 @@ export const corePreferenceSchema: PreferenceSchema = {
                 nls.localizeByDefault('Enable proxy support for extensions, override request options.'),
             ],
             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.'),
+            description: nls.localize('theia/core/http/proxySupport', 'Use the proxy support for extensions.'),
             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.'),
+            description: nls.localize('theia/core/http/systemCertificates', '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.'),
             scope: PreferenceScope.User
         },
         'workbench.list.openMode': {

package/src/electron-browser/electron-clipboard-service.ts

@@ -25,7 +25,7 @@ export class ElectronClipboardService implements ClipboardService {
     protected readonly onDidWriteTextEmitter = new Emitter<string>();
     readonly onDidWriteText: Event<string> = this.onDidWriteTextEmitter.event;
 
-    readText(): string {
+    readText(): Promise<string> {
         return window.electronTheiaCore.readClipboard();
     }
 

package/src/electron-browser/preload.ts

@@ -232,8 +232,8 @@ const api: TheiaCoreAPI = {
         ipcRenderer.send(CHANNEL_APP_STATE_CHANGED, state);
     },
 
-    readClipboard(): string {
-        return ipcRenderer.sendSync(CHANNEL_READ_CLIPBOARD);
+    readClipboard(): Promise<string> {
+        return ipcRenderer.invoke(CHANNEL_READ_CLIPBOARD);
     },
 
     writeClipboard(text): void {

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

@@ -107,7 +107,7 @@ export interface TheiaCoreAPI {
 
     applicationStateChanged(state: FrontendApplicationState): void;
 
-    readClipboard(): string;
+    readClipboard(): Promise<string>;
     writeClipboard(text: string): void;
 
     onKeyboardLayoutChanged(handler: (newLayout: NativeKeyboardLayout) => void): Disposable;

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

@@ -274,11 +274,12 @@ export class TheiaMainApi implements ElectronMainApplicationContribution {
             event.returnValue = BrowserWindow.fromWebContents(event.sender)?.isFullScreen();
         });
 
-        ipcMain.on(CHANNEL_READ_CLIPBOARD, event => {
-            event.returnValue = clipboard.readText();
-        });
+        ipcMain.handle(CHANNEL_READ_CLIPBOARD, () => clipboard.readText().catch(error => {
+            console.warn('Could not read from the clipboard', error);
+            return '';
+        }));
         ipcMain.on(CHANNEL_WRITE_CLIPBOARD, (event, text) => {
-            clipboard.writeText(text);
+            clipboard.writeText(text).catch(error => console.warn('Could not write to the clipboard', error));
         });
 
         nativeKeymap.onDidChangeKeyboardLayout(() => {

package/src/node/messaging/binary-message-pipe.spec.ts

@@ -0,0 +1,81 @@
+// *****************************************************************************
+// Copyright (C) 2026 Ivan Baksheev 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 { expect } from 'chai';
+import { PassThrough } from 'stream';
+import { BinaryMessagePipe } from './binary-message-pipe';
+
+class TestBinaryMessagePipe extends BinaryMessagePipe {
+    override encodeMessageStart(message: Uint8Array): Uint8Array {
+        return super.encodeMessageStart(message);
+    }
+
+    override get messageStartByteLength(): number {
+        return super.messageStartByteLength;
+    }
+}
+
+describe('BinaryMessagePipe', () => {
+    const payload = Buffer.alloc(64, 0x41);
+    let headerLength: number;
+    let headerSplit: number;
+    let stream: PassThrough;
+    let pipe: TestBinaryMessagePipe;
+    let messages: Buffer[];
+    let frame: Buffer;
+
+    beforeEach(() => {
+        stream = new PassThrough();
+        pipe = new TestBinaryMessagePipe(stream);
+        headerLength = pipe.messageStartByteLength;
+        headerSplit = Math.floor(headerLength / 2);
+        messages = [];
+        frame = encodeFrame(payload);
+        pipe.onMessage(message => messages.push(Buffer.from(message)));
+    });
+
+    afterEach(() => {
+        pipe.dispose();
+        stream.destroy();
+    });
+
+    it('accumulates consecutive chunks that are shorter than the header', () => {
+        stream.emit('data', frame.subarray(0, headerSplit));
+        stream.emit('data', frame.subarray(headerSplit, headerLength));
+        stream.emit('data', frame.subarray(headerLength));
+
+        expect(messages).to.deep.equal([payload]);
+    });
+
+    it('receives the original payload when the header is split between chunks', () => {
+        stream.emit('data', frame.subarray(0, headerSplit));
+        stream.emit('data', frame.subarray(headerSplit));
+
+        expect(messages).to.deep.equal([payload]);
+    });
+
+    it('preserves the next frame in the same chunk after a partial header', () => {
+        const nextPayload = Buffer.from('next');
+        stream.emit('data', frame.subarray(0, headerSplit));
+        stream.emit('data', Buffer.concat([frame.subarray(headerSplit), encodeFrame(nextPayload)]));
+
+        expect(messages).to.deep.equal([payload, nextPayload]);
+    });
+
+    function encodeFrame(message: Uint8Array): Buffer {
+        return Buffer.concat([Buffer.from(pipe.encodeMessageStart(message)), Buffer.from(message)]);
+    }
+});

package/src/node/messaging/binary-message-pipe.ts

@@ -57,6 +57,10 @@ export class BinaryMessagePipe implements Disposable {
     }
 
     protected handleNewMessage(chunk: Uint8Array): void {
+        if (this.cachedMessageData.partialMessageStart) {
+            chunk = Buffer.concat([this.cachedMessageData.partialMessageStart, chunk]);
+            this.cachedMessageData.partialMessageStart = undefined;
+        }
         if (chunk.byteLength < this.messageStartByteLength) {
             // The chunk only contains a part of the encoded message start
             this.cachedMessageData.partialMessageStart = chunk;
@@ -137,10 +141,7 @@ export class BinaryMessagePipe implements Disposable {
      * @throws An error if the message start can not be read successfully.
      */
     protected readMessageStart(chunk: Uint8Array): number {
-        const messageData = this.cachedMessageData.partialMessageStart ? Buffer.concat([this.cachedMessageData.partialMessageStart, chunk]) : chunk;
-        this.cachedMessageData.partialMessageStart = undefined;
-
-        const reader = new Uint8ArrayReadBuffer(messageData);
+        const reader = new Uint8ArrayReadBuffer(chunk);
         const identifier = reader.readString();
 
         if (identifier !== BinaryMessagePipe.MESSAGE_START_IDENTIFIER) {