@eclipse-glsp/client 2.2.0-next.343 → 2.2.0-next.344

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

@@ -20,15 +20,18 @@ import { GridManager } from './grid-manager';
 import { ShowGridAction, ShowGridCommand } from './grid-model';
 import { GridSnapper } from './grid-snapper';
 
-export const gridModule = new FeatureModule((bind, unbind, isBound, rebind) => {
-    const context = { bind, unbind, isBound, rebind };
+export const gridModule = new FeatureModule(
+    (bind, unbind, isBound, rebind) => {
+        const context = { bind, unbind, isBound, rebind };
 
-    bind(TYPES.Grid).toConstantValue({ x: 10, y: 10 });
+        bind(TYPES.Grid).toConstantValue({ x: 10, y: 10 });
 
-    configureCommand(context, ShowGridCommand);
+        configureCommand(context, ShowGridCommand);
 
-    bind(GridManager).toSelf().inSingletonScope();
-    configureActionHandler(context, ShowGridAction.KIND, GridManager);
+        bind(GridManager).toSelf().inSingletonScope();
+        configureActionHandler(context, ShowGridAction.KIND, GridManager);
 
-    bind(TYPES.ISnapper).to(GridSnapper);
-});
+        bind(TYPES.ISnapper).to(GridSnapper);
+    },
+    { featureId: Symbol('grid') }
+);

package/src/features/helper-lines/helper-line-module.ts

@@ -31,17 +31,20 @@ import { HelperLineManager } from './helper-line-manager-default';
 import { HELPER_LINE, HelperLine, SELECTION_BOUNDS, SelectionBounds } from './model';
 import { HelperLineView, SelectionBoundsView } from './view';
 
-export const helperLineModule = new FeatureModule((bind, unbind, isBound, rebind) => {
-    const context = { bind, unbind, isBound, rebind };
-    configureModelElement(context, HELPER_LINE, HelperLine, HelperLineView);
-    configureModelElement(context, SELECTION_BOUNDS, SelectionBounds, SelectionBoundsView);
-    configureCommand(context, DrawHelperLinesFeedbackCommand);
-    configureCommand(context, RemoveHelperLinesFeedbackCommand);
+export const helperLineModule = new FeatureModule(
+    (bind, unbind, isBound, rebind) => {
+        const context = { bind, unbind, isBound, rebind };
+        configureModelElement(context, HELPER_LINE, HelperLine, HelperLineView);
+        configureModelElement(context, SELECTION_BOUNDS, SelectionBounds, SelectionBoundsView);
+        configureCommand(context, DrawHelperLinesFeedbackCommand);
+        configureCommand(context, RemoveHelperLinesFeedbackCommand);
 
-    bindAsService(bind, TYPES.IHelperLineManager, HelperLineManager);
-    configureActionHandler(context, SetBoundsAction.KIND, TYPES.IHelperLineManager);
-    configureActionHandler(context, SetBoundsFeedbackAction.KIND, TYPES.IHelperLineManager);
-    configureActionHandler(context, MoveAction.KIND, TYPES.IHelperLineManager);
-    configureActionHandler(context, MoveInitializedEventAction.KIND, TYPES.IHelperLineManager);
-    configureActionHandler(context, MoveFinishedEventAction.KIND, TYPES.IHelperLineManager);
-});
+        bindAsService(bind, TYPES.IHelperLineManager, HelperLineManager);
+        configureActionHandler(context, SetBoundsAction.KIND, TYPES.IHelperLineManager);
+        configureActionHandler(context, SetBoundsFeedbackAction.KIND, TYPES.IHelperLineManager);
+        configureActionHandler(context, MoveAction.KIND, TYPES.IHelperLineManager);
+        configureActionHandler(context, MoveInitializedEventAction.KIND, TYPES.IHelperLineManager);
+        configureActionHandler(context, MoveFinishedEventAction.KIND, TYPES.IHelperLineManager);
+    },
+    { featureId: Symbol('helperLine') }
+);

package/src/features/hints/type-hints-module.ts

@@ -16,10 +16,13 @@
 import { FeatureModule, SetTypeHintsAction, TYPES, bindAsService, configureActionHandler, configureCommand } from '@eclipse-glsp/sprotty';
 import { ApplyTypeHintsCommand, TypeHintProvider } from './type-hint-provider';
 
