@theia/core 1.45.0 → 1.46.0-next.106

package/src/browser-only/i18n/i18n-frontend-only-module.ts

@@ -0,0 +1,37 @@
+// *****************************************************************************
+// Copyright (C) 2023 EclipseSource 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 { ContainerModule } from 'inversify';
+import { AsyncLocalizationProvider, LanguageInfo, Localization } from '../../common/i18n/localization';
+import { LanguageQuickPickService } from '../../browser/i18n/language-quick-pick-service';
+
+export default new ContainerModule(bind => {
+    const i18nMock: AsyncLocalizationProvider = {
+        getCurrentLanguage: async (): Promise<string> => 'en',
+        setCurrentLanguage: async (_languageId: string): Promise<void> => {
+
+        },
+        getAvailableLanguages: async (): Promise<LanguageInfo[]> =>
+            []
+        ,
+        loadLocalization: async (_languageId: string): Promise<Localization> => ({
+            translations: {},
+            languageId: 'en'
+        })
+    };
+    bind(AsyncLocalizationProvider).toConstantValue(i18nMock);
+    bind(LanguageQuickPickService).toSelf().inSingletonScope();
+});

package/src/browser-only/logger-frontend-only-module.ts

@@ -0,0 +1,63 @@
+// *****************************************************************************
+// Copyright (C) 2023 EclipseSource 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 { ContainerModule, Container } from 'inversify';
+import { ILoggerServer, ILoggerClient, LogLevel, ConsoleLogger } from '../common/logger-protocol';
+import { ILogger, Logger, LoggerFactory, LoggerName } from '../common/logger';
+
+// is loaded directly after the regular logger frontend module
+export const loggerFrontendOnlyModule = new ContainerModule((bind, unbind, isBound, rebind) => {
+    const logger: ILoggerServer = {
+        setLogLevel: async (_name: string, _logLevel: number): Promise<void> => { },
+        getLogLevel: async (_name: string): Promise<number> => LogLevel.INFO,
+        log: async (name: string, logLevel: number, message: string, params: unknown[]): Promise<void> => {
+            ConsoleLogger.log(name, logLevel, message, params);
+
+        },
+        child: async (_name: string): Promise<void> => { },
+        dispose: (): void => {
+        },
+        setClient: (_client: ILoggerClient | undefined): void => {
+        }
+    };
+    if (isBound(ILoggerServer)) {
+        rebind(ILoggerServer).toConstantValue(logger);
+    } else {
+        bind(ILoggerServer).toConstantValue(logger);
+    }
+
+    if (isBound(ILoggerServer)) {
+        rebind(LoggerFactory).toFactory(ctx =>
+            (name: string) => {
+                const child = new Container({ defaultScope: 'Singleton' });
+                child.parent = ctx.container;
+                child.bind(ILogger).to(Logger).inTransientScope();
+                child.bind(LoggerName).toConstantValue(name);
+                return child.get(ILogger);
+            }
+        );
+    } else {
+        bind(LoggerFactory).toFactory(ctx =>
+            (name: string) => {
+                const child = new Container({ defaultScope: 'Singleton' });
+                child.parent = ctx.container;
+                child.bind(ILogger).to(Logger).inTransientScope();
+                child.bind(LoggerName).toConstantValue(name);
+                return child.get(ILogger);
+            }
+        );
+    }
+});

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

