@eclipse-glsp/client 2.3.0-next.322 → 2.3.0-next.363

package/src/base/selection-service.ts

@@ -25,9 +25,9 @@ import {
     GModelElement,
     GModelRoot,
     ILogger,
+    LazyInjector,
     SelectAction,
     SelectAllAction,
-    Selectable,
     SprottySelectAllCommand,
     SprottySelectCommand,
     TYPES,
@@ -35,10 +35,11 @@ import {
     isSelectable,
     pluck
 } from '@eclipse-glsp/sprotty';
-import { inject, injectable, multiInject, optional, postConstruct, preDestroy } from 'inversify';
-import { getElements, getMatchingElements } from '../utils/gmodel-util';
-import { GLSPCommandStack, IGModelRootListener } from './command-stack';
+import { inject, injectable, postConstruct, preDestroy } from 'inversify';
+import { SelectableElement, getElements, getMatchingElements } from '../utils/gmodel-util';
+import { IGModelRootListener } from './editor-context-service';
 import { IFeedbackActionDispatcher } from './feedback/feedback-action-dispatcher';
+import { IDiagramStartup } from './model/diagram-loader';
 
 export interface ISelectionListener {
     selectionChanged(root: Readonly<GModelRoot>, selectedElements: string[], deselectedElements?: string[]): void;
@@ -51,35 +52,34 @@ export interface SelectionChange {
 }
 
 @injectable()
-export class SelectionService implements IGModelRootListener, Disposable {
-    protected root: Readonly<GModelRoot>;
-    protected selectedElementIDs: Set<string> = new Set();
-
+export class SelectionService implements IGModelRootListener, Disposable, IDiagramStartup {
     @inject(TYPES.IFeedbackActionDispatcher)
     protected feedbackDispatcher: IFeedbackActionDispatcher;
 
+    @inject(LazyInjector)
+    protected lazyInjector: LazyInjector;
+
     @inject(TYPES.ILogger)
     protected logger: ILogger;
 
-    @inject(TYPES.ICommandStack)
-    protected commandStack: GLSPCommandStack;
-
-    @multiInject(TYPES.ISelectionListener)
-    @optional()
-    protected selectionListeners: ISelectionListener[] = [];
+    protected root: Readonly<GModelRoot>;
+    protected selectedElementIDs: Set<string> = new Set();
 
     protected toDispose = new DisposableCollection();
 
     @postConstruct()
     protected initialize(): void {
-        this.toDispose.push(
-            this.onSelectionChangedEmitter,
-            this.commandStack.onModelRootChanged(root => this.modelRootChanged(root))
-        );
-
-        this.selectionListeners.forEach(listener =>
-            this.onSelectionChanged(change => listener.selectionChanged(change.root, change.selectedElements, change.deselectedElements))
-        );
+        this.toDispose.push(this.onSelectionChangedEmitter);
+    }
+
+    preLoadDiagram(): void {
+        this.lazyInjector
+            .getAll<ISelectionListener>('selectionListener')
+            .forEach(listener =>
+                this.onSelectionChanged(change =>
+                    listener.selectionChanged(change.root, change.selectedElements, change.deselectedElements)
+                )
+            );
     }
 
     @preDestroy()
@@ -163,7 +163,7 @@ export class SelectionService implements IGModelRootListener, Disposable {
         return this.root;
     }
 
-    getSelectedElements(): Readonly<GModelElement & Selectable>[] {
+    getSelectedElements(): Readonly<SelectableElement>[] {
         return !this.root ? [] : getElements(this.root.index, Array.from(this.selectedElementIDs), isSelectable);
     }
 

package/src/base/tool-manager/tool-manager.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2019-2023 EclipseSource and others.
+ * Copyright (c) 2019-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
@@ -14,19 +14,24 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 
-import { inject, injectable, multiInject, optional } from 'inversify';
 import {
     Action,
     EditMode,
+    GModelElement,
     IActionHandler,
     ICommand,
     KeyListener,
-    GModelElement,
+    LazyInjector,
+    MaybePromise,
     TYPES,
     distinctAdd,
-    matchesKeystroke
+    matchesKeystroke,
+    pluck
 } from '@eclipse-glsp/sprotty';
-import { EditorContextService, EditorContextServiceProvider } from '../editor-context-service';
+import { inject, injectable } from 'inversify';
+import { EditorContextService, IEditModeListener } from '../editor-context-service';
+import { IDiagramStartup } from '../model/diagram-loader';
+import { Ranked } from '../ranked';
 import { EnableDefaultToolsAction, EnableToolsAction, Tool } from './tool';
 /**
  * A tool manager coordinates the state of tools in the context of an editor.
@@ -45,6 +50,9 @@ export interface IToolManager {
     /** The currently active tools, which are either specifically enabled tools, or the default tools. */
     readonly activeTools: Tool[];
 
+    /** Flag to indicate that the default tools are enabled and no other tool was explicitly enabled. */
+    readonly defaultToolsEnabled: boolean;
+
     /**
      * Enables the tools with the specified `toolIds`.
      * Therefore, this manager first disables currently active tools and then enable the
@@ -58,7 +66,7 @@ export interface IToolManager {
     enable(toolIds: string[]): void;
 
     /**
-     * Enables all default tools.
+     * Enables all default tools. If the default tools are already enabled, this is a no-op.
      */
     enableDefaultTools(): void;
 
@@ -75,27 +83,28 @@ export interface IToolManager {
  * registration of tools via Dependency Injection.
  */
 @injectable()
-export class ToolManager implements IToolManager {
+export class ToolManager implements IToolManager, IDiagramStartup, IEditModeListener {
+    @inject(EditorContextService)
+    protected editorContext: EditorContextService;
+
+    @inject(LazyInjector)
+    protected readonly lazyInjector: LazyInjector;
+
     readonly actives: Tool[] = [];
+    readonly tools: Tool[] = [];
+    readonly defaultTools: Tool[] = [];
+
+    protected _defaultToolsEnabled = false;
+    get defaultToolsEnabled(): boolean {
+        return this._defaultToolsEnabled;
+    }
 
-    protected editorContext?: EditorContextService;
-
-    constructor(
-        @multiInject(TYPES.ITool)
-        @optional()
-        readonly tools: Tool[] = [],
-        @multiInject(TYPES.IDefaultTool)
-        @optional()
-        readonly defaultTools: Tool[],
-        @inject(TYPES.IEditorContextServiceProvider) protected contextServiceProvider: EditorContextServiceProvider
-    ) {
-        this.registerTools(...this.tools);
-        this.registerDefaultTools(...this.defaultTools);
+    preLoadDiagram(): MaybePromise<void> {
+        const tools: Tool[] = this.lazyInjector.getAll(TYPES.ITool);
+        const defaultTools: Tool[] = this.lazyInjector.getAll(TYPES.IDefaultTool);
+        this.registerTools(...tools);
+        this.registerDefaultTools(...defaultTools);
         this.enableDefaultTools();
-        this.contextServiceProvider().then(editorContext => {
-            editorContext.onEditModeChanged(change => this.editModeChanged(change.newValue, change.oldValue));
-            this.editorContext = editorContext;
-        });
     }
 
     get managedTools(): Tool[] {
@@ -106,6 +115,10 @@ export class ToolManager implements IToolManager {
         return this.actives;
     }
 
+    get rank(): number {
+        return Ranked.DEFAULT_RANK - 100;
+    }
+
     registerDefaultTools(...tools: Tool[]): void {
         distinctAdd(this.defaultTools, ...tools);
     }
@@ -115,12 +128,17 @@ export class ToolManager implements IToolManager {
     }
 
     disableActiveTools(): void {
+        this._defaultToolsEnabled = false;
         this.actives.forEach(tool => tool.disable());
         this.actives.splice(0, this.actives.length);
     }
 
     enableDefaultTools(): void {
-        this.enable(this.defaultTools.map(tool => tool.id));
+        if (this.defaultToolsEnabled) {
+            return;
+        }
+        this.enable(pluck(this.defaultTools, 'id'));
+        this._defaultToolsEnabled = true;
     }
 
     enable(toolIds: string[]): void {

package/src/base/ui-extension/ui-extension-registry.ts

@@ -0,0 +1,33 @@
+/********************************************************************************
+ * 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 WITH Classpath-exception-2.0
+ ********************************************************************************/
+
+import { IUIExtension, LazyInjector, MaybePromise, TYPES, UIExtensionRegistry } from '@eclipse-glsp/sprotty';
+import { inject, injectable, optional } from 'inversify';
+import { IDiagramStartup } from '../model/diagram-loader';
+
+@injectable()
+export class GLSPUIExtensionRegistry extends UIExtensionRegistry implements IDiagramStartup {
+    @inject(LazyInjector)
+    protected lazyInjector: LazyInjector;
+
+    constructor(@optional() extensions: IUIExtension[] = []) {
+        super(extensions);
+    }
+
+    preLoadDiagram(): MaybePromise<void> {
+        this.lazyInjector.getAll<IUIExtension>(TYPES.IUIExtension).forEach(extension => this.register(extension.id(), extension));
+    }
+}

package/src/base/ui-extension/ui-extension.ts

@@ -0,0 +1,119 @@
+/********************************************************************************
+ * 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 WITH Classpath-exception-2.0
+ ********************************************************************************/
+
+import { AbstractUIExtension } from '@eclipse-glsp/sprotty';
+import { injectable } from 'inversify';
+
+export const CSS_UI_EXTENSION_CLASS = 'ui-extension';
+export const CSS_HIDDEN_EXTENSION_CLASS = 'hidden';
+
+/**
+ * Reusable abstract base implementation for UI extensions.
+ * Intended for UI extensions that directly interact with the DOM API to create and manage UI elements.
+ */
+@injectable()
+export abstract class GLSPAbstractUIExtension extends AbstractUIExtension {
+    protected get diagramContainerId(): string {
+        return this.options.baseDiv;
+    }
+
+    protected get parentContainerSelector(): string {
+        return '#' + this.diagramContainerId;
+    }
+
+    protected get containerSelector(): string {
+        return '#' + this.id();
+    }
+
+    protected get initialized(): boolean {
+        return !!this.containerElement;
+    }
+
+    protected override initialize(): boolean {
+        if (this.initialized) {
+            return true;
+        }
+        try {
+            this.containerElement = this.getOrCreateContainer();
+            this.initializeContainer(this.containerElement);
+            this.initializeContents(this.containerElement);
+        } catch (error) {
+            const msg = error instanceof Error ? error.message : `Could not retrieve container element for UI extension ${this.id}`;
+            this.logger.error(this, msg);
+            return false;
+        }
+        return true;
+    }
+
+    protected override getOrCreateContainer(): HTMLElement {
+        if (this.containerElement) {
+            return this.containerElement;
+        }
+        // check if the container already exists, independent from any potential parent container
+        // this allows us to use existing elements defined anywhere in the document
+        const existingContainer = this.getContainer();
+        if (existingContainer) {
+            return existingContainer;
+        }
+        // to create a container the parent container
+        const parent = this.getParentContainer();
+        if (!parent?.isConnected) {
+            throw new Error(`Could not obtain attached parent for initializing UI extension ${this.id}`);
+        }
+        const container = this.createContainer(parent);
+        this.insertContainerIntoParent(container, parent);
+        return container;
+    }
+
+    protected getContainer(): HTMLElement | null {
+        return document.querySelector<HTMLElement>(this.containerSelector);
+    }
+
+    protected createContainer(parent: HTMLElement): HTMLElement {
+        const container = document.createElement('div');
+        container.id = parent.id + '_' + this.id();
+        return container;
+    }
+
+    protected initializeContainer(container: HTMLElement): void {
+        container.classList.add(CSS_UI_EXTENSION_CLASS, this.containerClass());
+    }
+
+    protected getParentContainer(): HTMLElement | null {
+        return document.querySelector<HTMLElement>(this.parentContainerSelector)!;
+    }
+
+    protected insertContainerIntoParent(container: HTMLElement, parent: HTMLElement): void {
+        parent.insertBefore(container, parent.firstChild);
+    }
+
+    protected override setContainerVisible(visible: boolean): void {
+        // the parent class simply sets the style directly, however classes provide more fine-grained control
+        if (visible) {
+            this.containerElement?.classList.remove(CSS_HIDDEN_EXTENSION_CLASS);
+        } else {
+            this.containerElement?.classList.add(CSS_HIDDEN_EXTENSION_CLASS);
+        }
+    }
+
+    protected isContainerVisible(): boolean {
+        return !this.containerElement?.classList.contains(CSS_HIDDEN_EXTENSION_CLASS);
+    }
+
+    protected toggleContainerVisible(): void {
+        this.setContainerVisible(!this.isContainerVisible());
+    }
+}

package/src/base/view/key-tool.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2023 EclipseSource and others.
+ * Copyright (c) 2023-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
@@ -13,13 +13,25 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { injectable } from 'inversify';
-import { Disposable, KeyListener, KeyTool } from '@eclipse-glsp/sprotty';
+import { Disposable, KeyListener, KeyTool, LazyInjector, MaybePromise, TYPES } from '@eclipse-glsp/sprotty';
+import { inject, injectable, optional } from 'inversify';
+import { IDiagramStartup } from '../model/diagram-loader';
 
 @injectable()
-export class GLSPKeyTool extends KeyTool {
+export class GLSPKeyTool extends KeyTool implements IDiagramStartup {
+    @inject(LazyInjector)
+    protected lazyInjector: LazyInjector;
+
+    constructor(@optional() keyListeners: KeyListener[] = []) {
+        super(keyListeners);
+    }
+
     registerListener(keyListener: KeyListener): Disposable {
         super.register(keyListener);
         return Disposable.create(() => this.deregister(keyListener));
     }
+
+    preLoadDiagram(): MaybePromise<void> {
+        this.lazyInjector.getAll<KeyListener>(TYPES.KeyListener).forEach(listener => this.register(listener));
+    }
 }

package/src/base/view/mouse-tool.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2019-2023 EclipseSource and others.
+ * Copyright (c) 2019-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
@@ -13,8 +13,19 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { injectable, multiInject, optional } from 'inversify';
-import { Action, Disposable, MouseListener, MouseTool, GModelElement, GModelRoot, TYPES } from '@eclipse-glsp/sprotty';
+import {
+    Action,
+    Disposable,
+    GModelElement,
+    GModelRoot,
+    LazyInjector,
+    MaybePromise,
+    MouseListener,
+    MouseTool,
+    TYPES
+} from '@eclipse-glsp/sprotty';
+import { inject, injectable, optional } from 'inversify';
+import { IDiagramStartup } from '../model/diagram-loader';
 import { Ranked } from '../ranked';
 
 /**
@@ -24,12 +35,18 @@ import { Ranked } from '../ranked';
 type MouseListenerMethods = keyof Omit<MouseListener, 'decorate'>;
 
 @injectable()
-export class GLSPMouseTool extends MouseTool {
+export class GLSPMouseTool extends MouseTool implements IDiagramStartup {
+    @inject(LazyInjector)
+    protected lazyInjector: LazyInjector;
+
     protected rankedMouseListeners: Map<number, MouseListener[]>;
 
-    constructor(@multiInject(TYPES.MouseListener) @optional() protected override mouseListeners: MouseListener[] = []) {
+    constructor(@optional() mouseListeners: MouseListener[] = []) {
         super(mouseListeners);
-        this.rankedMouseListeners = groupBy(mouseListeners, listener => Ranked.getRank(listener));
+    }
+
+    preLoadDiagram(): MaybePromise<void> {
+        this.lazyInjector.getAll<MouseListener>(TYPES.MouseListener).forEach(listener => this.register(listener));
     }
 
     override register(mouseListener: MouseListener): void {

package/src/default-modules.spec.ts

@@ -0,0 +1,56 @@
+/********************************************************************************
+ * 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 WITH Classpath-exception-2.0
+ ********************************************************************************/
+import { FeatureModule } from '@eclipse-glsp/sprotty';
+import { expect } from 'chai';
+import { Container } from 'inversify';
+import * as sinon from 'sinon';
+import { defaultModule } from './base/default.module';
+import { DEFAULT_MODULES, initializeDiagramContainer } from './default-modules';
+
+describe('default-modules', () => {
+    // InitializeDiagramContainer internally uses `resolveContainerConfiguration` so we only test functionality
+    // that is not covered by the tests of `resolveContainerConfiguration`.
+    describe('initializeDiagramContainer', () => {
+        const sandbox = sinon.createSandbox();
+        const container = new Container();
+        const loadSpy = sandbox.spy(container, 'load');
+        container.snapshot();
+
+        beforeEach(() => {
+            sandbox.reset();
+            container.restore();
+            container.snapshot();
+        });
+        it('should initialize the diagram container with the default modules in addition to the given config and load them first', () => {
+            const extraModule = new FeatureModule(() => {});
+            initializeDiagramContainer(container, { add: extraModule });
+            expect(loadSpy.calledOnce).to.be.true;
+            const callArgs = loadSpy.firstCall.args;
+            const lastModule = callArgs.pop();
+            expect(callArgs).to.be.deep.equal(DEFAULT_MODULES).ordered;
+            expect(lastModule).to.be.equal(extraModule);
+        });
+        it('should throw an error if the base (default) module is removed via configuration', () => {
+            expect(() => initializeDiagramContainer(container, { remove: defaultModule })).to.throw(/Invalid module configuration/);
+        });
+        // eslint-disable-next-line max-len
+        it('should throw an error if the base (default) module is not the first module of the resolved configured (removed and added again)', () => {
+            expect(() => initializeDiagramContainer(container, { remove: defaultModule, add: defaultModule })).to.throw(
+                /Invalid module configuration/
+            );
+        });
+    });
+});

package/src/default-modules.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2021-2023 EclipseSource and others.
+ * Copyright (c) 2021-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
@@ -26,7 +26,6 @@ import {
     edgeLayoutModule,
     expandModule,
     fadeModule,
-    labelEditUiModule,
     modelSourceModule,
     resolveContainerConfiguration,
     zorderModule
@@ -43,6 +42,7 @@ import { elementTemplateModule } from './features/element-template/element-templ
 import { exportModule } from './features/export/export-modules';
 import { typeHintsModule } from './features/hints/type-hints-module';
 import { hoverModule } from './features/hover/hover-module';
+import { labelEditUiModule } from './features/label-edit-ui/label-edit-ui-module';
 import { labelEditModule } from './features/label-edit/label-edit-module';
 import { layoutModule } from './features/layout/layout-module';
 import { navigationModule } from './features/navigation/navigation-module';
@@ -106,11 +106,14 @@ export const DEFAULT_MODULES = [
  * Wraps the {@link configureDiagramOptions} utility function in a module. Adopters can either include this
  * module into the container {@link ModuleConfiguration} or configure the container after its creation
  * (e.g. using the {@link configureDiagramOptions} utility function).
- * @param options The diagram instance specific configuration options
+ * @param diagramOptions The diagram instance specific configuration options
+ * @param viewerOptions Optional {@link ViewerOptions} that should be configured
  * @returns The corresponding {@link FeatureModule}
  */
-export function createDiagramOptionsModule(options: IDiagramOptions): FeatureModule {
-    return new FeatureModule((bind, unbind, isBound, rebind) => configureDiagramOptions({ bind, unbind, isBound, rebind }, options));
+export function createDiagramOptionsModule(diagramOptions: IDiagramOptions, viewerOptions?: Partial<ViewerOptions>): FeatureModule {
+    return new FeatureModule((bind, unbind, isBound, rebind) =>
+        configureDiagramOptions({ bind, unbind, isBound, rebind }, diagramOptions, viewerOptions)
+    );
 }
 
 /**

package/src/features/accessibility/accessibility-module.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2023 Business Informatics Group (TU Wien) and others.
+ * Copyright (c) 2023-2024 Business Informatics Group (TU Wien) 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
@@ -15,30 +15,35 @@
  ********************************************************************************/
 
 import { FeatureModule } from '@eclipse-glsp/sprotty';
-import { configureShortcutHelpTool } from './key-shortcut/di.config';
+import { configureElementNavigationTool } from './element-navigation/element-navigation-module';
+import { configureFocusTrackerTool } from './focus-tracker/focus-tracker-module';
+import { configureShortcutHelpTool } from './key-shortcut/shortcut-help-module';
+import { configureKeyboardControlTools } from './keyboard-pointer/keyboard-pointer-module';
+import { configureKeyboardToolPaletteTool } from './keyboard-tool-palette/keyboard-tool-palette-module';
 import { configureMoveZoom } from './move-zoom/move-zoom-module';
 import { configureResizeTools } from './resize-key-tool/resize-key-module';
 import { configureSearchPaletteModule } from './search/search-palette-module';
-import { configureViewKeyTools } from './view-key-tools/view-key-tools-module';
-import { configureKeyboardToolPaletteTool } from './keyboard-tool-palette/keyboard-tool-palette-module';
-import { configureKeyboardControlTools } from './keyboard-pointer/keyboard-pointer-module';
-import { configureElementNavigationTool } from './element-navigation/element-navigation-module';
-import { configureFocusTrackerTool } from './focus-tracker/focus-tracker-module';
 import { configureToastTool } from './toast/toast-module';
+import { configureViewKeyTools } from './view-key-tools/view-key-tools-module';
 
 /**
  * Enables the accessibility tools for a keyboard-only-usage
  */
-export const accessibilityModule = new FeatureModule((bind, unbind, isBound, rebind) => {
-    const context = { bind, unbind, isBound, rebind };
-    configureResizeTools(context);
-    configureViewKeyTools(context);
-    configureMoveZoom(context);
-    configureSearchPaletteModule(context);
-    configureShortcutHelpTool(context);
-    configureKeyboardToolPaletteTool(context);
-    configureKeyboardControlTools(context);
-    configureElementNavigationTool(context);
-    configureFocusTrackerTool(context);
-    configureToastTool(context);
-});
+export const accessibilityModule = new FeatureModule(
+    (bind, unbind, isBound, rebind) => {
+        const context = { bind, unbind, isBound, rebind };
+        configureResizeTools(context);
+        configureViewKeyTools(context);
+        configureMoveZoom(context);
+        configureSearchPaletteModule(context);
+        configureShortcutHelpTool(context);
+        configureKeyboardToolPaletteTool(context);
+        configureKeyboardControlTools(context);
+        configureElementNavigationTool(context);
+        configureFocusTrackerTool(context);
+        configureToastTool(context);
+    },
+    {
+        featureId: Symbol('accessibility')
+    }
+);

package/src/features/accessibility/element-navigation/element-navigation-module.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2023 Business Informatics Group (TU Wien) and others.
+ * Copyright (c) 2023-2024 Business Informatics Group (TU Wien) 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
@@ -13,24 +13,31 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { ContainerModule } from 'inversify';
-import { BindingContext, TYPES, bindAsService } from '@eclipse-glsp/sprotty';
-import { PositionNavigator } from './position-navigator';
-import { LocalElementNavigator } from './local-element-navigator';
-import { ElementNavigatorTool } from './diagram-navigation-tool';
+import { BindingContext, FeatureModule, TYPES, bindAsService } from '@eclipse-glsp/sprotty';
 import '../../../../css/navigation.css';
+import { ElementNavigatorTool } from './diagram-navigation-tool';
+import { LocalElementNavigator } from './local-element-navigator';
+import { PositionNavigator } from './position-navigator';
 
 /**
  * Handles element navigation actions.
  */
 
-export const glspElementNavigationModule = new ContainerModule((bind, unbind, isBound, rebind) => {
-    const context = { bind, unbind, isBound, rebind };
-    configureElementNavigationTool(context);
-});
+export const elementNavigationModule = new FeatureModule(
+    (bind, unbind, isBound, rebind) => {
+        const context = { bind, unbind, isBound, rebind };
+        configureElementNavigationTool(context);
+    },
+    { featureId: Symbol('elementNavigation') }
+);
 
 export function configureElementNavigationTool(context: BindingContext): void {
     bindAsService(context, TYPES.IDefaultTool, ElementNavigatorTool);
     bindAsService(context, TYPES.IElementNavigator, PositionNavigator);
     bindAsService(context, TYPES.ILocalElementNavigator, LocalElementNavigator);
 }
+
+export {
+    /** Deprecated use {@link elementNavigationModule} instead */
+    elementNavigationModule as glspElementNavigationModule
+};