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

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

@@ -17,6 +17,9 @@ import { FeatureModule, TYPES, bindAsService } from '@eclipse-glsp/sprotty';
 import '../../../css/decoration.css';
 import { GlspDecorationPlacer } from './decoration-placer';
 
-export const decorationModule = new FeatureModule(bind => {
-    bindAsService(bind, TYPES.IVNodePostprocessor, GlspDecorationPlacer);
-});
+export const decorationModule = new FeatureModule(
+    bind => {
+        bindAsService(bind, TYPES.IVNodePostprocessor, GlspDecorationPlacer);
+    },
+    { featureId: Symbol('decoration') }
+);

package/src/features/element-template/element-template-module.ts

@@ -17,8 +17,11 @@ import { FeatureModule, configureCommand } from '@eclipse-glsp/sprotty';
 import { AddTemplateElementsFeedbackCommand } from './add-template-element';
 import { RemoveTemplateElementsFeedbackCommand } from './remove-template-element';
 
-export const elementTemplateModule = new FeatureModule((bind, unbind, isBound, rebind) => {
-    const context = { bind, unbind, isBound, rebind };
-    configureCommand(context, AddTemplateElementsFeedbackCommand);
-    configureCommand(context, RemoveTemplateElementsFeedbackCommand);
-});
+export const elementTemplateModule = new FeatureModule(
+    (bind, unbind, isBound, rebind) => {
+        const context = { bind, unbind, isBound, rebind };
+        configureCommand(context, AddTemplateElementsFeedbackCommand);
+        configureCommand(context, RemoveTemplateElementsFeedbackCommand);
+    },
+    { featureId: Symbol('elementTemplate') }
+);

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

@@ -27,12 +27,15 @@ import {
 import { ExportSvgActionHandler } from './export-svg-action-handler';
 import { GLSPSvgExporter } from './glsp-svg-exporter';
 
-export const exportModule = new FeatureModule((bind, _unbind, isBound) => {
-    const context = { bind, isBound };
-    bindAsService(context, TYPES.HiddenVNodePostprocessor, ExportSvgPostprocessor);
-    configureCommand(context, ExportSvgCommand);
-    bind(TYPES.SvgExporter).to(GLSPSvgExporter).inSingletonScope();
-});
+export const exportModule = new FeatureModule(
+    (bind, _unbind, isBound) => {
+        const context = { bind, isBound };
+        bindAsService(context, TYPES.HiddenVNodePostprocessor, ExportSvgPostprocessor);
+        configureCommand(context, ExportSvgCommand);
+        bind(TYPES.SvgExporter).to(GLSPSvgExporter).inSingletonScope();
+    },
+    { featureId: Symbol('export') }
+);
 
 /**
  * Feature module that is intended for the standalone deployment of GLSP (i.e. plain webapp)
@@ -46,5 +49,5 @@ export const standaloneExportModule = new FeatureModule(
         bind(ExportSvgActionHandler).toSelf().inSingletonScope();
         configureActionHandler(context, ExportSvgAction.KIND, ExportSvgActionHandler);
     },
-    { requires: exportModule }
+    { featureId: Symbol('standaloneExport'), requires: exportModule }
 );

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-manager-default.ts

@@ -30,7 +30,7 @@ import { IFeedbackActionDispatcher } from '../../base/feedback/feedback-action-d
 import { FeedbackEmitter } from '../../base/feedback/feedback-emitter';
 import { ISelectionListener, SelectionService } from '../../base/selection-service';
 import { SetBoundsFeedbackAction } from '../bounds/set-bounds-feedback-command';
-import { ResizeHandleLocation, SResizeHandle } from '../change-bounds/model';
+import { GResizeHandle, ResizeHandleLocation } from '../change-bounds/model';
 import { Grid } from '../grid/grid';
 import { MoveFinishedEventAction, MoveInitializedEventAction } from '../tools/change-bounds/change-bounds-tool-feedback';
 import {
@@ -182,7 +182,7 @@ export class HelperLineManager implements IActionHandler, ISelectionListener, IH
 
         const minimum: Writable<Vector> = { ...Vector.ZERO };
         const resize =
-            element instanceof SResizeHandle
+            element instanceof GResizeHandle
                 ? ResizeHandleLocation.direction(element.location)
                 : [Direction.Left, Direction.Right, Direction.Up, Direction.Down];
 

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/select/select-mouse-listener.ts

@@ -17,7 +17,7 @@ import { Action, BringToFrontAction, GModelElement, SelectAction, SelectMouseLis
 import { inject, injectable, optional } from 'inversify';
 import { Ranked } from '../../base/ranked';
 import { SelectableElement } from '../../utils/gmodel-util';
-import { SResizeHandle } from '../change-bounds/model';
+import { GResizeHandle } from '../change-bounds/model';
 import { ChangeBoundsManager } from '../tools/change-bounds/change-bounds-manager';
 
 /**
@@ -60,7 +60,7 @@ export class RankedSelectMouseListener extends SelectMouseListener implements Ra
     }
 
     protected override handleButton(target: GModelElement, event: MouseEvent): (Action | Promise<Action>)[] | undefined {
-        if (target instanceof SResizeHandle && this.changeBoundsManager?.useSymmetricResize(event)) {
+        if (target instanceof GResizeHandle && this.changeBoundsManager?.useSymmetricResize(event)) {
             // avoid de-selecting elements when resizing with a modifier key
             return [];
         }

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-manager.ts

@@ -40,7 +40,7 @@ import {
 import { FeedbackEmitter } from '../../../base/feedback/feedback-emitter';
 import { isValidMove, minDimensions } from '../../../utils/layout-utils';
 import { LayoutAware } from '../../bounds/layout-data';
-import { ResizeHandleLocation, SResizeHandle } from '../../change-bounds/model';
+import { GResizeHandle, ResizeHandleLocation } from '../../change-bounds/model';
 import {
     IMovementRestrictor,
     movementRestrictionFeedback,
@@ -154,7 +154,7 @@ export class ChangeBoundsManager {
         );
 
         // cursor feedback on graph
-        const cursorClass = SResizeHandle.getCursorCss(resize.handleMove.element);
+        const cursorClass = GResizeHandle.getCursorCss(resize.handleMove.element);
         feedback.add(cursorFeedbackAction(cursorClass), cursorFeedbackAction(CursorCSS.DEFAULT));
 
         // handle feedback

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

@@ -15,17 +15,20 @@
  ********************************************************************************/
 import { FeatureModule, TYPES, bindAsService, configureCommand, configureView } from '@eclipse-glsp/sprotty';
 import '../../../../css/change-bounds.css';
-import { SResizeHandle } from '../../change-bounds/model';
+import { GResizeHandle } from '../../change-bounds/model';
 import { ChangeBoundsManager } from './change-bounds-manager';
 import { ChangeBoundsTool } from './change-bounds-tool';
 import { HideChangeBoundsToolResizeFeedbackCommand, ShowChangeBoundsToolResizeFeedbackCommand } from './change-bounds-tool-feedback';
-import { SResizeHandleView } from './view';
+import { GResizeHandleView } 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, GResizeHandle.TYPE, GResizeHandleView);
+    },
+    { featureId: Symbol('changeBoundsTool') }
+);