@@ -0,0 +1,39 @@
+// *****************************************************************************
+// Copyright (C) 2023 EclipseSource 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 { Event, RpcProxy, Channel, RpcProxyFactory, Emitter } from '../../common';
+import { injectable } from 'inversify';
+import { ServiceConnectionProvider } from '../../browser/messaging/service-connection-provider';
+import { ConnectionSource } from '../../browser/messaging/connection-source';
+
+@injectable()
+export class FrontendOnlyConnectionSource implements ConnectionSource {
+    onConnectionDidOpen = new Emitter<Channel>().event;
+}
+
+@injectable()
+export class FrontendOnlyServiceConnectionProvider extends ServiceConnectionProvider {
+    onSocketDidOpen = Event.None;
+    onSocketDidClose = Event.None;
+    onIncomingMessageActivity = Event.None;
+    override createProxy<T extends object>(path: unknown, target?: unknown): RpcProxy<T> {
+        console.debug(`[Frontend-Only Fallback] Created proxy connection for ${path}`);
+        const factory = target instanceof RpcProxyFactory ? target : new RpcProxyFactory<T>(target);
+        return factory.createProxy();
+    }
+    override listen(path: string, handler: ServiceConnectionProvider.ConnectionHandler, reconnect: boolean): void {
+        console.debug('[Frontend-Only Fallback] Listen to websocket connection requested');
+    }
+}

package/src/browser-only/messaging/messaging-frontend-only-module.ts

@@ -0,0 +1,42 @@
+// *****************************************************************************
+// Copyright (C) 2023 EclipseSource 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 { ContainerModule } from 'inversify';
+import { WebSocketConnectionSource } from '../../browser/messaging/ws-connection-source';
+import { FrontendOnlyConnectionSource, FrontendOnlyServiceConnectionProvider } from './frontend-only-service-connection-provider';
+import { ConnectionSource } from '../../browser/messaging/connection-source';
+import { LocalConnectionProvider, RemoteConnectionProvider } from '../../browser/messaging/service-connection-provider';
+
+// is loaded directly after the regular message frontend module
+export const messagingFrontendOnlyModule = new ContainerModule((bind, unbind, isBound, rebind) => {
+    unbind(WebSocketConnectionSource);
+    bind(FrontendOnlyConnectionSource).toSelf().inSingletonScope();
+    if (isBound(ConnectionSource)) {
+        rebind(ConnectionSource).toService(FrontendOnlyConnectionSource);
+    } else {
+        bind(ConnectionSource).toService(FrontendOnlyConnectionSource);
+    }
+    bind(FrontendOnlyServiceConnectionProvider).toSelf().inSingletonScope();
+    if (isBound(LocalConnectionProvider)) {
+        rebind(LocalConnectionProvider).toService(FrontendOnlyServiceConnectionProvider);
+    } else {
+        bind(LocalConnectionProvider).toService(FrontendOnlyServiceConnectionProvider);
+    }
+    if (isBound(RemoteConnectionProvider)) {
+        rebind(RemoteConnectionProvider).toService(FrontendOnlyServiceConnectionProvider);
+    } else {
+        bind(RemoteConnectionProvider).toService(FrontendOnlyServiceConnectionProvider);
+    }
+});

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

@@ -0,0 +1,49 @@
+// *****************************************************************************
+// Copyright (C) 2023 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
+// *****************************************************************************
+
+import { ContainerModule } from 'inversify';
+import { LocalizationServer } from '../../common/i18n/localization-server';
+import { OS, OSBackendProvider } from '../../common/os';
+import { Localization } from '../../common/i18n/localization';
+
+// loaded after regular preload module
+export default new ContainerModule((bind, unbind, isBound, rebind) => {
+    const frontendOnlyLocalizationServer: LocalizationServer = {
+        loadLocalization: async (languageId: string): Promise<Localization> => ({ translations: {}, languageId })
+    };
+    if (isBound(LocalizationServer)) {
+        rebind(LocalizationServer).toConstantValue(frontendOnlyLocalizationServer);
+    } else {
+        bind(LocalizationServer).toConstantValue(frontendOnlyLocalizationServer);
+    }
+
+    const frontendOnlyOSBackendProvider: OSBackendProvider = {
+        getBackendOS: async (): Promise<OS.Type> => {
+            if (window.navigator.platform.startsWith('Win')) {
+                return OS.Type.Windows;
+            } else if (window.navigator.platform.startsWith('Mac')) {
+                return OS.Type.OSX;
+            } else {
+                return OS.Type.Linux;
+            }
+        }
+    };
+    if (isBound(OSBackendProvider)) {
+        rebind(OSBackendProvider).toConstantValue(frontendOnlyOSBackendProvider);
+    } else {
+        bind(OSBackendProvider).toConstantValue(frontendOnlyOSBackendProvider);
+    }
+});

