@theia/core 1.59.0-next.62 → 1.59.0-next.72

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

@@ -15,18 +15,20 @@
 // *****************************************************************************
 
 import { injectable, inject } from 'inversify';
-import { MenuBar, Menu as MenuWidget, Widget } from '@phosphor/widgets';
+import { Menu, MenuBar, Menu as MenuWidget, Widget } from '@phosphor/widgets';
 import { CommandRegistry as PhosphorCommandRegistry } from '@phosphor/commands';
+import { ElementExt } from '@phosphor/domutils';
 import {
     CommandRegistry, environment, DisposableCollection, Disposable,
-    MenuModelRegistry, MAIN_MENU_BAR, MenuPath, MenuNode, MenuCommandExecutor, CompoundMenuNode, CompoundMenuNodeRole, CommandMenuNode
+    MenuModelRegistry, MAIN_MENU_BAR, MenuPath, MenuNode, MenuCommandExecutor, CompoundMenuNode, CompoundMenuNodeRole, CommandMenuNode,
+    ArrayUtils
 } from '../../common';
 import { KeybindingRegistry } from '../keybinding';
 import { FrontendApplication } from '../frontend-application';
 import { FrontendApplicationContribution } from '../frontend-application-contribution';
 import { ContextKeyService, ContextMatcher } from '../context-key-service';
 import { ContextMenuContext } from './context-menu-context';
-import { waitForRevealed } from '../widgets';
+import { Message, waitForRevealed } from '../widgets';
 import { ApplicationShell } from '../shell';
 import { CorePreferences } from '../core-preferences';
 import { PreferenceService } from '../preferences/preference-service';