package/src/features/tools/change-bounds/change-bounds-tool-move-feedback.ts

@@ -26,7 +26,7 @@ import {
     isNonRoutableSelectedMovableBoundsAware,
     removeDescendants
 } from '../../../utils/gmodel-util';
-import { SResizeHandle } from '../../change-bounds/model';
+import { GResizeHandle } from '../../change-bounds/model';
 import { ChangeBoundsTool } from './change-bounds-tool';
 import { MoveFinishedEventAction, MoveInitializedEventAction } from './change-bounds-tool-feedback';
 import { ChangeBoundsTracker, TrackedMove } from './change-bounds-tracker';
@@ -66,7 +66,7 @@ export class FeedbackMoveMouseListener extends DragAwareMouseListener {
     }
 
     protected initializeMove(target: GModelElement, event: MouseEvent): void {
-        if (target instanceof SResizeHandle) {
+        if (target instanceof GResizeHandle) {
             // avoid conflict with resize tool
             return;
         }
@@ -102,7 +102,7 @@ export class FeedbackMoveMouseListener extends DragAwareMouseListener {
     }
 
     protected isValidMoveable(element?: GModelElement): element is MoveableElement {
-        return !!element && isNonRoutableSelectedMovableBoundsAware(element) && !(element instanceof SResizeHandle);
+        return !!element && isNonRoutableSelectedMovableBoundsAware(element) && !(element instanceof GResizeHandle);
     }
 
     override nonDraggingMouseUp(element: GModelElement, event: MouseEvent): Action[] {

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

@@ -51,7 +51,7 @@ import {
 } from '../../../utils/gmodel-util';
 import { LocalRequestBoundsAction } from '../../bounds/local-bounds';
 import { SetBoundsFeedbackAction } from '../../bounds/set-bounds-feedback-command';
-import { SResizeHandle, isResizable } from '../../change-bounds/model';
+import { GResizeHandle, isResizable } from '../../change-bounds/model';
 import { IMovementRestrictor } from '../../change-bounds/movement-restrictor';
 import { BaseEditTool } from '../base-tools';
 import { CSS_ACTIVE_HANDLE, ChangeBoundsManager } from './change-bounds-manager';
@@ -131,7 +131,7 @@ export class ChangeBoundsListener extends DragAwareMouseListener implements ISel
 
     // members for resize mode
     protected activeResizeElement?: ResizableModelElement;
-    protected activeResizeHandle?: SResizeHandle;
+    protected activeResizeHandle?: GResizeHandle;
     protected handleFeedback: FeedbackEmitter;
     protected resizeFeedback: FeedbackEmitter;
 
@@ -155,7 +155,7 @@ export class ChangeBoundsListener extends DragAwareMouseListener implements ISel
     }
 
     protected updateResizeElement(target: GModelElement, event?: MouseEvent): boolean {
-        this.activeResizeHandle = target instanceof SResizeHandle ? target : undefined;
+        this.activeResizeHandle = target instanceof GResizeHandle ? target : undefined;
         this.activeResizeElement = this.activeResizeHandle?.parent ?? this.findResizeElement(target);
         if (this.activeResizeElement) {
             if (event) {
@@ -301,7 +301,7 @@ export class ChangeBoundsListener extends DragAwareMouseListener implements ISel
         return newRoutingPoints.length > 0 ? [ChangeRoutingPointsOperation.create(newRoutingPoints)] : [];
     }
 
-    protected handleResizeOnServer(activeResizeHandle: SResizeHandle): Action[] {
+    protected handleResizeOnServer(activeResizeHandle: GResizeHandle): Action[] {
         if (this.initialBounds && this.isValidResize(activeResizeHandle.parent)) {
             const elementAndBounds = toElementAndBounds(activeResizeHandle.parent);
             if (!this.initialBounds.newPosition || !elementAndBounds.newPosition) {