@theia/core 1.59.0-next.62 → 1.59.0

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/browser/preload/i18n-preload-contribution.ts

@@ -17,8 +17,10 @@
 import { PreloadContribution } from './preloader';
 import { FrontendApplicationConfigProvider } from '../frontend-application-config-provider';
 import { nls } from '../../common/nls';
-import { inject, injectable } from 'inversify';
+import { inject, injectable, named } from 'inversify';
 import { LocalizationServer } from '../../common/i18n/localization-server';
+import { ContributionProvider } from '../../common';
+import { TextReplacementContribution } from './text-replacement-contribution';
 
 @injectable()
 export class I18nPreloadContribution implements PreloadContribution {
@@ -26,6 +28,9 @@ export class I18nPreloadContribution implements PreloadContribution {
     @inject(LocalizationServer)
     protected readonly localizationServer: LocalizationServer;
 
+    @inject(ContributionProvider) @named(TextReplacementContribution)
+    protected readonly replacementContributions: ContributionProvider<TextReplacementContribution>;
+
     async initialize(): Promise<void> {
         const defaultLocale = FrontendApplicationConfigProvider.get().defaultLocale;
         if (defaultLocale && !nls.locale) {
@@ -33,8 +38,9 @@ export class I18nPreloadContribution implements PreloadContribution {
                 locale: defaultLocale
             });
         }
+        let locale = nls.locale ?? nls.defaultLocale;
         if (nls.locale && nls.locale !== nls.defaultLocale) {
-            const localization = await this.localizationServer.loadLocalization(nls.locale);
+            const localization = await this.localizationServer.loadLocalization(locale);
             if (localization.languagePack) {
                 nls.localization = localization;
             } else {
@@ -43,8 +49,22 @@ export class I18nPreloadContribution implements PreloadContribution {
                 Object.assign(nls, {
                     locale: defaultLocale || undefined
                 });
+                locale = defaultLocale;
             }
         }
+        const replacements = this.getReplacements(locale);
+        if (Object.keys(replacements).length > 0) {
+            nls.localization ??= { translations: {}, languageId: locale };
+            nls.localization.replacements = replacements;
+        }
+    }
+
+    protected getReplacements(locale: string): Record<string, string> {
+        const replacements: Record<string, string> = {};
+        for (const contribution of this.replacementContributions.getContributions()) {
+            Object.assign(replacements, contribution.getReplacement(locale));
+        }
+        return replacements;
     }
 
 }

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

@@ -21,19 +21,21 @@ import { I18nPreloadContribution } from './i18n-preload-contribution';
 import { OSPreloadContribution } from './os-preload-contribution';
 import { ThemePreloadContribution } from './theme-preload-contribution';
 import { LocalizationServer, LocalizationServerPath } from '../../common/i18n/localization-server';
-import { WebSocketConnectionProvider } from '../messaging/ws-connection-provider';
+import { ServiceConnectionProvider } from '../messaging/service-connection-provider';
 import { OSBackendProvider, OSBackendProviderPath } from '../../common/os';
+import { TextReplacementContribution } from './text-replacement-contribution';
 
 export default new ContainerModule(bind => {
     bind(Preloader).toSelf().inSingletonScope();
     bindContributionProvider(bind, PreloadContribution);
+    bindContributionProvider(bind, TextReplacementContribution);
 
     bind(LocalizationServer).toDynamicValue(ctx =>
-        WebSocketConnectionProvider.createProxy<LocalizationServer>(ctx.container, LocalizationServerPath)
+        ServiceConnectionProvider.createProxy<LocalizationServer>(ctx.container, LocalizationServerPath)
     ).inSingletonScope();
 
     bind(OSBackendProvider).toDynamicValue(ctx =>
-        WebSocketConnectionProvider.createProxy<OSBackendProvider>(ctx.container, OSBackendProviderPath)
+        ServiceConnectionProvider.createProxy<OSBackendProvider>(ctx.container, OSBackendProviderPath)
     ).inSingletonScope();
 
     bind(I18nPreloadContribution).toSelf().inSingletonScope();

package/src/browser/preload/text-replacement-contribution.ts

@@ -0,0 +1,53 @@
+// *****************************************************************************
+// Copyright (C) 2025 TypeFox 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
+// *****************************************************************************
+
+export const TextReplacementContribution = Symbol('TextReplacementContribution');
+
+/**
+ * Enables adopters to override text in the application. All `TextReplacementContribution`s need to be bound in the `frontendPreload` scope of the package.json.
+ *
+ * @example Create a text replacement contribution
+ * ```typescript
+ *          import { TextReplacementContribution } from '@theia/core/lib/browser/preload/text-replacement-contribution';
+ *          export class TextSampleReplacementContribution implements TextReplacementContribution {
+ *              getReplacement(locale: string): Record<string, string> {
+ *                  switch (locale) {
+ *                      case 'en': {
+ *                          return {
+ *                              'About': 'About Theia',
+ *                          };
+ *                      }
+ *                      case 'de': {
+ *                          return {
+ *                              'About': 'Über Theia',
+ *                          };
+ *                      }
+ *                  }
+ *                  return {};
+ *              }
+ *          }
+ * ```
+ */
+export interface TextReplacementContribution {
+    /**
+     * This method returns a map of **default values** and their replacement values for the specified locale.
+     * **Do not** use the keys of the `nls.localization` call, but the English default values.
+     *
+     * @param locale The locale for which the replacement should be returned.
+     * @returns A map of default values and their replacement values.
+     */
+    getReplacement(locale: string): Record<string, string>;
+}

package/src/browser/shell/side-panel-handler.ts

@@ -240,7 +240,8 @@ export class SidePanelHandler {
         this.contextMenuRenderer.render({
             args: [title.owner],
             menuPath: SIDE_PANEL_TOOLBAR_CONTEXT_MENU,
-            anchor: e
+            anchor: e,
+            context: e.currentTarget instanceof HTMLElement ? e.currentTarget : this.tabBar.node
         });
     }
 

package/src/browser/shell/sidebar-bottom-menu-widget.tsx

@@ -32,7 +32,8 @@ export class SidebarBottomMenuWidget extends SidebarMenuWidget {
             anchor: {
                 x: button.left + button.width,
                 y: button.top + button.height,
-            }
+            },
+            context: e.currentTarget
         });
     }
 

