@theia/core 1.64.0-next.28 → 1.64.0

package/src/browser/menu/browser-menu-plugin.ts

@@ -212,7 +212,7 @@ export class MenuServices {
 }
 
 export interface MenuWidgetFactory {
-    createMenuWidget(effectiveMenuPath: MenuPath, menu: Submenu, contextMatcher: ContextMatcher, options: BrowserMenuOptions): MenuWidget;
+    createMenuWidget(effectiveMenuPath: MenuPath, menu: Submenu, contextMatcher: ContextMatcher, options: BrowserMenuOptions, args?: unknown[]): MenuWidget;
 }
 
 /**
@@ -252,7 +252,7 @@ export class DynamicMenuWidget extends MenuWidget {
 
     protected override onBeforeDetach(msg: Message): void {
         this.node.ownerDocument.removeEventListener('pointerdown', this, true);
-        super.onAfterDetach(msg);
+        super.onBeforeDetach(msg);
     }
 
     override handleEvent(event: Event): void {
@@ -325,7 +325,7 @@ export class DynamicMenuWidget extends MenuWidget {
             if (node.isVisible(nodePath, contextMatcher, context, ...(this.args || []))) {
                 if (CompoundMenuNode.is(node)) {
                     if (RenderedMenuNode.is(node)) {
-                        const submenu = this.services.menuWidgetFactory.createMenuWidget(nodePath, node, this.contextMatcher, this.options);
+                        const submenu = this.services.menuWidgetFactory.createMenuWidget(nodePath, node, this.contextMatcher, this.options, this.args);
                         if (submenu.items.length > 0) {
                             result.push({ type: 'submenu', submenu });
                         }

package/src/browser/preload/i18n-preload-contribution.ts

@@ -43,7 +43,7 @@ export class I18nPreloadContribution implements PreloadContribution {
             const localization = await this.localizationServer.loadLocalization(locale);
             if (localization.languagePack) {
                 nls.localization = localization;
-            } else {
+            } else if (locale !== nls.defaultLocale) {
                 // In case the localization that we've loaded doesn't localize Theia completely (languagePack is false)
                 // We simply reset the locale to the default again
                 Object.assign(nls, {

package/src/browser/shell/application-shell.ts

@@ -656,7 +656,7 @@ export class ApplicationShell extends Widget {
         this.additionalDraggedUris = undefined;
     }
 
-    protected static getDraggedEditorUris(dataTransfer: DataTransfer): URI[] {
+    static getDraggedEditorUris(dataTransfer: DataTransfer): URI[] {
         const data = dataTransfer.getData('theia-editor-dnd');
         return data ? data.split('\n').map(entry => new URI(entry)) : [];
     }

package/src/common/array-utils.ts

@@ -151,4 +151,57 @@ export namespace ArrayUtils {
         }
         return true;
     }
+
+    export function equals<T>(one: ReadonlyArray<T> | undefined, other: ReadonlyArray<T> | undefined, itemEquals: (a: T, b: T) => boolean = (a, b) => a === b): boolean {
+        if (one === other) {
+            return true;
+        }
+
+        if (!one || !other) {
+            return false;
+        }
+
+        if (one.length !== other.length) {
+            return false;
+        }
+
+        for (let i = 0, len = one.length; i < len; i++) {
+            if (!itemEquals(one[i], other[i])) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    export function findLast<T>(array: readonly T[], predicate: (item: T) => boolean): T | undefined {
+        const idx = findLastIdx(array, predicate);
+        if (idx === -1) {
+            return undefined;
+        }
+        return array[idx];
+    }
+
+    export function findLastIdx<T>(array: readonly T[], predicate: (item: T) => boolean, fromIndex = array.length - 1): number {
+        for (let i = fromIndex; i >= 0; i--) {
+            const element = array[i];
+
+            if (predicate(element)) {
+                return i;
+            }
+        }
+
+        return -1;
+    }
+
+    export function checkAdjacentItems<T>(items: readonly T[], predicate: (item1: T, item2: T) => boolean): boolean {
+        for (let i = 0; i < items.length - 1; i++) {
+            const a = items[i];
+            const b = items[i + 1];
+            if (!predicate(a, b)) {
+                return false;
+            }
+        }
+        return true;
+    }
 }

package/src/common/diff.ts

@@ -0,0 +1,56 @@
+// *****************************************************************************
+// Copyright (C) 2025 1C-Soft LLC 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 { Range } from 'vscode-languageserver-protocol';
+import { CancellationToken } from './cancellation';
+import URI from './uri';
+
+/** Represents a textual diff. */
+export interface Diff {
+    readonly changes: readonly DetailedLineRangeMapping[];
+}
+
+export interface DetailedLineRangeMapping extends LineRangeMapping {
+    readonly innerChanges?: readonly RangeMapping[];
+}
+
+export interface LineRangeMapping {
+    readonly left: LineRange;
+    readonly right: LineRange;
+}
+
+/** Represents a range of whole lines of text. */
+export interface LineRange {
+    /** A zero-based number of the start line. */
+    readonly start: number;
+    /** A zero-based number of the end line, exclusive. */
+    readonly end: number;
+}
+
+export interface RangeMapping {
+    readonly left: Range;
+    readonly right: Range;
+}
+
+export const DiffComputer = Symbol('DiffComputer');
+
+export interface DiffComputer {
+    computeDiff(left: URI, right: URI, options?: DiffComputerOptions): Promise<Diff | undefined>;
+}
+
+export interface DiffComputerOptions {
+    readonly cancellationToken?: CancellationToken;
+}

