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

package/src/features/tools/node-creation/insert-indicator.ts

@@ -0,0 +1,41 @@
+/********************************************************************************
+ * 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 { Args, Dimension, FeatureSet, GNode, boundsFeature, createFeatureSet, moveFeature } from '@eclipse-glsp/sprotty';
+import { v4 as uuid } from 'uuid';
+import { ArgsAware, argsFeature } from '../../../base/args-feature';
+
+export const ARG_LENGTH = 'length';
+
+export class InsertIndicator extends GNode implements ArgsAware {
+    static override readonly DEFAULT_FEATURES = [boundsFeature, moveFeature, argsFeature];
+
+    static TYPE = 'node:insert-indicator';
+
+    override id: string = uuid();
+    override type: string = InsertIndicator.TYPE;
+    override features?: FeatureSet = createFeatureSet(InsertIndicator.DEFAULT_FEATURES);
+    override cssClasses: string[] = ['insert-indicator', 'sprotty-node'];
+    override size: Dimension = Dimension.ZERO;
+    args: Args = {};
+
+    constructor(length?: number) {
+        super();
+        if (length) {
+            this.args = { [ARG_LENGTH]: length };
+        }
+    }
+}

package/src/features/tools/node-creation/node-creation-module.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,15 +13,30 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { FeatureModule, TYPES, TriggerNodeCreationAction, bindAsService, configureActionHandler } from '@eclipse-glsp/sprotty';
+import {
+    FeatureModule,
+    TYPES,
+    TriggerNodeCreationAction,
+    bindAsService,
+    configureActionHandler,
+    configureModelElement
+} from '@eclipse-glsp/sprotty';
 import { elementTemplateModule } from '../../element-template/element-template-module';
+import { ContainerManager } from './container-manager';
+import { InsertIndicator } from './insert-indicator';
 import { NodeCreationTool } from './node-creation-tool';
+import { InsertIndicatorView } from './node-creation-views';
 
 export const nodeCreationToolModule = new FeatureModule(
     (bind, unbind, isBound, rebind) => {
         const context = { bind, unbind, isBound, rebind };
+        bind(ContainerManager).toSelf().inSingletonScope();
         bindAsService(context, TYPES.ITool, NodeCreationTool);
         configureActionHandler(context, TriggerNodeCreationAction.KIND, NodeCreationTool);
+        configureModelElement(context, InsertIndicator.TYPE, InsertIndicator, InsertIndicatorView);
     },
-    { requires: elementTemplateModule }
+    {
+        featureId: Symbol('nodeCreationTool'),
+        requires: elementTemplateModule
+    }
 );

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

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2020-2023 EclipseSource and others.
+ * Copyright (c) 2020-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
@@ -15,27 +15,38 @@
  ********************************************************************************/
 import {
     Action,
+    Args,
+    Bounds,
     CreateNodeOperation,
+    Dimension,
+    Disposable,
+    DisposableCollection,
     GModelElement,
-    GNode,
+    GhostElement,
+    IModelFactory,
     Point,
     TYPES,
     TriggerNodeCreationAction,
-    findParentByFeature,
-    isCtrlOrCmd
+    isBoundsAware,
+    isCtrlOrCmd,
+    isMoveable
 } from '@eclipse-glsp/sprotty';
-import { inject, injectable, optional } from 'inversify';
+import { inject, injectable } from 'inversify';
 import '../../../../css/ghost-element.css';
 import { DragAwareMouseListener } from '../../../base/drag-aware-mouse-listener';
+import { EditorContextService } from '../../../base/editor-context-service';
 import { CSS_GHOST_ELEMENT, CSS_HIDDEN, CursorCSS, cursorFeedbackAction } from '../../../base/feedback/css-feedback';
+import { FeedbackEmitter } from '../../../base/feedback/feedback-emitter';
 import { EnableDefaultToolsAction } from '../../../base/tool-manager/tool';
-import { getAbsolutePosition } from '../../../utils/viewpoint-util';
-import { IMovementRestrictor } from '../../change-bounds/movement-restrictor';
-import { PositionSnapper } from '../../change-bounds/position-snapper';
+import { MoveableElement } from '../../../utils/gmodel-util';
 import { AddTemplateElementsAction, getTemplateElementId } from '../../element-template/add-template-element';
 import { MouseTrackingElementPositionListener, PositioningTool } from '../../element-template/mouse-tracking-element-position-listener';