-export const typeHintsModule = new FeatureModule((bind, unbind, isBound) => {
-    const context = { bind, unbind, isBound };
-    bindAsService(context, TYPES.ITypeHintProvider, TypeHintProvider);
-    bind(TYPES.IDiagramStartup).toService(TypeHintProvider);
-    configureActionHandler(context, SetTypeHintsAction.KIND, TypeHintProvider);
-    configureCommand(context, ApplyTypeHintsCommand);
-});
+export const typeHintsModule = new FeatureModule(
+    (bind, unbind, isBound) => {
+        const context = { bind, unbind, isBound };
+        bindAsService(context, TYPES.ITypeHintProvider, TypeHintProvider);
+        bind(TYPES.IDiagramStartup).toService(TypeHintProvider);
+        configureActionHandler(context, SetTypeHintsAction.KIND, TypeHintProvider);
+        configureCommand(context, ApplyTypeHintsCommand);
+    },
+    { featureId: Symbol('typeHints') }
+);

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

@@ -35,30 +35,33 @@ import { FocusStateChangedAction } from '../../base/focus/focus-state-change-act
 import { EnableDefaultToolsAction, EnableToolsAction } from '../../base/tool-manager/tool';
 import { GlspHoverMouseListener } from './hover';
 
-export const hoverModule = new FeatureModule((bind, _unbind, isBound) => {
-    const context = { bind, isBound };
-    bindAsService(context, TYPES.PopupVNodePostprocessor, PopupPositionUpdater);
-    bindAsService(context, TYPES.MouseListener, GlspHoverMouseListener);
-    bindAsService(context, TYPES.PopupMouseListener, PopupHoverMouseListener);
-    bindAsService(context, TYPES.KeyListener, HoverKeyListener);
+export const hoverModule = new FeatureModule(
+    (bind, _unbind, isBound) => {
+        const context = { bind, isBound };
+        bindAsService(context, TYPES.PopupVNodePostprocessor, PopupPositionUpdater);
+        bindAsService(context, TYPES.MouseListener, GlspHoverMouseListener);
+        bindAsService(context, TYPES.PopupMouseListener, PopupHoverMouseListener);
+        bindAsService(context, TYPES.KeyListener, HoverKeyListener);
 
-    bind<HoverState>(TYPES.HoverState).toConstantValue({
-        mouseOverTimer: undefined,
-        mouseOutTimer: undefined,
-        popupOpen: false,
-        previousPopupElement: undefined
-    });
-    bind(ClosePopupActionHandler).toSelf().inSingletonScope();
+        bind<HoverState>(TYPES.HoverState).toConstantValue({
+            mouseOverTimer: undefined,
+            mouseOutTimer: undefined,
+            popupOpen: false,
+            previousPopupElement: undefined
+        });
+        bind(ClosePopupActionHandler).toSelf().inSingletonScope();
 
-    configureCommand(context, HoverFeedbackCommand);
-    configureCommand(context, SetPopupModelCommand);
-    configureActionHandler(context, SetPopupModelCommand.KIND, ClosePopupActionHandler);
-    configureActionHandler(context, FitToScreenCommand.KIND, ClosePopupActionHandler);
-    configureActionHandler(context, CenterCommand.KIND, ClosePopupActionHandler);
-    configureActionHandler(context, SetViewportCommand.KIND, ClosePopupActionHandler);
-    configureActionHandler(context, MoveCommand.KIND, ClosePopupActionHandler);
-    configureActionHandler(context, FocusStateChangedAction.KIND, ClosePopupActionHandler);
-    configureActionHandler(context, EnableToolsAction.KIND, GlspHoverMouseListener);
-    configureActionHandler(context, EnableDefaultToolsAction.KIND, GlspHoverMouseListener);
-    configureActionHandler(context, FocusStateChangedAction.KIND, GlspHoverMouseListener);
-});
+        configureCommand(context, HoverFeedbackCommand);
+        configureCommand(context, SetPopupModelCommand);
+        configureActionHandler(context, SetPopupModelCommand.KIND, ClosePopupActionHandler);
+        configureActionHandler(context, FitToScreenCommand.KIND, ClosePopupActionHandler);
+        configureActionHandler(context, CenterCommand.KIND, ClosePopupActionHandler);
+        configureActionHandler(context, SetViewportCommand.KIND, ClosePopupActionHandler);
+        configureActionHandler(context, MoveCommand.KIND, ClosePopupActionHandler);
+        configureActionHandler(context, FocusStateChangedAction.KIND, ClosePopupActionHandler);
+        configureActionHandler(context, EnableToolsAction.KIND, GlspHoverMouseListener);
+        configureActionHandler(context, EnableDefaultToolsAction.KIND, GlspHoverMouseListener);
+        configureActionHandler(context, FocusStateChangedAction.KIND, GlspHoverMouseListener);
+    },
+    { featureId: Symbol('hover') }
+);