package/src/common/message-rpc/msg-pack-extension-manager.ts

@@ -47,8 +47,8 @@ export class MsgPackExtensionManager {
             addExtension({
                 Class: extension.class,
                 type: extension.tag,
-                write: extension.serialize,
-                read: extension.deserialize
+                write: instance => extension.serialize(instance),
+                read: serialized => extension.deserialize(serialized)
             });
         });
     }

package/src/common/observable/autorun.ts

@@ -0,0 +1,246 @@
+// *****************************************************************************
+// Copyright (C) 2025 1C-Soft LLC 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
+// *****************************************************************************
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+// copied and modified from https://github.com/microsoft/vscode/blob/1.96.3/src/vs/base/common/observableInternal/autorun.ts
+
+import { Disposable } from '../disposable';
+import { Observable } from './observable-base';
+
+export class Autorun<TChangeSummary = unknown> implements Disposable {
+
+    protected state = Autorun.State.Stale;
+    protected updateCount = 0;
+    protected disposed = false;
+    protected isRunning = false;
+    protected dependencies = new Set<Observable<unknown>>();
+    protected dependenciesToBeRemoved?: Set<Observable<unknown>>;
+    protected readonly dependencyObserver = this.createDependencyObserver();
+    protected readonly createChangeSummary?: () => TChangeSummary;
+    protected readonly willHandleChange?: <T, TChange>(context: Observable.ChangeContext<T, TChange>, changeSummary: TChangeSummary | undefined) => boolean;
+    protected changeSummary?: TChangeSummary;
+
+    constructor(
+        protected readonly doRun: (args: Autorun.Args<TChangeSummary>) => void,
+        options?: Autorun.Options<TChangeSummary>
+    ) {
+        this.createChangeSummary = options?.createChangeSummary;
+        this.willHandleChange = options?.willHandleChange;
+        this.changeSummary = this.createChangeSummary?.();
+        try {
+            this.run(true);
+        } catch (e) {
+            this.dispose();
+            throw e;
+        }
+    }
+
+    dispose(): void {
+        if (this.disposed) {
+            return;
+        }
+        this.disposed = true;
+        for (const dependency of this.dependencies) {
+            dependency.removeObserver(this.dependencyObserver);
+        }
+        this.dependencies.clear();
+    }
+
+    protected run(isFirstRun = false): void {
+        if (this.disposed) {
+            return;
+        }
+
+        this.dependenciesToBeRemoved = this.dependencies;
+        this.dependencies = new Set<Observable<unknown>>();
+
+        this.state = Autorun.State.UpToDate;
+
+        try {
+            const { changeSummary } = this;
+            this.changeSummary = this.createChangeSummary?.();
+            this.isRunning = true;
+            Observable.Accessor.runWithAccessor(() => this.doRun({ autorun: this, isFirstRun, changeSummary }), dependency => this.watchDependency(dependency));
+        } finally {
+            this.isRunning = false;
+            // We don't want our watched dependencies to think that they are no longer observed, even temporarily.
+            // Thus, we only unsubscribe from dependencies that are definitely not watched anymore.
+            for (const dependency of this.dependenciesToBeRemoved) {
+                dependency.removeObserver(this.dependencyObserver);
+            }
+            this.dependenciesToBeRemoved = undefined;
+        }
+    }
+
+    protected watchDependency<T>(dependency: Observable<T>): T {
+        if (!this.isRunning) {
+            throw new Error('The accessor may only be called while the autorun is running');
+        }
+
+        // In case the run action disposed the autorun.
+        if (this.disposed) {
+            return dependency.getUntracked();
+        }
+
+        // Subscribe before getting the value to enable caching.
+        dependency.addObserver(this.dependencyObserver);
+        // This might call handleChange indirectly, which could invalidate us.
+        const value = dependency.getUntracked();
+        // Which is why we only add the observable to the dependencies now.
+        this.dependencies.add(dependency);
+        this.dependenciesToBeRemoved?.delete(dependency);
+        return value;
+    }
+
+    protected createDependencyObserver(): Observable.Observer {
+        return {
+            beginUpdate: () => {
+                if (this.state === Autorun.State.UpToDate) {
+                    this.state = Autorun.State.DependenciesMightHaveChanged;
+                }
+                this.updateCount++;
+            },
+
+            endUpdate: () => {
+                this.updateCount--;
+                if (this.updateCount === 0) {
+                    do {
+                        if (this.state === Autorun.State.DependenciesMightHaveChanged) {
+                            this.state = Autorun.State.UpToDate;
+                            for (const dependency of this.dependencies) {
+                                dependency.update(); // might call handleChange indirectly, which could make us stale
+                                if (this.state as Autorun.State === Autorun.State.Stale) {
+                                    // The other dependencies will refresh on demand
+                                    break;
+                                }
+                            }
+                        }
+
+                        if (this.state !== Autorun.State.UpToDate) {
+                            try {
+                                this.run();
+                            } catch (e) {
+                                console.error(e);
+                            }
+                        }
+                        // In case the run action changed one of our dependencies, we need to run again.
+                    } while (this.state !== Autorun.State.UpToDate);
+                }
+                if (this.updateCount < 0) {
+                    throw new Error('Unexpected update count: ' + this.updateCount);
+                }
+            },
+
+            handlePossibleChange: <T>(observable: Observable<T>) => {
+                if (this.state === Autorun.State.UpToDate && this.dependencies.has(observable) && !this.dependenciesToBeRemoved?.has(observable)) {
+                    this.state = Autorun.State.DependenciesMightHaveChanged;
+                }
+            },
+
+            handleChange: <T, TChange>(observable: Observable<T, TChange>, change: TChange) => {
+                if (this.dependencies.has(observable) && !this.dependenciesToBeRemoved?.has(observable)) {
+                    let shouldReact = true;
+                    if (this.willHandleChange) {
+                        try {
+                            shouldReact = this.willHandleChange({
+                                observable,
+                                change,
+                                isChangeOf: <U, UChange>(o: Observable<U, UChange>): this is { change: UChange } => o as unknown === observable
+                            }, this.changeSummary);
+                        } catch (e) {
+                            console.error(e);
+                        }
+                    }
+                    if (shouldReact) {
+                        this.state = Autorun.State.Stale;
+                    }
+                }
+            }
+        };
+    }
+}
+
+export namespace Autorun {
+
+    /**
+     * Runs the given {@link run} function immediately, and whenever an update scope ends
+     * and an observable tracked as a dependency of the autorun has changed.
+     *
+     * Note that the run function of the autorun is called within an invocation context where
+     * the {@link Observable.Accessor.getCurrent current accessor} is set to track the autorun
+     * dependencies, so that any observables accessed with `get()` will automatically be tracked.
+     * Occasionally, it might be useful to disable such automatic tracking and track the dependencies
+     * manually with `get(accessor)`. This can be done using the {@link Observable.noAutoTracking} function,
+     * e.g.
+     * ```ts
+     * this.toDispose.push(Autorun.create(() => Observable.noAutoTracking(accessor => {
+     *    const value1 = this.observable1.get(accessor); // the autorun will depend on this observable...
+     *    const value2 = this.observable2.get(); // ...but not on this observable
+     * })));
+     * ```
+     * In particular, this pattern might be useful when copying existing autorun code from VS Code,
+     * where observables can only be tracked manually with `read(reader)`, which corresponds to
+     * `get(accessor)` in Theia; calls to `get()` never cause an observable to be tracked. This directly
+     * corresponds to disabling automatic tracking in Theia with {@link Observable.noAutoTracking}.
+     */
+    export function create<TChangeSummary = void>(run: (args: Args<TChangeSummary>) => void, options?: Options<TChangeSummary>): Disposable {
+        return new Autorun(run, options);
+    }
+
+    export interface Args<TChangeSummary> {
+        readonly autorun: Disposable;
+        readonly isFirstRun: boolean;
+        /**
+         * The change summary with the changes collected from the start of the previous run of the autorun until the start of this run.
+         *
+         * The change summary is created by {@link Options.createChangeSummary} and
+         * the changes are collected by {@link Options.willHandleChange}.
+         */
+        readonly changeSummary: TChangeSummary | undefined;
+    };
+
+    export interface Options<TChangeSummary> {
+        /**
+         * Creates a change summary that can collect the changes reported by the observed dependencies to {@link willHandleChange}.
+         */
+        createChangeSummary?: () => TChangeSummary;
+
+        /**
+         * Handles a change reported by an observed dependency, e.g. by adding it to the {@link changeSummary}.
+         * Returns `true` if the reported change should be reacted to, and `false` if it should be ignored.
+         */
+        willHandleChange?: <T, TChange>(context: Observable.ChangeContext<T, TChange>, changeSummary: TChangeSummary | undefined) => boolean;
+    }
+
+    export const enum State {
+        /**
+         * Dependencies might have changed. Need to check if at least one dependency has actually changed.
+         */
+        DependenciesMightHaveChanged,
+
+        /**
+         * A dependency has changed. Need to (re-)run.
+         */
+        Stale,
+
+        /**
+         * All is up to date.
+         */
+        UpToDate
+    }
+}