-import { Containable, isContainable } from '../../hints/model';
+import { RemoveTemplateElementsAction } from '../../element-template/remove-template-element';
 import { BaseCreationTool } from '../base-tools';
+import { ChangeBoundsManager } from '../change-bounds/change-bounds-manager';
+import { TrackedMove } from '../change-bounds/change-bounds-tracker';
+import { ContainerManager, TrackedInsert } from './container-manager';
+import { InsertIndicator } from './insert-indicator';
 
 @injectable()
 export class NodeCreationTool extends BaseCreationTool<TriggerNodeCreationAction> implements PositioningTool {
@@ -43,97 +54,179 @@ export class NodeCreationTool extends BaseCreationTool<TriggerNodeCreationAction
 
     protected isTriggerAction = TriggerNodeCreationAction.is;
 
-    @inject(TYPES.IMovementRestrictor) @optional() readonly movementRestrictor?: IMovementRestrictor;
-    @inject(PositionSnapper) readonly positionSnapper: PositionSnapper;
+    @inject(ChangeBoundsManager) readonly changeBoundsManager: ChangeBoundsManager;
+    @inject(ContainerManager) readonly containerManager: ContainerManager;
+    @inject(TYPES.IModelFactory) modelFactory: IModelFactory;
 
     get id(): string {
         return NodeCreationTool.ID;
     }
 
     doEnable(): void {
-        let trackingListener: MouseTrackingElementPositionListener | undefined;
-        const ghostElement = this.triggerAction.ghostElement;
-        if (ghostElement) {
-            trackingListener = new MouseTrackingElementPositionListener(getTemplateElementId(ghostElement.template), this, 'middle');
-            this.toDisposeOnDisable.push(
-                this.registerFeedback(
-                    [AddTemplateElementsAction.create({ templates: [ghostElement.template], addClasses: [CSS_HIDDEN, CSS_GHOST_ELEMENT] })],
-                    ghostElement
-                ),
-                this.mouseTool.registerListener(trackingListener)
-            );
-        }
+        const ghostElement = this.triggerAction.ghostElement ?? { template: this.modelFactory.createSchema(this.createInsertIndicator()) };
+        this.toDisposeOnDisable.push(this.createGhostElementTracker(ghostElement, 'middle'));
+        this.toDisposeOnDisable.push(this.createNodeCreationListener(ghostElement));
+        this.toDisposeOnDisable.push(this.createNodeCreationCursorFeedback().submit());
+    }
+
+    protected createInsertIndicator(): GModelElement {
+        return new InsertIndicator();
+    }
 
-        this.toDisposeOnDisable.push(
-            this.mouseTool.registerListener(new NodeCreationToolMouseListener(this.triggerAction, this, trackingListener)),
-            this.registerFeedback([cursorFeedbackAction(CursorCSS.NODE_CREATION)], this, [cursorFeedbackAction()])
+    protected createGhostElementTracker(ghostElement: GhostElement, position: 'top-left' | 'middle'): Disposable {
+        const trackingListener = new NodeInsertTrackingListener(
+            getTemplateElementId(ghostElement.template),
+            this.triggerAction.elementTypeId,
+            this,
+            position,
+            this.editorContext
         );
+        return new DisposableCollection(trackingListener, this.mouseTool.registerListener(trackingListener));
+    }
+
+    protected createNodeCreationListener(ghostElement: GhostElement): Disposable {
+        const toolListener = new NodeCreationToolMouseListener(this.triggerAction, this, ghostElement);
+        return new DisposableCollection(toolListener, this.mouseTool.registerListener(toolListener));
+    }
+
+    protected createNodeCreationCursorFeedback(): FeedbackEmitter {
+        return this.createFeedbackEmitter().add(cursorFeedbackAction(CursorCSS.NODE_CREATION), cursorFeedbackAction());
+    }
+}
+
+export interface ContainerPositioningTool extends PositioningTool {
+    readonly containerManager: ContainerManager;
+}
+
+export class NodeInsertTrackingListener extends MouseTrackingElementPositionListener {
+    constructor(
+        elementId: string,
+        protected elementTypeId: string,
+        protected override tool: ContainerPositioningTool,
+        cursorPosition: 'top-left' | 'middle' = 'top-left',
+        editorContext?: EditorContextService
+    ) {
+        super(elementId, tool, cursorPosition, editorContext);
+    }
+
+    protected override addMoveFeedback(move: TrackedMove, ctx: GModelElement, event: MouseEvent): void {
+        super.addMoveFeedback(move, ctx, event);
+        const element = move.elementMoves[0].element;
+        const location = move.elementMoves[0].toPosition;
+        const insert = this.tool.containerManager.insert(element, location, this.elementTypeId, { evt: event });
+        this.tool.containerManager.addInsertFeedback(this.moveGhostFeedback, insert, ctx, event);
     }
 }
 
-@injectable()
 export class NodeCreationToolMouseListener extends DragAwareMouseListener {
-    protected container?: GModelElement & Containable;
+    protected cursorFeedback: FeedbackEmitter;
+    protected ghostElementFeedback: FeedbackEmitter;
+    protected ghostElementId: string;
 
     constructor(
         protected triggerAction: TriggerNodeCreationAction,
         protected tool: NodeCreationTool,
-        protected trackingListener?: MouseTrackingElementPositionListener
+        protected ghostElement: GhostElement
     ) {
         super();
-    }
-
-    protected creationAllowed(elementTypeId: string): boolean | undefined {
-        return this.container && this.container.isContainableElement(elementTypeId);
+        this.cursorFeedback = tool.createFeedbackEmitter();
+        this.ghostElementFeedback = tool.createFeedbackEmitter();
+        this.ghostElementId = getTemplateElementId(ghostElement.template);
+        this.createGhostElement(ghostElement);
     }
 
     get elementTypeId(): string {
         return this.triggerAction.elementTypeId;
     }
 
-    override nonDraggingMouseUp(target: GModelElement, event: MouseEvent): Action[] {
+    override nonDraggingMouseUp(ctx: GModelElement, event: MouseEvent): Action[] {
         const result: Action[] = [];
-        if (this.container === undefined) {
-            this.mouseOver(target, event);
+
+        const insert = this.getTrackedInsert(ctx, event);
+        if (insert.valid) {
+            result.push(this.getCreateOperation(ctx, event, insert));
+        }
+        if (this.isContinuousMode(ctx, event)) {
+            // we continue in stamp mode so we keep the ghost but dispose everything else
+            this.disposeAllButGhostElement();
+            return result;
         }
 
-        if (this.creationAllowed(this.elementTypeId)) {
-            const containerId = this.container ? this.container.id : undefined;
-            const location = this.getInsertPosition(target, event);
-            result.push(CreateNodeOperation.create(this.elementTypeId, { location, containerId, args: this.triggerAction.args }));
-            if (!isCtrlOrCmd(event)) {
-                result.push(EnableDefaultToolsAction.create());
-            } else {
-                this.tool.deregisterFeedback(this);
-            }
+        if (insert.valid) {
+            // we keep the ghost element until the next update to avoid flickering during insert
+            this.ghostElementFeedback.discard();
+        } else {
+            this.dispose();
         }
+        result.push(EnableDefaultToolsAction.create());
         return result;
     }
 
-    protected getInsertPosition(target: GModelElement, event: MouseEvent): Point {
-        if (this.trackingListener) {
-            const trackedPosition = this.trackingListener.currentPosition;
-            if (trackedPosition) {
-                return trackedPosition;
-            }
+    /**
+     * Determines wether the tool should run in continuous mode (also called stamp mode) or not.
+     * If continuous mode is enabled, the tool will stay after a successful creation.
+     * The user can then create more elements of the same type without having to re-trigger the tool.
+     * By default, continuous mode is enabled if the user holds the CTRL key.
+     * @param ctx the current model context
+     * @param event
+     */
+    protected isContinuousMode(ctx: GModelElement, event: MouseEvent): boolean {
+        return isCtrlOrCmd(event);
+    }
+
+    protected getCreateOperation(ctx: GModelElement, event: MouseEvent, insert: TrackedInsert): Action {
+        return CreateNodeOperation.create(this.elementTypeId, {
+            location: insert.location,
+            containerId: insert.container?.id,
+            args: this.getCreateNodeOperationArgs(insert, ctx, event)
+        });
+    }
+
+    protected getCreateNodeOperationArgs(insert: TrackedInsert, ctx: GModelElement, event: MouseEvent): Args | undefined {
+        let args = { ...this.triggerAction.args };
+        const ghostElement = this.getGhostElement(ctx, event);
+        if (ghostElement) {
+            const ghostDimensions = isBoundsAware(ghostElement) ? Bounds.dimension(ghostElement.bounds) : Dimension.ZERO;
+            args = {
+                ...args,
+                'ghost-x': ghostElement.position.x,
+                'ghost-y': ghostElement.position.y,
+                'ghost-width': ghostDimensions.width,
+                'ghost-height': ghostDimensions.height
+            };
         }
-        const location = getAbsolutePosition(target, event);
-
-        // Create a 0-bounds proxy element for snapping
-        const elementProxy = new GNode();
-        elementProxy.size = { width: 0, height: 0 };
-        return this.tool.positionSnapper.snapPosition(location, elementProxy);
-    }
-
-    override mouseOver(target: GModelElement, event: MouseEvent): Action[] {
-        const currentContainer = findParentByFeature(target, isContainable);
-        if (!this.container || currentContainer !== this.container) {
-            this.container = currentContainer;
-            const feedback = this.creationAllowed(this.elementTypeId)
-                ? cursorFeedbackAction(CursorCSS.NODE_CREATION)
-                : cursorFeedbackAction(CursorCSS.OPERATION_NOT_ALLOWED);
-            this.tool.registerFeedback([feedback]);
+        return args;
+    }
+
+    protected createGhostElement(ghostElement: GhostElement): string {
+        const templates = [ghostElement.template];
+        this.ghostElementFeedback.add(
+            AddTemplateElementsAction.create({ templates, addClasses: [CSS_HIDDEN, CSS_GHOST_ELEMENT] }),
+            RemoveTemplateElementsAction.create({ templates })
+        );
+        this.ghostElementFeedback.submit();
+        return getTemplateElementId(ghostElement.template);
+    }
+
+    protected getGhostElement(ctx: GModelElement, event: MouseEvent): MoveableElement | undefined {
+        const ghostElement = ctx.index.getById(this.ghostElementId);
+        return ghostElement && isMoveable(ghostElement) ? ghostElement : undefined;
+    }
+
+    protected getTrackedInsert(ctx: GModelElement, event: MouseEvent): TrackedInsert {
+        const ghostElement = this.getGhostElement(ctx, event);
+        if (!ghostElement) {
+            return { elementTypeId: this.elementTypeId, location: Point.ORIGIN, valid: false, options: { evt: event } };
         }
-        return [];
+        return this.tool.containerManager.insert(ghostElement, ghostElement.position, this.elementTypeId, { evt: event });
+    }
+
+    protected disposeAllButGhostElement(): void {
+        super.dispose();
+    }
+
+    override dispose(): void {
+        this.ghostElementFeedback.dispose();
+        this.disposeAllButGhostElement();
     }
 }

package/src/features/tools/node-creation/node-creation-views.tsx

@@ -0,0 +1,46 @@
+/********************************************************************************
+ * Copyright (c) 2024 Axon Ivy AG 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
+ ********************************************************************************/
+/** @jsx svg */
+import { IView, RenderingContext, TYPES, setClass, svg } from '@eclipse-glsp/sprotty';
+import { inject, injectable, optional } from 'inversify';
+import { VNode } from 'snabbdom';
+import { GArgument } from '../../../utils/argument-utils';
+import { Grid } from '../../grid/grid';
+import { ARG_LENGTH, InsertIndicator } from './insert-indicator';
+
+@injectable()
+export class InsertIndicatorView implements IView {
+    @optional() @inject(TYPES.Grid) protected grid?: Grid;
+
+    render(model: Readonly<InsertIndicator>, context: RenderingContext): VNode | undefined {
+        if (context.targetKind === 'hidden') {
+            return undefined;
+        }
+        const size = this.getSize(model);
+        const node = (
+            <g>
+                <polyline class-sprotty-node={true} class-insert-indicator={true} points={`0,${-size / 2} 0,${size / 2}`}></polyline>
+                <polyline class-sprotty-node={true} class-insert-indicator={true} points={`${-size / 2},0 ${size / 2},0`}></polyline>
+            </g>
+        );
+        model.cssClasses.forEach(cl => setClass(node, cl, true));
+        return node;
+    }
+
+    protected getSize(model: Readonly<InsertIndicator>): number {
+        return GArgument.getNumber(model, ARG_LENGTH) ?? this.grid?.x ?? 10;
+    }
+}

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

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2022-2023 EclipseSource and others.
+ * Copyright (c) 2022-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,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/undo-redo/undo-redo-module.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
@@ -14,8 +14,7 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 
-import { ContainerModule } from 'inversify';
-import { bindAsService, TYPES } from '@eclipse-glsp/sprotty';
+import { bindAsService, FeatureModule, TYPES } from '@eclipse-glsp/sprotty';
 import { GLSPUndoRedoKeyListener } from './undo-redo-key-listener';
 
 /**
@@ -23,6 +22,9 @@ import { GLSPUndoRedoKeyListener } from './undo-redo-key-listener';
  * 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 undoRedoModule = new ContainerModule((bind, unbind, isBound, rebind) => {
-    bindAsService(bind, TYPES.KeyListener, GLSPUndoRedoKeyListener);
-});
+export const undoRedoModule = new FeatureModule(
+    (bind, unbind, isBound, rebind) => {
+        bindAsService(bind, TYPES.KeyListener, GLSPUndoRedoKeyListener);
+    },
+    { featureId: Symbol('undoRedo') }
+);

package/src/features/validation/issue-marker.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
@@ -22,11 +22,11 @@ import {
     Marker,
     MarkerKind,
     Projectable,
-    SIssueMarker,
+    SIssueMarkerImpl,
     isBoundsAware
 } from '@eclipse-glsp/sprotty';
 
-export class GIssueMarker extends SIssueMarker implements Projectable {
+export class GIssueMarker extends SIssueMarkerImpl implements Projectable {
     constructor() {
         super();
         this.features = new Set<symbol>(GDecoration.DEFAULT_FEATURES);
@@ -90,9 +90,10 @@ export function getGIssueMarker(modelElement: GParentElement): GIssueMarker | un
  * @returns the created `GIssue`.
  */
 export function createGIssue(marker: Marker, parent?: GParentElement): GIssue {
-    const issue = new GIssue();
-    issue.message = marker.description;
-
+    const issue: GIssue = {
+        message: marker.description,
+        severity: 'info'
+    };
     switch (marker.kind) {
         case MarkerKind.ERROR: {
             issue.severity = 'error';

package/src/features/validation/marker-navigator.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2020-2023 EclipseSource and others.
+ * Copyright (c) 2020-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
@@ -15,7 +15,6 @@
  ********************************************************************************/
 import {
     Action,
-    BoundsAware,
     CenterAction,
     GIssueSeverity,
     GModelElement,
@@ -26,7 +25,6 @@ import {
     MenuItem,
     Point,
     SelectAction,
-    Selectable,
     TYPES,
     findParentByFeature,
     hasArrayProp,
@@ -38,7 +36,7 @@ import {
 import { inject, injectable } from 'inversify';
 import { GLSPActionDispatcher } from '../../base/action-dispatcher';
 import { SelectionService } from '../../base/selection-service';
-import { getElements, isSelectableAndBoundsAware } from '../../utils/gmodel-util';
+import { BoundsAwareModelElement, SelectableElement, getElements, isSelectableAndBoundsAware } from '../../utils/gmodel-util';
 import { MarkerPredicates, collectIssueMarkers } from '../../utils/marker';
 import { GIssueMarker } from './issue-marker';
 
@@ -110,7 +108,7 @@ export class MarkerNavigator {
 
     next(
         root: Readonly<GModelRoot>,
-        current?: GModelElement & BoundsAware,
+        current?: BoundsAwareModelElement,
         predicate: (marker: GIssueMarker) => boolean = MarkerPredicates.ALL
     ): GIssueMarker | undefined {
         const markers = this.getMarkers(root, predicate);
@@ -122,7 +120,7 @@ export class MarkerNavigator {
 
     previous(
         root: Readonly<GModelRoot>,
-        current?: GModelElement & BoundsAware,
+        current?: BoundsAwareModelElement,
         predicate: (marker: GIssueMarker) => boolean = MarkerPredicates.ALL
     ): GIssueMarker | undefined {
         const markers = this.getMarkers(root, predicate);
@@ -137,7 +135,7 @@ export class MarkerNavigator {
         return markers.filter(predicate).sort(this.markerComparator.compare);
     }
 
-    protected getNextIndex(current: GModelElement & BoundsAware, markers: GIssueMarker[]): number {
+    protected getNextIndex(current: BoundsAwareModelElement, markers: GIssueMarker[]): number {
         for (let index = 0; index < markers.length; index++) {
             if (this.markerComparator.compare(markers[index], current) > 0) {
                 return index;
@@ -146,7 +144,7 @@ export class MarkerNavigator {
         return 0;
     }
 
-    protected getPreviousIndex(current: GModelElement & BoundsAware, markers: GIssueMarker[]): number {
+    protected getPreviousIndex(current: BoundsAwareModelElement, markers: GIssueMarker[]): number {
         for (let index = markers.length - 1; index >= 0; index--) {
             if (this.markerComparator.compare(markers[index], current) < 0) {
                 return index;
@@ -182,7 +180,7 @@ export class NavigateToMarkerActionHandler implements IActionHandler {
         }
     }
 
-    protected getSelectedElements(action: NavigateToMarkerAction): (GModelElement & Selectable)[] {
+    protected getSelectedElements(action: NavigateToMarkerAction): SelectableElement[] {
         if (action.selectedElementIds && action.selectedElementIds.length > 0) {
             return getElements(this.selectionService.getModelRoot().index, action.selectedElementIds, isSelectable);
         }

package/src/features/validation/validate.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
@@ -31,6 +31,7 @@ import { inject, injectable, optional } from 'inversify';
 import { EditorContextService } from '../../base/editor-context-service';
 import { IFeedbackActionDispatcher, IFeedbackEmitter } from '../../base/feedback/feedback-action-dispatcher';
 import { FeedbackCommand } from '../../base/feedback/feedback-command';
+import { FeedbackEmitter } from '../../base/feedback/feedback-emitter';
 import { removeCssClasses } from '../../utils/gmodel-util';
 import { GIssueMarker, createGIssue, getGIssueMarker, getOrCreateGIssueMarker, getSeverity } from './issue-marker';
 
@@ -42,7 +43,7 @@ import { GIssueMarker, createGIssue, getGIssueMarker, getOrCreateGIssueMarker, g
 export class ValidationFeedbackEmitter implements IFeedbackEmitter {
     @inject(TYPES.IFeedbackActionDispatcher) protected feedbackActionDispatcher: IFeedbackActionDispatcher;
 
-    protected registeredFeedbackByReason: Map<string, { action: ApplyMarkersAction; emitter: IFeedbackEmitter }> = new Map();
+    protected registeredFeedbackByReason: Map<string, FeedbackEmitter> = new Map();
 
     /**
      * Register the action that should be emitted for visualizing validation feedback.
@@ -51,25 +52,9 @@ export class ValidationFeedbackEmitter implements IFeedbackEmitter {
      */
     registerValidationFeedbackAction(action: ApplyMarkersAction, reason = ''): void {
         // De-register feedback and clear existing markers with the same reason
-        const previousFeedbackWithSameReason = this.registeredFeedbackByReason.get(reason);
-        let emitter: IFeedbackEmitter | undefined;
-        if (previousFeedbackWithSameReason) {
-            emitter = previousFeedbackWithSameReason.emitter;
-            const deleteMarkersAction = DeleteMarkersAction.create(previousFeedbackWithSameReason.action.markers);
-            this.feedbackActionDispatcher.deregisterFeedback(emitter, [deleteMarkersAction]);
-        }
-
-        if (!emitter) {
-            emitter = this.createEmitter(reason);
-        }
-
-        // Register new action responsible for applying markers and re-applying them when the model is updated
-        this.registeredFeedbackByReason.set(reason, { action, emitter });
-        this.feedbackActionDispatcher.registerFeedback(emitter, [action]);
-    }
-
-    protected createEmitter(reason: string): IFeedbackEmitter {
-        return { id: 'validationFeedbackEmitter_' + reason };
+        const emitter = this.registeredFeedbackByReason.get(reason)?.dispose() ?? this.feedbackActionDispatcher.createEmitter();
+        emitter.add(action, () => DeleteMarkersAction.create(action.markers)).submit();
+        this.registeredFeedbackByReason.set(reason, emitter);
     }
 }