package/src/common/application-protocol.ts

@@ -23,6 +23,7 @@ export const ApplicationServer = Symbol('ApplicationServer');
 export interface ApplicationServer {
     getExtensionsInfos(): Promise<ExtensionInfo[]>;
     getApplicationInfo(): Promise<ApplicationInfo | undefined>;
+    getApplicationRoot(): Promise<string>;
     /**
      * @deprecated since 1.25.0. Use `OS.backend.type()` instead.
      */

package/src/common/disposable.spec.ts

@@ -14,8 +14,11 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import { expect } from 'chai';
+import { expect, spy, use } from 'chai';
 import { DisposableCollection, Disposable } from './disposable';
+import * as spies from 'chai-spies';
+
+use(spies);
 
 describe('Disposables', () => {
     it('Is safe to use Disposable.NULL', () => {
@@ -26,4 +29,66 @@ describe('Disposables', () => {
         expect(collectionA.disposed, 'A should be disposed after being disposed.').to.be.true;
         expect(collectionB.disposed, 'B should not be disposed because A was disposed.').to.be.false;
     });
+
+    it('Collection is auto-pruned when an element is disposed', () => {
+        const onDispose = spy(() => { });
+        const elementDispose = () => { };
+
+        const collection = new DisposableCollection();
+        collection.onDispose(onDispose);
+
+        const disposable1 = Disposable.create(elementDispose);
+        collection.push(disposable1);
+        expect(collection['disposables']).to.have.lengthOf(1);
+
+        const disposable2 = Disposable.create(elementDispose);
+        collection.push(disposable2);
+        expect(collection['disposables']).to.have.lengthOf(2);
+
+        disposable1.dispose();
+        expect(collection['disposables']).to.have.lengthOf(1);
+        expect(onDispose).to.have.not.been.called();
+        expect(collection.disposed).is.false;
+
+        // Test that calling dispose on an already disposed element doesn't
+        // alter the collection state
+        disposable1.dispose();
+        expect(collection['disposables']).to.have.lengthOf(1);
+        expect(onDispose).to.have.not.been.called();
+        expect(collection.disposed).is.false;
+
+        disposable2.dispose();
+        expect(collection['disposables']).to.be.empty;
+        expect(collection.disposed).is.true;
+        expect(onDispose).to.have.been.called.once;
+    });
+
+    it('onDispose is only called once on actual disposal of elements', () => {
+        const onDispose = spy(() => { });
+        const elementDispose = spy(() => { });
+
+        const collection = new DisposableCollection();
+        collection.onDispose(onDispose);
+
+        // if the collection is empty 'onDispose' is not called
+        collection.dispose();
+        expect(onDispose).to.not.have.been.called();
+
+        // 'onDispose' is called because we actually dispose an element
+        collection.push(Disposable.create(elementDispose));
+        collection.dispose();
+        expect(elementDispose).to.have.been.called.once;
+        expect(onDispose).to.have.been.called.once;
+
+        // if the collection is empty 'onDispose' is not called and no further element is disposed
+        collection.dispose();
+        expect(elementDispose).to.have.been.called.once;
+        expect(onDispose).to.have.been.called.once;
+
+        // 'onDispose' is not called again even if we actually dispose an element
+        collection.push(Disposable.create(elementDispose));
+        collection.dispose();
+        expect(elementDispose).to.have.been.called.twice;
+        expect(onDispose).to.have.been.called.once;
+    });
 });

package/src/common/disposable.ts

@@ -47,6 +47,34 @@ Object.defineProperty(Disposable, 'NULL', {
     }
 });
 
+/**
+ * Utility for tracking a collection of Disposable objects.
+ *
+ * This utility provides a number of benefits over just using an array of
+ * Disposables:
+ *
+ * - the collection is auto-pruned when an element it contains is disposed by
+ * any code that has a reference to it
+ * - you can register to be notified when all elements in the collection have
+ * been disposed [1]
+ * - you can conveniently dispose all elements by calling dispose()
+ * on the collection
+ *
+ * Unlike an array, however, this utility does not give you direct access to
+ * its elements.
+ *
+ * Being notified when all elements are disposed is simple:
+ * ```
+ * const dc = new DisposableCollection(myDisposables);
+ * dc.onDispose(() => {
+ *    console.log('All elements in the collection have been disposed');
+ * });
+ * ```
+ *
+ * [1] The collection will notify only once. It will continue to function in so
+ * far as accepting new Disposables and pruning them when they are disposed, but
+ * such activity will never result in another notification.
+ */
 export class DisposableCollection implements Disposable {
 
     protected readonly disposables: Disposable[] = [];
@@ -133,3 +161,28 @@ export function disposableTimeout(...args: Parameters<typeof setTimeout>): Dispo
     const handle = setTimeout(...args);
     return { dispose: () => clearTimeout(handle) };
 }
+
+/**
+ * Wrapper for a {@link Disposable} that is not available immediately.
+ */
+export class DisposableWrapper implements Disposable {
+
+    private disposed = false;
+    private disposable: Disposable | undefined = undefined;
+
+    set(disposable: Disposable): void {
+        if (this.disposed) {
+            disposable.dispose();
+        } else {
+            this.disposable = disposable;
+        }
+    }
+
+    dispose(): void {
+        this.disposed = true;
+        if (this.disposable) {
+            this.disposable.dispose();
+            this.disposable = undefined;
+        }
+    }
+}

package/src/{node → common}/file-uri.ts

@@ -15,8 +15,8 @@
 // *****************************************************************************
 
 import { URI as Uri } from 'vscode-uri';
-import URI from '../common/uri';
-import { isWindows } from '../common/os';
+import URI from './uri';
+import { isWindows } from './os';
 
 export namespace FileUri {
 

package/src/common/index.ts

@@ -46,5 +46,6 @@ export * from './strings';
 export * from './telemetry';
 export * from './types';
 export { default as URI } from './uri';
+export * from './uuid';
 export * from './view-column';
 export * from './version';

package/src/common/markdown-rendering/markdown-string.ts

@@ -19,9 +19,13 @@ import { UriComponents } from '../uri';
 import { escapeIcons } from './icon-utilities';
 import { isObject, isString } from '../types';
 
+export interface MarkdownStringTrustedOptions {
+    readonly enabledCommands: readonly string[];
+}
+
 export interface MarkdownString {
     readonly value: string;
-    readonly isTrusted?: boolean;
+    readonly isTrusted?: boolean | MarkdownStringTrustedOptions;
     readonly supportThemeIcons?: boolean;
     readonly supportHtml?: boolean;
     readonly baseUri?: UriComponents;
@@ -45,9 +49,8 @@ export namespace MarkdownString {
 // Copied from https://github.com/microsoft/vscode/blob/7d9b1c37f8e5ae3772782ba3b09d827eb3fdd833/src/vs/base/common/htmlContent.ts
 
 export class MarkdownStringImpl implements MarkdownString {
-
     public value: string;
-    public isTrusted?: boolean;
+    public isTrusted?: boolean | MarkdownStringTrustedOptions;
     public supportThemeIcons?: boolean;
     public supportHtml?: boolean;
     public baseUri?: UriComponents;

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

@@ -0,0 +1,67 @@
+// *****************************************************************************
+// Copyright (C) 2024 EclipseSource 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 { CompositeMenuNode } from './composite-menu-node';
+import { CompoundMenuNodeRole } from './menu-types';
+
+describe('composite-menu-node', () => {
+    describe('updateOptions', () => {
+        it('should update undefined node properties', () => {
+            const node = new CompositeMenuNode('test-id');
+            node.updateOptions({ label: 'node-label', icon: 'icon', order: 'a', role: CompoundMenuNodeRole.Flat, when: 'node-condition' });
+            expect(node.label).to.equal('node-label');
+            expect(node.icon).to.equal('icon');
+            expect(node.order).to.equal('a');
+            expect(node.role).to.equal(CompoundMenuNodeRole.Flat);
+            expect(node.when).to.equal('node-condition');
+        });
+        it('should update existing node properties', () => {
+            const node = new CompositeMenuNode('test-id', 'test-label', { icon: 'test-icon', order: 'a1', role: CompoundMenuNodeRole.Submenu, when: 'test-condition' });
+            node.updateOptions({ label: 'NEW-label', icon: 'NEW-icon', order: 'a2', role: CompoundMenuNodeRole.Flat, when: 'NEW-condition' });
+            expect(node.label).to.equal('NEW-label');
+            expect(node.icon).to.equal('NEW-icon');
+            expect(node.order).to.equal('a2');
+            expect(node.role).to.equal(CompoundMenuNodeRole.Flat);
+            expect(node.when).to.equal('NEW-condition');
+        });
+        it('should update only the icon without affecting other properties', () => {
+            const node = new CompositeMenuNode('test-id', 'test-label', { icon: 'test-icon', order: 'a' });
+            node.updateOptions({ icon: 'NEW-icon' });
+            expect(node.label).to.equal('test-label');
+            expect(node.icon).to.equal('NEW-icon');
+            expect(node.order).to.equal('a');
+        });
+        it('should not allow to unset properties', () => {
+            const node = new CompositeMenuNode('test-id', 'test-label', { icon: 'test-icon', order: 'a' });
+            node.updateOptions({ icon: undefined });
+            expect(node.label).to.equal('test-label');
+            expect(node.icon).to.equal('test-icon');
+            expect(node.order).to.equal('a');
+        });
+        it('should allow to set empty strings in properties', () => {
+            const node = new CompositeMenuNode('test-id', 'test-label');
+            node.updateOptions({ label: '' });
+            expect(node.label).to.equal('');
+        });
+        it('should not cause side effects when updating a property to its existing value', () => {
+            const node = new CompositeMenuNode('test-id', 'test-label', { icon: 'test-icon', order: 'a' });
+            node.updateOptions({ icon: 'test-icon' });
+            expect(node.label).to.equal('test-label');
+            expect(node.icon).to.equal('test-icon');
+            expect(node.order).to.equal('a');
+        });
+    });
+});

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

@@ -63,11 +63,11 @@ export class CompositeMenuNode implements MutableCompoundMenuNode {
 
     updateOptions(options?: SubMenuOptions): void {
         if (options) {
-            this.iconClass ??= options.icon ?? options.iconClass;
-            this.label ??= options.label;
-            this.order ??= options.order;
-            this._role ??= options.role;
-            this._when ??= options.when;
+            this.iconClass = options.icon ?? options.iconClass ?? this.iconClass;
+            this.label = options.label ?? this.label;
+            this.order = options.order ?? this.order;
+            this._role = options.role ?? this._role;
+            this._when = options.when ?? this._when;
         }
     }
 

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

@@ -14,13 +14,13 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import { injectable, inject, named } from 'inversify';
-import { Disposable } from '../disposable';
-import { CommandRegistry, Command } from '../command';
+import { inject, injectable, named } from 'inversify';
+import { Command, CommandRegistry } from '../command';
 import { ContributionProvider } from '../contribution-provider';
-import { CompositeMenuNode, CompositeMenuNodeWrapper } from './composite-menu-node';
-import { CompoundMenuNode, MenuAction, MenuNode, MenuPath, MutableCompoundMenuNode, SubMenuOptions } from './menu-types';
+import { Disposable } from '../disposable';
 import { ActionMenuNode } from './action-menu-node';
+import { CompositeMenuNode, CompositeMenuNodeWrapper } from './composite-menu-node';
+import { CompoundMenuNode, MenuAction, MenuNode, MenuNodeMetadata, MenuPath, MutableCompoundMenuNode, SubMenuOptions } from './menu-types';
 
 export const MenuContribution = Symbol('MenuContribution');
 
@@ -157,6 +157,23 @@ export class MenuModelRegistry {
     linkSubmenu(parentPath: MenuPath | string, childId: string | MenuPath, options?: SubMenuOptions, group?: string): Disposable {
         const child = this.getMenuNode(childId);
         const parent = this.getMenuNode(parentPath, group);
+
+        const isRecursive = (node: MenuNodeMetadata, childNode: MenuNodeMetadata): boolean => {
+            if (node.id === childNode.id) {
+                return true;
+            }
+            if (node.parent) {
+                return isRecursive(node.parent, childNode);
+            }
+            return false;
+        };
+
+        // check for menu contribution recursion
+        if (isRecursive(parent, child)) {
+            console.warn(`Recursive menu contribution detected: ${child.id} is already in hierarchy of ${parent.id}.`);
+            return Disposable.NULL;
+        }
+
         const wrapper = new CompositeMenuNodeWrapper(child, parent, options);
         return parent.addNode(wrapper);
     }

package/src/common/menu/menu.spec.ts

@@ -14,10 +14,10 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import { CommandContribution, CommandRegistry } from '../command';
-import { MenuContribution, MenuModelRegistry } from './menu-model-registry';
 import * as chai from 'chai';
+import { CommandContribution, CommandRegistry } from '../command';
 import { CompositeMenuNode } from './composite-menu-node';
+import { MenuContribution, MenuModelRegistry } from './menu-model-registry';
 
 const expect = chai.expect;
 
@@ -61,6 +61,25 @@ describe('menu-model-registry', () => {
             expect(openGroup.children.length).equals(2);
             expect(openGroup.label).undefined;
         });
+
+        it('Should not allow to register cyclic menus.', () => {
+            const fileMenu = ['main', 'File'];
+            const fileOpenMenu = [...fileMenu, '0_open'];
+            const fileCloseMenu = [...fileMenu, '1_close'];
+            const service = createMenuRegistry({
+                registerMenus(menuRegistry: MenuModelRegistry): void {
+                    menuRegistry.registerSubmenu(fileMenu, 'File');
+                    // open menu should not be added to open menu
+                    menuRegistry.linkSubmenu(fileOpenMenu, fileOpenMenu);
+                    // close menu should be added
+                    menuRegistry.linkSubmenu(fileOpenMenu, fileCloseMenu);
+                }
+            }, {
+                registerCommands(reg: CommandRegistry): void { }
+            });
+            const all = service.getMenu() as CompositeMenuNode;
+            expect(menuStructureToString(all.children[0] as CompositeMenuNode)).equals('File(0_open(1_close),1_close())');
+        });
     });
 });
 
@@ -71,3 +90,12 @@ function createMenuRegistry(menuContrib: MenuContribution, commandContrib: Comma
     menuReg.onStart();
     return menuReg;
 }
+
+function menuStructureToString(node: CompositeMenuNode): string {
+    return node.children.map(c => {
+        if (c instanceof CompositeMenuNode) {
+            return `${c.id}(${menuStructureToString(c)})`;
+        }
+        return c.id;
+    }).join(',');
+}

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

@@ -21,7 +21,7 @@ import { addExtension } from 'msgpackr';
  * required for the default RPC communication. MsgPackR extensions
  * are installed globally on both ends of the communication channel.
  * (frontend-backend, pluginExt-pluginMain).
- * Is implemented as singleton as it is  also used in plugin child processes which have no access to inversify.
+ * Is implemented as singleton as it is also used in plugin child processes which have no access to inversify.
  */
 export class MsgPackExtensionManager {
     private static readonly INSTANCE = new MsgPackExtensionManager();