package/src/features/label-edit/label-edit-module.ts

@@ -17,9 +17,12 @@ import { ApplyLabelEditCommand, FeatureModule, TYPES, bindAsService, configureCo
 import { DirectLabelEditTool } from './edit-label-tool';
 import { BalloonLabelValidationDecorator, ServerEditLabelValidator } from './edit-label-validator';
 
-export const labelEditModule = new FeatureModule((bind, _unbind, isBound, _rebind) => {
-    bind(TYPES.IEditLabelValidator).to(ServerEditLabelValidator);
-    bind(TYPES.IEditLabelValidationDecorator).to(BalloonLabelValidationDecorator);
-    bindAsService(bind, TYPES.IDefaultTool, DirectLabelEditTool);
-    configureCommand({ bind, isBound }, ApplyLabelEditCommand);
-});
+export const labelEditModule = new FeatureModule(
+    (bind, _unbind, isBound, _rebind) => {
+        bind(TYPES.IEditLabelValidator).to(ServerEditLabelValidator);
+        bind(TYPES.IEditLabelValidationDecorator).to(BalloonLabelValidationDecorator);
+        bindAsService(bind, TYPES.IDefaultTool, DirectLabelEditTool);
+        configureCommand({ bind, isBound }, ApplyLabelEditCommand);
+    },
+    { featureId: Symbol('labelEdit') }
+);

package/src/features/label-edit-ui/label-edit-ui-module.ts

@@ -16,9 +16,12 @@
 import { EditLabelAction, EditLabelActionHandler, FeatureModule, TYPES, configureActionHandler } from '@eclipse-glsp/sprotty';
 import { GlspEditLabelUI } from './label-edit-ui';
 
-export const labelEditUiModule = new FeatureModule((bind, unbind, isBound, rebind, ...rest) => {
-    const context = { bind, unbind, isBound, rebind };
-    configureActionHandler(context, EditLabelAction.KIND, EditLabelActionHandler);
-    bind(GlspEditLabelUI).toSelf().inSingletonScope();
-    bind(TYPES.IUIExtension).toService(GlspEditLabelUI);
-});
+export const labelEditUiModule = new FeatureModule(
+    (bind, unbind, isBound, rebind, ...rest) => {
+        const context = { bind, unbind, isBound, rebind };
+        configureActionHandler(context, EditLabelAction.KIND, EditLabelActionHandler);
+        bind(GlspEditLabelUI).toSelf().inSingletonScope();
+        bind(TYPES.IUIExtension).toService(GlspEditLabelUI);
+    },
+    { featureId: Symbol('labelEditUi') }
+);

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

@@ -21,8 +21,11 @@ import {
     ResizeElementsActionHandler
 } from './layout-elements-action';
 
-export const layoutModule = new FeatureModule((bind, _unbind, isBound) => {
-    const context = { bind, isBound };
-    configureActionHandler(context, ResizeElementsAction.KIND, ResizeElementsActionHandler);
-    configureActionHandler(context, AlignElementsAction.KIND, AlignElementsActionHandler);
-});
+export const layoutModule = new FeatureModule(
+    (bind, _unbind, isBound) => {
+        const context = { bind, isBound };
+        configureActionHandler(context, ResizeElementsAction.KIND, ResizeElementsActionHandler);
+        configureActionHandler(context, AlignElementsAction.KIND, AlignElementsActionHandler);
+    },
+    { featureId: Symbol('layout') }
+);

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

@@ -17,11 +17,14 @@ import { FeatureModule, NavigateToExternalTargetAction, NavigateToTargetAction,
 import { NavigateAction, NavigationActionHandler, ProcessNavigationArgumentsAction } from './navigation-action-handler';
 import { NavigationTargetResolver } from './navigation-target-resolver';
 
-export const navigationModule = new FeatureModule((bind, _unbind, isBound) => {
-    bind(NavigationTargetResolver).toSelf().inSingletonScope();
-    bind(NavigationActionHandler).toSelf().inSingletonScope();
-    configureActionHandler({ bind, isBound }, NavigateAction.KIND, NavigationActionHandler);
-    configureActionHandler({ bind, isBound }, NavigateToTargetAction.KIND, NavigationActionHandler);
-    configureActionHandler({ bind, isBound }, ProcessNavigationArgumentsAction.KIND, NavigationActionHandler);
-    configureActionHandler({ bind, isBound }, NavigateToExternalTargetAction.KIND, NavigationActionHandler);
-});
+export const navigationModule = new FeatureModule(
+    (bind, _unbind, isBound) => {
+        bind(NavigationTargetResolver).toSelf().inSingletonScope();
+        bind(NavigationActionHandler).toSelf().inSingletonScope();
+        configureActionHandler({ bind, isBound }, NavigateAction.KIND, NavigationActionHandler);
+        configureActionHandler({ bind, isBound }, NavigateToTargetAction.KIND, NavigationActionHandler);
+        configureActionHandler({ bind, isBound }, ProcessNavigationArgumentsAction.KIND, NavigationActionHandler);
+        configureActionHandler({ bind, isBound }, NavigateToExternalTargetAction.KIND, NavigationActionHandler);
+    },
+    { featureId: Symbol('navigation') }
+);

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

@@ -33,25 +33,28 @@ import {
 } from '@eclipse-glsp/sprotty';
 import { GLSPBezierEdgeRouter, GLSPManhattanEdgeRouter, GLSPPolylineEdgeRouter } from './edge-router';
 
-export const routingModule = new FeatureModule((bind, unbind, isBound, rebind) => {
-    const context = { bind, unbind, isBound, rebind };
-    bind(EdgeRouterRegistry).toSelf().inSingletonScope();
-    bind(AnchorComputerRegistry).toSelf().inSingletonScope();
+export const routingModule = new FeatureModule(
+    (bind, unbind, isBound, rebind) => {
+        const context = { bind, unbind, isBound, rebind };
+        bind(EdgeRouterRegistry).toSelf().inSingletonScope();
+        bind(AnchorComputerRegistry).toSelf().inSingletonScope();
 
-    bindAsService(context, TYPES.IEdgeRouter, GLSPManhattanEdgeRouter);
-    bindAsService(context, TYPES.IAnchorComputer, ManhattanEllipticAnchor);
-    bindAsService(context, TYPES.IAnchorComputer, ManhattanRectangularAnchor);
-    bindAsService(context, TYPES.IAnchorComputer, ManhattanDiamondAnchor);
+        bindAsService(context, TYPES.IEdgeRouter, GLSPManhattanEdgeRouter);
+        bindAsService(context, TYPES.IAnchorComputer, ManhattanEllipticAnchor);
+        bindAsService(context, TYPES.IAnchorComputer, ManhattanRectangularAnchor);
+        bindAsService(context, TYPES.IAnchorComputer, ManhattanDiamondAnchor);
 
-    bindAsService(context, TYPES.IEdgeRouter, GLSPPolylineEdgeRouter);
-    bindAsService(context, TYPES.IAnchorComputer, EllipseAnchor);
-    bindAsService(context, TYPES.IAnchorComputer, RectangleAnchor);
-    bindAsService(context, TYPES.IAnchorComputer, DiamondAnchor);
+        bindAsService(context, TYPES.IEdgeRouter, GLSPPolylineEdgeRouter);
+        bindAsService(context, TYPES.IAnchorComputer, EllipseAnchor);
+        bindAsService(context, TYPES.IAnchorComputer, RectangleAnchor);
+        bindAsService(context, TYPES.IAnchorComputer, DiamondAnchor);
 
-    bindAsService(context, TYPES.IEdgeRouter, GLSPBezierEdgeRouter);
-    bindAsService(context, TYPES.IAnchorComputer, BezierEllipseAnchor);
-    bindAsService(context, TYPES.IAnchorComputer, BezierRectangleAnchor);
-    bindAsService(context, TYPES.IAnchorComputer, BezierDiamondAnchor);
+        bindAsService(context, TYPES.IEdgeRouter, GLSPBezierEdgeRouter);
+        bindAsService(context, TYPES.IAnchorComputer, BezierEllipseAnchor);
+        bindAsService(context, TYPES.IAnchorComputer, BezierRectangleAnchor);
+        bindAsService(context, TYPES.IAnchorComputer, BezierDiamondAnchor);
 
-    configureCommand({ bind, isBound }, AddRemoveBezierSegmentCommand);
-});
+        configureCommand({ bind, isBound }, AddRemoveBezierSegmentCommand);
+    },
+    { featureId: Symbol('routing') }
+);

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

@@ -21,6 +21,9 @@ import { SaveModelKeyboardListener } from './save-keylistener';
  * When integrated into an application frame (e.g Theia/VS Code) this module is typically omitted and/or replaced
  * with an application native module.
  */
-export const saveModule = new FeatureModule(bind => {
-    bindAsService(bind, TYPES.KeyListener, SaveModelKeyboardListener);
-});
+export const saveModule = new FeatureModule(
+    bind => {
+        bindAsService(bind, TYPES.KeyListener, SaveModelKeyboardListener);
+    },
+    { featureId: Symbol('save') }
+);

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

@@ -18,13 +18,16 @@ import { SelectAllCommand, SelectCommand } from '../../base/selection-service';
 import { SelectFeedbackCommand } from './select-feedback-command';
 import { RankedSelectMouseListener } from './select-mouse-listener';
 
-export const selectModule = new FeatureModule((bind, _unbind, isBound) => {
-    const context = { bind, isBound };
-    configureCommand(context, SelectCommand);
-    configureCommand(context, SelectAllCommand);
-    configureCommand(context, SelectFeedbackCommand);
-    bindAsService(context, TYPES.MouseListener, RankedSelectMouseListener);
-});
+export const selectModule = new FeatureModule(
+    (bind, _unbind, isBound) => {
+        const context = { bind, isBound };
+        configureCommand(context, SelectCommand);
+        configureCommand(context, SelectAllCommand);
+        configureCommand(context, SelectFeedbackCommand);
+        bindAsService(context, TYPES.MouseListener, RankedSelectMouseListener);
+    },
+    { featureId: Symbol('select') }
+);
 
 /**
  * Feature module that is intended for the standalone deployment of GLSP (i.e. plain webapp)
@@ -35,5 +38,5 @@ export const standaloneSelectModule = new FeatureModule(
     bind => {
         bindAsService(bind, TYPES.KeyListener, SelectKeyboardListener);
     },
-    { requires: selectModule }
+    { featureId: Symbol('standaloneSelect'), requires: selectModule }
 );

package/src/features/source-model-watcher/source-model-watcher-module.ts

@@ -16,6 +16,9 @@
 import { FeatureModule, SourceModelChangedAction, configureActionHandler } from '@eclipse-glsp/sprotty';
 import { SourceModelChangedActionHandler } from './source-model-changed-action-handler';
 
-export const sourceModelWatcherModule = new FeatureModule((bind, _unbind, isBound) => {
-    configureActionHandler({ bind, isBound }, SourceModelChangedAction.KIND, SourceModelChangedActionHandler);
-});
+export const sourceModelWatcherModule = new FeatureModule(
+    (bind, _unbind, isBound) => {
+        configureActionHandler({ bind, isBound }, SourceModelChangedAction.KIND, SourceModelChangedActionHandler);
+    },
+    { featureId: Symbol('sourceModelWatcher') }
+);

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

@@ -18,9 +18,12 @@ import { FeatureModule, StatusAction, TYPES, bindAsService, configureActionHandl
 import '../../../css/status-overlay.css';
 import { StatusOverlay } from './status-overlay';
 
-export const statusModule = new FeatureModule((bind, unbind, isBound, rebind) => {
-    const context = { bind, unbind, isBound, rebind };
-    bindAsService(context, TYPES.IUIExtension, StatusOverlay);
-    bind(TYPES.IDiagramStartup).toService(StatusOverlay);
-    configureActionHandler(context, StatusAction.KIND, StatusOverlay);
-});
+export const statusModule = new FeatureModule(
+    (bind, unbind, isBound, rebind) => {
+        const context = { bind, unbind, isBound, rebind };
+        bindAsService(context, TYPES.IUIExtension, StatusOverlay);
+        bind(TYPES.IDiagramStartup).toService(StatusOverlay);
+        configureActionHandler(context, StatusAction.KIND, StatusOverlay);
+    },
+    { featureId: Symbol('status') }
+);

package/src/features/svg-metadata/svg-metadata-module.ts

@@ -17,7 +17,10 @@
 import { FeatureModule, TYPES } from '@eclipse-glsp/sprotty';
 import { MetadataPlacer } from './metadata-placer';
 
-export const svgMetadataModule = new FeatureModule(bind => {
-    bind(MetadataPlacer).toSelf().inSingletonScope();
-    bind(TYPES.IVNodePostprocessor).toService(MetadataPlacer);
-});
+export const svgMetadataModule = new FeatureModule(
+    bind => {
+        bind(MetadataPlacer).toSelf().inSingletonScope();
+        bind(TYPES.IVNodePostprocessor).toService(MetadataPlacer);
+    },
+    { featureId: Symbol('svgMetadata') }
+);

package/src/features/tool-palette/tool-palette-module.ts

@@ -18,10 +18,13 @@ import '../../../css/tool-palette.css';
 import { EnableDefaultToolsAction } from '../../base/tool-manager/tool';
 import { ToolPalette } from './tool-palette';
 
-export const toolPaletteModule = new FeatureModule((bind, _unbind, isBound, _rebind) => {
-    bindAsService(bind, TYPES.IUIExtension, ToolPalette);
-    bind(TYPES.IDiagramStartup).toService(ToolPalette);
-    configureActionHandler({ bind, isBound }, EnableDefaultToolsAction.KIND, ToolPalette);
-    configureActionHandler({ bind, isBound }, UpdateModelAction.KIND, ToolPalette);
-    configureActionHandler({ bind, isBound }, SetModelAction.KIND, ToolPalette);
-});
+export const toolPaletteModule = new FeatureModule(
+    (bind, _unbind, isBound, _rebind) => {
+        bindAsService(bind, TYPES.IUIExtension, ToolPalette);
+        bind(TYPES.IDiagramStartup).toService(ToolPalette);
+        configureActionHandler({ bind, isBound }, EnableDefaultToolsAction.KIND, ToolPalette);
+        configureActionHandler({ bind, isBound }, UpdateModelAction.KIND, ToolPalette);
+        configureActionHandler({ bind, isBound }, SetModelAction.KIND, ToolPalette);
+    },
+    { featureId: Symbol('toolPalette') }
+);

package/src/features/tools/change-bounds/change-bounds-tool-module.ts

@@ -21,11 +21,14 @@ import { ChangeBoundsTool } from './change-bounds-tool';
 import { HideChangeBoundsToolResizeFeedbackCommand, ShowChangeBoundsToolResizeFeedbackCommand } from './change-bounds-tool-feedback';
 import { SResizeHandleView } from './view';
 
-export const changeBoundsToolModule = new FeatureModule((bind, unbind, isBound, rebind) => {
-    const context = { bind, unbind, isBound, rebind };
-    bind(ChangeBoundsManager).toSelf().inSingletonScope();
-    bindAsService(context, TYPES.IDefaultTool, ChangeBoundsTool);
-    configureCommand(context, ShowChangeBoundsToolResizeFeedbackCommand);
-    configureCommand(context, HideChangeBoundsToolResizeFeedbackCommand);
-    configureView(context, SResizeHandle.TYPE, SResizeHandleView);
-});
+export const changeBoundsToolModule = new FeatureModule(
+    (bind, unbind, isBound, rebind) => {
+        const context = { bind, unbind, isBound, rebind };
+        bind(ChangeBoundsManager).toSelf().inSingletonScope();
+        bindAsService(context, TYPES.IDefaultTool, ChangeBoundsTool);
+        configureCommand(context, ShowChangeBoundsToolResizeFeedbackCommand);
+        configureCommand(context, HideChangeBoundsToolResizeFeedbackCommand);
+        configureView(context, SResizeHandle.TYPE, SResizeHandleView);
+    },
+    { featureId: Symbol('changeBoundsTool') }
+);

package/src/features/tools/deletion/deletion-tool-module.ts

@@ -16,8 +16,11 @@
 import { FeatureModule, TYPES, bindAsService } from '@eclipse-glsp/sprotty';
 import { DelKeyDeleteTool, MouseDeleteTool } from './delete-tool';
 
-export const deletionToolModule = new FeatureModule((bind, unbind, isBound, rebind) => {
-    const context = { bind, unbind, isBound, rebind };
-    bindAsService(context, TYPES.IDefaultTool, DelKeyDeleteTool);
-    bindAsService(context, TYPES.ITool, MouseDeleteTool);
-});
+export const deletionToolModule = new FeatureModule(
+    (bind, unbind, isBound, rebind) => {
+        const context = { bind, unbind, isBound, rebind };
+        bindAsService(context, TYPES.IDefaultTool, DelKeyDeleteTool);
+        bindAsService(context, TYPES.ITool, MouseDeleteTool);
+    },
+    { featureId: Symbol('deletionTool') }
+);

package/src/features/tools/edge-creation/edege-creation-module.ts

@@ -17,9 +17,12 @@ import { FeatureModule, TYPES, TriggerEdgeCreationAction, bindAsService, configu
 import { configureDanglingFeedbackEdge } from './dangling-edge-feedback';
 import { EdgeCreationTool } from './edge-creation-tool';
 
-export const edgeCreationToolModule = new FeatureModule((bind, unbind, isBound, rebind) => {
-    const context = { bind, unbind, isBound, rebind };
-    bindAsService(context, TYPES.ITool, EdgeCreationTool);
-    configureActionHandler(context, TriggerEdgeCreationAction.KIND, EdgeCreationTool);
-    configureDanglingFeedbackEdge(context);
-});
+export const edgeCreationToolModule = new FeatureModule(
+    (bind, unbind, isBound, rebind) => {
+        const context = { bind, unbind, isBound, rebind };
+        bindAsService(context, TYPES.ITool, EdgeCreationTool);
+        configureActionHandler(context, TriggerEdgeCreationAction.KIND, EdgeCreationTool);
+        configureDanglingFeedbackEdge(context);
+    },
+    { featureId: Symbol('edgeCreationTool') }
+);

package/src/features/tools/edge-edit/edge-edit-module.ts

@@ -23,16 +23,19 @@ import {
     SwitchRoutingModeCommand
 } from './edge-edit-tool-feedback';
 
-export const edgeEditToolModule = new FeatureModule((bind, unbind, isBound, rebind) => {
-    const context = { bind, unbind, isBound, rebind };
-    bindAsService(context, TYPES.IDefaultTool, EdgeEditTool);
+export const edgeEditToolModule = new FeatureModule(
+    (bind, unbind, isBound, rebind) => {
+        const context = { bind, unbind, isBound, rebind };
+        bindAsService(context, TYPES.IDefaultTool, EdgeEditTool);
 
-    // reconnect edge tool feedback
-    configureCommand(context, ShowEdgeReconnectHandlesFeedbackCommand);
-    configureCommand(context, HideEdgeReconnectHandlesFeedbackCommand);
-    configureCommand(context, DrawFeedbackEdgeSourceCommand);
-    configureCommand(context, SwitchRoutingModeCommand);
+        // reconnect edge tool feedback
+        configureCommand(context, ShowEdgeReconnectHandlesFeedbackCommand);
+        configureCommand(context, HideEdgeReconnectHandlesFeedbackCommand);
+        configureCommand(context, DrawFeedbackEdgeSourceCommand);
+        configureCommand(context, SwitchRoutingModeCommand);
 
-    // dangling edge feedback
-    configureDanglingFeedbackEdge(context);
-});
+        // dangling edge feedback
+        configureDanglingFeedbackEdge(context);
+    },
+    { featureId: Symbol('edgeEditTool') }
+);

package/src/features/tools/marquee-selection/marquee-selection-module.ts

@@ -20,13 +20,16 @@ import { DrawMarqueeCommand, MARQUEE, RemoveMarqueeCommand } from './marquee-too
 import { MarqueeNode } from './model';
 import { MarqueeView } from './view';
 
-export const marqueeSelectionToolModule = new FeatureModule((bind, unbind, isBound, rebind) => {
-    const context = { bind, unbind, isBound, rebind };
-    bindAsService(context, TYPES.IDefaultTool, MarqueeTool);
-    bindAsService(context, TYPES.ITool, MarqueeMouseTool);
+export const marqueeSelectionToolModule = new FeatureModule(
+    (bind, unbind, isBound, rebind) => {
+        const context = { bind, unbind, isBound, rebind };
+        bindAsService(context, TYPES.IDefaultTool, MarqueeTool);
+        bindAsService(context, TYPES.ITool, MarqueeMouseTool);
 
-    configureCommand(context, DrawMarqueeCommand);
-    configureCommand(context, RemoveMarqueeCommand);
+        configureCommand(context, DrawMarqueeCommand);
+        configureCommand(context, RemoveMarqueeCommand);
 
-    configureModelElement(context, MARQUEE, MarqueeNode, MarqueeView);
-});
+        configureModelElement(context, MARQUEE, MarqueeNode, MarqueeView);
+    },
+    { featureId: Symbol('marqueeSelectionTool') }
+);

package/src/features/tools/node-creation/node-creation-module.ts

@@ -35,5 +35,8 @@ export const nodeCreationToolModule = new FeatureModule(
         configureActionHandler(context, TriggerNodeCreationAction.KIND, NodeCreationTool);
         configureModelElement(context, InsertIndicator.TYPE, InsertIndicator, InsertIndicatorView);
     },
-    { requires: elementTemplateModule }
+    {
+        featureId: Symbol('nodeCreationTool'),
+        requires: elementTemplateModule
+    }
 );

package/src/features/tools/tool-focus-loss-module.ts

@@ -13,8 +13,8 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { injectable } from 'inversify';
 import { Action, FeatureModule, IActionHandler, ICommand, configureActionHandler } from '@eclipse-glsp/sprotty';
+import { injectable } from 'inversify';
 import { FocusStateChangedAction } from '../../base/focus/focus-state-change-action';
 import { EnableDefaultToolsAction } from '../../base/tool-manager/tool';
 
@@ -34,6 +34,9 @@ export class EnableDefaultToolsOnFocusLossHandler implements IActionHandler {
 /**
  * Enables the default tools in the tool manager if the diagram looses focus.
  */
-export const toolFocusLossModule = new FeatureModule((bind, _unbind, isBound) => {
-    configureActionHandler({ bind, isBound }, FocusStateChangedAction.KIND, EnableDefaultToolsOnFocusLossHandler);
-});
+export const toolFocusLossModule = new FeatureModule(
+    (bind, _unbind, isBound) => {
+        configureActionHandler({ bind, isBound }, FocusStateChangedAction.KIND, EnableDefaultToolsOnFocusLossHandler);
+    },
+    { featureId: Symbol('toolFocusLoss ') }
+);

package/src/features/validation/validation-modules.ts

@@ -25,19 +25,25 @@ import {
 } from './marker-navigator';
 import { ApplyMarkersCommand, DeleteMarkersCommand, SetMarkersActionHandler, ValidationFeedbackEmitter } from './validate';
 
-export const validationModule = new FeatureModule((bind, _unbind, isBound) => {
-    const context = { bind, isBound };
-    configureActionHandler(context, SetMarkersAction.KIND, SetMarkersActionHandler);
-    configureCommand(context, ApplyMarkersCommand);
-    configureCommand(context, DeleteMarkersCommand);
-    bind(ValidationFeedbackEmitter).toSelf().inSingletonScope();
-});
+export const validationModule = new FeatureModule(
+    (bind, _unbind, isBound) => {
+        const context = { bind, isBound };
+        configureActionHandler(context, SetMarkersAction.KIND, SetMarkersActionHandler);
+        configureCommand(context, ApplyMarkersCommand);
+        configureCommand(context, DeleteMarkersCommand);
+        bind(ValidationFeedbackEmitter).toSelf().inSingletonScope();
+    },
+    { featureId: Symbol('validation') }
+);
 
-export const markerNavigatorModule = new FeatureModule((bind, _unbind, isBound) => {
-    bind(GModelElementComparator).to(LeftToRightTopToBottomComparator).inSingletonScope();
-    bind(MarkerNavigator).toSelf().inSingletonScope();
-    configureActionHandler({ bind, isBound }, NavigateToMarkerAction.KIND, NavigateToMarkerActionHandler);
-});
+export const markerNavigatorModule = new FeatureModule(
+    (bind, _unbind, isBound) => {
+        bind(GModelElementComparator).to(LeftToRightTopToBottomComparator).inSingletonScope();
+        bind(MarkerNavigator).toSelf().inSingletonScope();
+        configureActionHandler({ bind, isBound }, NavigateToMarkerAction.KIND, NavigateToMarkerActionHandler);
+    },
+    { featureId: Symbol('markerNavigator') }
+);
 
 /**
  * Feature module that is intended for the standalone deployment of GLSP (i.e. plain webapp)
@@ -49,5 +55,5 @@ export const standaloneMarkerNavigatorModule = new FeatureModule(
         bindAsService(bind, TYPES.IContextMenuProvider, MarkerNavigatorContextMenuItemProvider);
         bindAsService(bind, TYPES.KeyListener, MarkerNavigatorKeyListener);
     },
-    { requires: markerNavigatorModule }
+    { featureId: Symbol('standaloneMarkerNavigator'), requires: markerNavigatorModule }
 );