@@ -82,8 +84,10 @@ export class BrowserMainMenuFactory implements MenuWidgetFactory {
             this.keybindingRegistry.onKeybindingsChanged(() => {
                 this.showMenuBar(menuBar);
             }),
-            this.menuProvider.onDidChange(() => {
-                this.showMenuBar(menuBar);
+            this.menuProvider.onDidChange(evt => {
+                if (ArrayUtils.startsWith(evt.path, MAIN_MENU_BAR)) {
+                    this.showMenuBar(menuBar);
+                }
             })
         );
         menuBar.disposed.connect(() => disposable.dispose());
@@ -156,6 +160,10 @@ export class BrowserMainMenuFactory implements MenuWidgetFactory {
 
 }
 
+export function isMenuElement(element: HTMLElement | null): boolean {
+    return !!element && element.className.includes('p-Menu');
+}
+
 export class DynamicMenuBarWidget extends MenuBarWidget {
 
     /**
@@ -263,6 +271,48 @@ export class DynamicMenuWidget extends MenuWidget {
         this.updateSubMenus(this, this.menu, this.options.commands);
     }
 
+    protected override onAfterAttach(msg: Message): void {
+        super.onAfterAttach(msg);
+        this.node.ownerDocument.addEventListener('pointerdown', this, true);
+    }
+
+    protected override onBeforeDetach(msg: Message): void {
+        this.node.ownerDocument.removeEventListener('pointerdown', this);
+        super.onAfterDetach(msg);
+    }
+
+    override handleEvent(event: Event): void {
+        if (event.type === 'pointerdown') {
+            this.handlePointerDown(event as PointerEvent);
+        }
+        super.handleEvent(event);
+    }
+
+    handlePointerDown(event: PointerEvent): void {
+        // this code is copied from the superclass because we cannot use the hit
+        // test from the "Private" implementation namespace
+        if (this['_parentMenu']) {
+            return;
+        }
+
+        // The mouse button which is pressed is irrelevant. If the press
+        // is not on a menu, the entire hierarchy is closed and the event
+        // is allowed to propagate. This allows other code to act on the
+        // event, such as focusing the clicked element.
+        if (!this.hitTestMenus(this, event.clientX, event.clientY)) {
+            this.close();
+        }
+    }
+
+    private hitTestMenus(menu: Menu, x: number, y: number): boolean {
+        for (let temp: Menu | null = menu; temp; temp = temp.childMenu) {
+            if (ElementExt.hitTest(temp.node, x, y)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
     public aboutToShow({ previousFocusedElement }: { previousFocusedElement: HTMLElement | undefined }): void {
         this.preserveFocusedElement(previousFocusedElement);
         this.clearItems();

package/src/browser/navigatable-types.ts

@@ -42,7 +42,7 @@ export namespace NavigatableWidget {
     export function is(arg: unknown): arg is NavigatableWidget {
         return arg instanceof BaseWidget && Navigatable.is(arg);
     }
-    export function* getAffected<T extends Widget>(
+    export function getAffected<T extends Widget>(
         widgets: Iterable<T>,
         context: MaybeArray<URI>
     ): IterableIterator<[URI, T & NavigatableWidget]> {

package/src/common/array-utils.ts

@@ -126,4 +126,29 @@ export namespace ArrayUtils {
         }
         return result;
     }
+
+    export function shallowEqual<T>(left: readonly T[], right: readonly T[]): boolean {
+        if (left.length !== right.length) {
+            return false;
+        }
+        for (let i = 0; i < left.length; i++) {
+            if (left[i] !== right[i]) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    export function startsWith<T>(left: readonly T[], right: readonly T[]): boolean {
+        if (right.length > left.length) {
+            return false;
+        }
+
+        for (let i = 0; i < right.length; i++) {
+            if (left[i] !== right[i]) {
+                return false;
+            }
+        }
+        return true;
+    }
 }

package/src/common/content-replacer.spec.ts

@@ -0,0 +1,124 @@
+// *****************************************************************************
+// Copyright (C) 2025 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 { expect } from 'chai';
+import { ContentReplacer, Replacement } from './content-replacer';
+
+describe('ContentReplacer', () => {
+    let contentReplacer: ContentReplacer;
+
+    before(() => {
+        contentReplacer = new ContentReplacer();
+    });
+
+    it('should replace content when oldContent matches exactly', () => {
+        const originalContent = 'Hello World!';
+        const replacements: Replacement[] = [
+            { oldContent: 'World', newContent: 'Universe' }
+        ];
+        const expectedContent = 'Hello Universe!';
+        const result = contentReplacer.applyReplacements(originalContent, replacements);
+        expect(result.updatedContent).to.equal(expectedContent);
+        expect(result.errors).to.be.empty;
+    });
+
+    it('should replace content when oldContent matches after trimming lines', () => {
+        const originalContent = 'Line one\n   Line two   \nLine three';
+        const replacements: Replacement[] = [
+            { oldContent: 'Line two', newContent: 'Second Line' }
+        ];
+        const expectedContent = 'Line one\n   Second Line   \nLine three';
+        const result = contentReplacer.applyReplacements(originalContent, replacements);
+        expect(result.updatedContent).to.equal(expectedContent);
+        expect(result.errors).to.be.empty;
+    });
+
+    it('should return an error when oldContent is not found', () => {
+        const originalContent = 'Sample content';
+        const replacements: Replacement[] = [
+            { oldContent: 'Nonexistent', newContent: 'Replacement' }
+        ];
+        const result = contentReplacer.applyReplacements(originalContent, replacements);
+        expect(result.updatedContent).to.equal(originalContent);
+        expect(result.errors).to.include('Content to replace not found: "Nonexistent"');
+    });
+
+    it('should return an error when oldContent has multiple occurrences', () => {
+        const originalContent = 'Repeat Repeat Repeat';
+        const replacements: Replacement[] = [
+            { oldContent: 'Repeat', newContent: 'Once' }
+        ];
+        const result = contentReplacer.applyReplacements(originalContent, replacements);
+        expect(result.updatedContent).to.equal(originalContent);
+        expect(result.errors).to.include('Multiple occurrences found for: "Repeat"');
+    });
+
+    it('should prepend newContent when oldContent is an empty string', () => {
+        const originalContent = 'Existing content';
+        const replacements: Replacement[] = [
+            { oldContent: '', newContent: 'Prepended content\n' }
+        ];
+        const expectedContent = 'Prepended content\nExisting content';
+        const result = contentReplacer.applyReplacements(originalContent, replacements);
+        expect(result.updatedContent).to.equal(expectedContent);
+        expect(result.errors).to.be.empty;
+    });
+
+    it('should handle multiple replacements correctly', () => {
+        const originalContent = 'Foo Bar Baz';
+        const replacements: Replacement[] = [
+            { oldContent: 'Foo', newContent: 'FooModified' },
+            { oldContent: 'Bar', newContent: 'BarModified' },
+            { oldContent: 'Baz', newContent: 'BazModified' }
+        ];
+        const expectedContent = 'FooModified BarModified BazModified';
+        const result = contentReplacer.applyReplacements(originalContent, replacements);
+        expect(result.updatedContent).to.equal(expectedContent);
+        expect(result.errors).to.be.empty;
+    });
+
+    it('should replace all occurrences when mutiple is true', () => {
+        const originalContent = 'Repeat Repeat Repeat';
+        const replacements: Replacement[] = [
+            { oldContent: 'Repeat', newContent: 'Once', multiple: true }
+        ];
+        const expectedContent = 'Once Once Once';
+        const result = contentReplacer.applyReplacements(originalContent, replacements);
+        expect(result.updatedContent).to.equal(expectedContent);
+        expect(result.errors).to.be.empty;
+    });
+
+    it('should return an error when mutiple is false and multiple occurrences are found', () => {
+        const originalContent = 'Repeat Repeat Repeat';
+        const replacements: Replacement[] = [
+            { oldContent: 'Repeat', newContent: 'Once', multiple: false }
+        ];
+        const result = contentReplacer.applyReplacements(originalContent, replacements);
+        expect(result.updatedContent).to.equal(originalContent);
+        expect(result.errors).to.include('Multiple occurrences found for: "Repeat"');
+    });
+
+    it('should return an error when conflicting replacements for the same oldContent are provided', () => {
+        const originalContent = 'Conflict test content';
+        const replacements: Replacement[] = [
+            { oldContent: 'test', newContent: 'test1' },
+            { oldContent: 'test', newContent: 'test2' }
+        ];
+        const result = contentReplacer.applyReplacements(originalContent, replacements);
+        expect(result.updatedContent).to.equal(originalContent);
+        expect(result.errors).to.include('Conflicting replacement values for: "test"');
+    });
+});

package/src/common/content-replacer.ts

@@ -0,0 +1,151 @@
+// *****************************************************************************
+// Copyright (C) 2025 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
+// *****************************************************************************
+
+export interface Replacement {
+    oldContent: string;
+    newContent: string;
+    multiple?: boolean;
+}
+
+export class ContentReplacer {
+    /**
+     * Applies a list of replacements to the original content using a multi-step matching strategy.
+     * @param originalContent The original file content.
+     * @param replacements Array of Replacement objects.
+     * @param allowMultiple If true, all occurrences of each oldContent will be replaced. If false, an error is returned when multiple occurrences are found.
+     * @returns An object containing the updated content and any error messages.
+     */
+    applyReplacements(originalContent: string, replacements: Replacement[]): { updatedContent: string, errors: string[] } {
+        let updatedContent = originalContent;
+        const errorMessages: string[] = [];
+
+        // Guard against conflicting replacements: if the same oldContent appears with different newContent, return with an error.
+        const conflictMap = new Map<string, string>();
+        for (const replacement of replacements) {
+            if (conflictMap.has(replacement.oldContent) && conflictMap.get(replacement.oldContent) !== replacement.newContent) {
+                return { updatedContent: originalContent, errors: [`Conflicting replacement values for: "${replacement.oldContent}"`] };
+            }
+            conflictMap.set(replacement.oldContent, replacement.newContent);
+        }
+
+        replacements.forEach(({ oldContent, newContent, multiple }) => {
+            // If the old content is empty, prepend the new content to the beginning of the file (e.g. in new file)
+            if (oldContent === '') {
+                updatedContent = newContent + updatedContent;
+                return;
+            }
+
+            let matchIndices = this.findExactMatches(updatedContent, oldContent);
+
+            if (matchIndices.length === 0) {
+                matchIndices = this.findLineTrimmedMatches(updatedContent, oldContent);
+            }
+
+            if (matchIndices.length === 0) {
+                errorMessages.push(`Content to replace not found: "${oldContent}"`);
+            } else if (matchIndices.length > 1) {
+                if (multiple) {
+                    updatedContent = this.replaceContentAll(updatedContent, oldContent, newContent);
+                } else {
+                    errorMessages.push(`Multiple occurrences found for: "${oldContent}"`);
+                }
+            } else {
+                updatedContent = this.replaceContentOnce(updatedContent, oldContent, newContent);
+            }
+        });
+
+        return { updatedContent, errors: errorMessages };
+    }
+
+    /**
+     * Finds all exact matches of a substring within a string.
+     * @param content The content to search within.
+     * @param search The substring to search for.
+     * @returns An array of starting indices where the exact substring is found.
+     */
+    private findExactMatches(content: string, search: string): number[] {
+        const indices: number[] = [];
+        let startIndex = 0;
+
+        while ((startIndex = content.indexOf(search, startIndex)) !== -1) {
+            indices.push(startIndex);
+            startIndex += search.length;
+        }
+
+        return indices;
+    }
+
+    /**
+     * Attempts to find matches by trimming whitespace from lines in the original content and the search string.
+     * @param content The original content.
+     * @param search The substring to search for, potentially with varying whitespace.
+     * @returns An array of starting indices where a trimmed match is found.
+     */
+    private findLineTrimmedMatches(content: string, search: string): number[] {
+        const trimmedSearch = search.trim();
+        const lines = content.split('\n');
+
+        for (let i = 0; i < lines.length; i++) {
+            const trimmedLine = lines[i].trim();
+            if (trimmedLine === trimmedSearch) {
+                // Calculate the starting index of this line in the original content
+                const startIndex = this.getLineStartIndex(content, i);
+                return [startIndex];
+            }
+        }
+
+        return [];
+    }
+
+    /**
+     * Calculates the starting index of a specific line number in the content.
+     * @param content The original content.
+     * @param lineNumber The zero-based line number.
+     * @returns The starting index of the specified line.
+     */
+    private getLineStartIndex(content: string, lineNumber: number): number {
+        const lines = content.split('\n');
+        let index = 0;
+        for (let i = 0; i < lineNumber; i++) {
+            index += lines[i].length + 1; // +1 for the newline character
+        }
+        return index;
+    }
+
+    /**
+     * Replaces the first occurrence of oldContent with newContent in the content.
+     * @param content The original content.
+     * @param oldContent The content to be replaced.
+     * @param newContent The content to replace with.
+     * @returns The content after replacement.
+     */
+    private replaceContentOnce(content: string, oldContent: string, newContent: string): string {
+        const index = content.indexOf(oldContent);
+        if (index === -1) { return content; }
+        return content.substring(0, index) + newContent + content.substring(index + oldContent.length);
+    }
+
+    /**
+     * Replaces all occurrences of oldContent with newContent in the content.
+     * @param content The original content.
+     * @param oldContent The content to be replaced.
+     * @param newContent The content to replace with.
+     * @returns The content after all replacements.
+     */
+    private replaceContentAll(content: string, oldContent: string, newContent: string): string {
+        return content.split(oldContent).join(newContent);
+    }
+}

package/src/common/menu/composite-menu-node.ts

@@ -54,11 +54,13 @@ export class CompositeMenuNode implements MutableCompoundMenuNode {
         };
     }
 
-    removeNode(id: string): void {
+    removeNode(id: string): boolean {
         const idx = this._children.findIndex(n => n.id === id);
         if (idx >= 0) {
             this._children.splice(idx, 1);
+            return true;
         }
+        return false;
     }
 
     updateOptions(options?: SubMenuOptions): void {
@@ -108,7 +110,7 @@ export class CompositeMenuNodeWrapper implements MutableCompoundMenuNode {
 
     addNode(node: MenuNode): Disposable { return this.wrapped.addNode(node); }
 
-    removeNode(id: string): void { return this.wrapped.removeNode(id); }
+    removeNode(id: string): boolean { return this.wrapped.removeNode(id); }
 
     updateOptions(options: SubMenuOptions): void { return this.wrapped.updateOptions(options); }
 }

package/src/common/menu/menu-model-registry.ts

@@ -59,6 +59,29 @@ export interface MenuContribution {
     registerMenus(menus: MenuModelRegistry): void;
 }
 
+export enum ChangeKind {
+    ADDED,
+    REMOVED,
+    CHANGED,
+    LINKED
+}
+
+export interface MenuChangedEvent {
+    kind: ChangeKind;
+    path: MenuPath
+}
+
+export interface StructuralMenuChange extends MenuChangedEvent {
+    kind: ChangeKind.ADDED | ChangeKind.REMOVED | ChangeKind.LINKED;
+    affectedChildId: string
+}
+
+export namespace StructuralMenuChange {
+    export function is(evt: MenuChangedEvent): evt is StructuralMenuChange {
+        return evt.kind !== ChangeKind.CHANGED;
+    }
+}
+
 /**
  * The MenuModelRegistry allows to register and unregister menus, submenus and actions
  * via strings and {@link MenuAction}s without the need to access the underlying UI
@@ -69,9 +92,9 @@ export class MenuModelRegistry {
     protected readonly root = new CompositeMenuNode('');
     protected readonly independentSubmenus = new Map<string, MutableCompoundMenuNode>();
 
-    protected readonly onDidChangeEmitter = new Emitter<void>();
+    protected readonly onDidChangeEmitter = new Emitter<MenuChangedEvent>();
 
-    get onDidChange(): Event<void> {
+    get onDidChange(): Event<MenuChangedEvent> {
         return this.onDidChangeEmitter.event;
     }
 
@@ -108,8 +131,21 @@ export class MenuModelRegistry {
     registerMenuNode(menuPath: MenuPath | string, menuNode: MenuNode, group?: string): Disposable {
         const parent = this.getMenuNode(menuPath, group);
         const disposable = parent.addNode(menuNode);
-        this.fireChangeEvent();
-        return this.changeEventOnDispose(disposable);
+        const parentPath = this.getParentPath(menuPath, group);
+        this.fireChangeEvent({
+            kind: ChangeKind.ADDED,
+            path: parentPath,
+            affectedChildId: menuNode.id
+        });
+        return this.changeEventOnDispose(parentPath, menuNode.id, disposable);
+    }
+
+    protected getParentPath(menuPath: MenuPath | string, group?: string): string[] {
+        if (typeof menuPath === 'string') {
+            return group ? [menuPath, group] : [menuPath];
+        } else {
+            return group ? menuPath.concat(group) : menuPath;
+        }
     }
 
     getMenuNode(menuPath: MenuPath | string, group?: string): MutableCompoundMenuNode {
@@ -152,11 +188,19 @@ export class MenuModelRegistry {
         let disposable = Disposable.NULL;
         if (!groupNode) {
             groupNode = new CompositeMenuNode(menuId, label, options, parent);
-            disposable = this.changeEventOnDispose(parent.addNode(groupNode));
+            disposable = this.changeEventOnDispose(groupPath, menuId, parent.addNode(groupNode));
+            this.fireChangeEvent({
+                kind: ChangeKind.ADDED,
+                path: groupPath,
+                affectedChildId: menuId
+            });
         } else {
+            this.fireChangeEvent({
+                kind: ChangeKind.CHANGED,
+                path: groupPath,
+            });
             groupNode.updateOptions({ ...options, label });
         }
-        this.fireChangeEvent();
         return disposable;
     }
 
@@ -165,12 +209,13 @@ export class MenuModelRegistry {
             console.debug(`Independent submenu with path ${id} registered, but given ID already exists.`);
         }
         this.independentSubmenus.set(id, new CompositeMenuNode(id, label, options));
-        return this.changeEventOnDispose(Disposable.create(() => this.independentSubmenus.delete(id)));
+        return this.changeEventOnDispose([], id, Disposable.create(() => this.independentSubmenus.delete(id)));
     }
 
     linkSubmenu(parentPath: MenuPath | string, childId: string | MenuPath, options?: SubMenuOptions, group?: string): Disposable {
         const child = this.getMenuNode(childId);
         const parent = this.getMenuNode(parentPath, group);
+        const affectedPath = this.getParentPath(parentPath, group);
 
         const isRecursive = (node: MenuNodeMetadata, childNode: MenuNodeMetadata): boolean => {
             if (node.id === childNode.id) {
@@ -190,8 +235,13 @@ export class MenuModelRegistry {
 
         const wrapper = new CompositeMenuNodeWrapper(child, parent, options);
         const disposable = parent.addNode(wrapper);
-        this.fireChangeEvent();
-        return this.changeEventOnDispose(disposable);
+        this.fireChangeEvent({
+            kind: ChangeKind.LINKED,
+            path: affectedPath,
+            affectedChildId: child.id
+
+        });
+        return this.changeEventOnDispose(affectedPath, child.id, disposable);
     }
 
     /**
@@ -223,11 +273,14 @@ export class MenuModelRegistry {
         if (menuPath) {
             const parent = this.findGroup(menuPath);
             parent.removeNode(id);
-            this.fireChangeEvent();
-            return;
+            this.fireChangeEvent({
+                kind: ChangeKind.REMOVED,
+                path: menuPath,
+                affectedChildId: id
+            });
+        } else {
+            this.unregisterMenuNode(id);
         }
-
-        this.unregisterMenuNode(id);
     }
 
     /**
@@ -236,16 +289,24 @@ export class MenuModelRegistry {
      * @param id technical identifier of the `MenuNode`.
      */
     unregisterMenuNode(id: string): void {
+        const parentPath: string[] = [];
         const recurse = (root: MutableCompoundMenuNode) => {
             root.children.forEach(node => {
                 if (CompoundMenuNode.isMutable(node)) {
-                    node.removeNode(id);
+                    if (node.removeNode(id)) {
+                        this.fireChangeEvent({
+                            kind: ChangeKind.REMOVED,
+                            path: parentPath,
+                            affectedChildId: id
+                        });
+                    }
+                    parentPath.push(node.id);
                     recurse(node);
+                    parentPath.pop();
                 }
             });
         };
         recurse(this.root);
-        this.fireChangeEvent();
     }
 
     /**
@@ -339,16 +400,20 @@ export class MenuModelRegistry {
         return true;
     }
 
-    protected changeEventOnDispose(disposable: Disposable): Disposable {
+    protected changeEventOnDispose(path: MenuPath, id: string, disposable: Disposable): Disposable {
         return Disposable.create(() => {
             disposable.dispose();
-            this.fireChangeEvent();
+            this.fireChangeEvent({
+                path,
+                affectedChildId: id,
+                kind: ChangeKind.REMOVED
+            });
         });
     }
 
-    protected fireChangeEvent(): void {
+    protected fireChangeEvent<T extends MenuChangedEvent>(evt: T): void {
         if (this.isReady) {
-            this.onDidChangeEmitter.fire();
+            this.onDidChangeEmitter.fire(evt);
         }
     }
 

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

@@ -139,8 +139,9 @@ export interface MutableCompoundMenuNode extends CompoundMenuNode {
      * Removes the first node with the given id.
      *
      * @param id node id.
+     * @returns true if the id was present
      */
-    removeNode(id: string): void;
+    removeNode(id: string): boolean;
 
     /**
      * Fills any `undefined` fields with the values from the {@link options}.