package/src/browser/shell/sidebar-menu-widget.tsx

@@ -152,6 +152,7 @@ export class SidebarMenuWidget extends ReactWidget {
                 x: button.left + button.width,
                 y: button.top,
             },
+            context: e.currentTarget,
             onHide: () => {
                 this.preservingContext = false;
                 if (this.preservedContext) {

package/src/browser/shell/tab-bar-toolbar/tab-bar-toolbar.tsx

@@ -309,7 +309,7 @@ export class TabBarToolbar extends ReactWidget {
             menuPath: TAB_BAR_TOOLBAR_CONTEXT_MENU,
             args: [this.current],
             anchor,
-            context: this.current?.node,
+            context: this.current?.node || this.node,
             onHide: () => toDisposeOnHide.dispose(),
             skipSingleRootNode: true,
         });
@@ -375,7 +375,7 @@ export class TabBarToolbar extends ReactWidget {
             menuPath,
             args: [this.current],
             anchor,
-            context: this.current?.node,
+            context: this.current?.node || this.node,
             contextKeyService: contextMatcher,
             onHide: () => toDisposeOnHide.dispose()
         });

package/src/browser/shell/tab-bars.ts

@@ -653,6 +653,7 @@ export class TabBarRenderer extends TabBar.Renderer {
                 menuPath: this.contextMenuPath!,
                 anchor: event,
                 args: [event],
+                context: event.currentTarget,
                 contextKeyService: contextKeyServiceOverlay,
                 // We'd like to wait until the command triggered by the context menu has been run, but this should let it get through the preamble, at least.
                 onHide: () => setTimeout(() => { if (this.selectionService) { this.selectionService.selection = oldSelection; } })

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

@@ -1362,6 +1362,7 @@ export class TreeWidget extends ReactWidget implements StatefulWidget {
                 const args = this.toContextMenuArgs(node);
                 setTimeout(() => this.contextMenuRenderer.render({
                     menuPath: contextMenuPath,
+                    context: event.currentTarget,
                     anchor: { x, y },
                     args
                 }), 10);

package/src/browser/view-container.ts

@@ -170,7 +170,11 @@ export class ViewContainer extends BaseWidget implements StatefulWidget, Applica
                 if (event.button === 2 && every(this.containerLayout.iter(), part => !!part.isHidden)) {
                     event.stopPropagation();
                     event.preventDefault();
-                    contextMenuRenderer.render({ menuPath: this.contextMenuPath, anchor: event });
+                    contextMenuRenderer.render({
+                        menuPath: this.contextMenuPath,
+                        anchor: event,
+                        context: event.currentTarget instanceof HTMLElement ? event.currentTarget : this.node
+                    });
                 }
             }),
             commandRegistry.registerCommand({ id: this.globalHideCommandId }, {
@@ -436,7 +440,7 @@ export class ViewContainer extends BaseWidget implements StatefulWidget, Applica
                 if (event.button === 2) {
                     event.preventDefault();
                     event.stopPropagation();
-                    this.contextMenuRenderer.render({ menuPath: this.contextMenuPath, anchor: event });
+                    this.contextMenuRenderer.render({ menuPath: this.contextMenuPath, anchor: event, context: this.node });
                 }
             }),
             newPart.onTitleChanged(() => this.refreshMenu(newPart)),

package/src/browser/widgets/widget.ts

@@ -234,9 +234,11 @@ export class BaseWidget extends Widget implements PreviewableWidget {
     }
 
     override clearFlag(flag: Widget.Flag): void {
+        const wasVisible = this.isVisible;
         super.clearFlag(flag);
-        if (flag === Widget.Flag.IsVisible) {
-            this.handleVisiblityChanged(this.isVisible);
+        const isVisible = this.isVisible;
+        if (isVisible !== wasVisible) {
+            this.handleVisiblityChanged(isVisible);
         }
     }
 }

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/i18n/localization.ts

@@ -25,7 +25,8 @@ export interface AsyncLocalizationProvider {
 }
 
 export interface Localization extends LanguageInfo {
-    translations: { [key: string]: string };
+    translations: Record<string, string>;
+    replacements?: Record<string, string>;
 }
 
 export interface LanguageInfo {
@@ -50,9 +51,14 @@ export namespace Localization {
     export function localize(localization: Localization | undefined, key: string, defaultValue: string, ...args: FormatType[]): string {
         let value = defaultValue;
         if (localization) {
-            const translation = localization.translations[key];
-            if (translation) {
-                value = normalize(translation);
+            const replacement = localization.replacements?.[defaultValue];
+            if (typeof replacement === 'string') {
+                value = replacement;
+            } else {
+                const translation = localization.translations[key];
+                if (translation) {
+                    value = normalize(translation);
+                }
             }
         }
         return format(value, args);