@eclipse-glsp/client 1.1.0-next.c40feb3.207 → 1.1.0-next.c5afbfa.273

package/src/base/default.module.ts

@@ -0,0 +1,122 @@
+/********************************************************************************
+ * Copyright (c) 2019-2023 EclipseSource and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the Eclipse
+ * Public License v. 2.0 are satisfied: GNU General Public License, version 2
+ * with the GNU Classpath Exception which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ ********************************************************************************/
+import '@vscode/codicons/dist/codicon.css';
+import {
+    FeatureModule,
+    KeyTool,
+    LocationPostprocessor,
+    MouseTool,
+    MoveCommand,
+    SetDirtyStateAction,
+    SetEditModeAction,
+    TYPES,
+    bindAsService,
+    bindOrRebind,
+    configureActionHandler,
+    configureCommand,
+    sprottyDefaultModule
+} from '~glsp-sprotty';
+import '../../css/glsp-sprotty.css';
+import { GLSPActionDispatcher } from './action-dispatcher';
+import { GLSPCommandStack } from './command-stack';
+import { EditorContextService } from './editor-context-service';
+import { ModifyCssFeedbackCommand } from './feedback/css-feedback';
+import { FeedbackActionDispatcher } from './feedback/feedback-action-dispatcher';
+import { FeedbackAwareUpdateModelCommand } from './feedback/update-model-command';
+import { FocusStateChangedAction } from './focus/focus-state-change-action';
+import { FocusTracker } from './focus/focus-tracker';
+import { DefaultModelInitializationConstraint, ModelInitializationConstraint } from './model-initialization-constraint';
+import { DiagramLoader } from './model/diagram-loader';
+import { GLSPModelSource } from './model/glsp-model-source';
+import { GLSPModelRegistry } from './model/model-registry';
+import { SelectionClearingMouseListener } from './selection-clearing-mouse-listener';
+import { SelectionService } from './selection-service';
+import { EnableDefaultToolsAction, EnableToolsAction } from './tool-manager/tool';
+import { DefaultToolsEnablingKeyListener, ToolManager, ToolManagerActionHandler } from './tool-manager/tool-manager';
+import { GLSPKeyTool } from './view/key-tool';
+import { GLSPMouseTool } from './view/mouse-tool';
+import { GLSPViewRegistry } from './view/view-registry';
+
+/**
+ * The default module provides all of GLSP's base functionality and services.
+ * It builds on top of sprotty's default module {@link `sprottyDefaultModule`}.
+ */
+export const defaultModule = new FeatureModule((bind, unbind, isBound, rebind, ...rest) => {
+    // load bindings from sprotty's default module to avoid code duplication
+    sprottyDefaultModule.registry(bind, unbind, isBound, rebind, ...rest);
+    const context = { bind, unbind, isBound, rebind };
+
+    bind(EditorContextService).toSelf().inSingletonScope();
+    bind(TYPES.IEditorContextServiceProvider).toProvider<EditorContextService>(
+        ctx => () =>
+            new Promise<EditorContextService>((resolve, reject) => {
+                if (ctx.container.isBound(EditorContextService)) {
+                    resolve(ctx.container.get<EditorContextService>(EditorContextService));
+                } else {
+                    reject();
+                }
+            })
+    );
+
+    configureActionHandler(context, SetEditModeAction.KIND, EditorContextService);
+    configureActionHandler(context, SetDirtyStateAction.KIND, EditorContextService);
+
+    bind(FocusTracker).toSelf().inSingletonScope();
+    configureActionHandler(context, FocusStateChangedAction.KIND, FocusTracker);
+
+    // Model update initialization ------------------------------------
+    bind(TYPES.IFeedbackActionDispatcher).to(FeedbackActionDispatcher).inSingletonScope();
+    configureCommand(context, FeedbackAwareUpdateModelCommand);
+
+    bind(GLSPMouseTool).toSelf().inSingletonScope();
+    bindOrRebind(context, MouseTool).toService(GLSPMouseTool);
+    bind(GLSPKeyTool).toSelf().inSingletonScope();
+    bindOrRebind(context, KeyTool).toService(GLSPKeyTool);
+
+    bindAsService(context, TYPES.MouseListener, SelectionClearingMouseListener);
+
+    bindOrRebind(context, TYPES.ICommandStack).to(GLSPCommandStack).inSingletonScope();
+    bind(GLSPActionDispatcher).toSelf().inSingletonScope();
+    bindOrRebind(context, TYPES.IActionDispatcher).toService(GLSPActionDispatcher);
+
+    bindAsService(context, TYPES.ModelSource, GLSPModelSource);
+    bind(DiagramLoader).toSelf().inSingletonScope();
+    bind(ModelInitializationConstraint).to(DefaultModelInitializationConstraint).inSingletonScope();
+
+    // support re-registration of model elements and views
+    bindOrRebind(context, TYPES.SModelRegistry).to(GLSPModelRegistry).inSingletonScope();
+    bindOrRebind(context, TYPES.ViewRegistry).to(GLSPViewRegistry).inSingletonScope();
+
+    bind(SelectionService).toSelf().inSingletonScope();
+    bind(TYPES.ISModelRootListener).toService(SelectionService);
+
+    // Feedback Support ------------------------------------
+    // Generic re-usable feedback modifying css classes
+    configureCommand(context, ModifyCssFeedbackCommand);
+    // We support using sprotty's MoveCommand as client-side visual feedback
+    configureCommand(context, MoveCommand);
+
+    bindAsService(context, TYPES.IVNodePostprocessor, LocationPostprocessor);
+    bind(TYPES.HiddenVNodePostprocessor).toService(LocationPostprocessor);
+
+    // Tool manager initialization ------------------------------------
+    bind(TYPES.IToolManager).to(ToolManager).inSingletonScope();
+    bind(DefaultToolsEnablingKeyListener).toSelf().inSingletonScope();
+    bind(TYPES.KeyListener).toService(DefaultToolsEnablingKeyListener);
+    bind(ToolManagerActionHandler).toSelf().inSingletonScope();
+    configureActionHandler(context, EnableDefaultToolsAction.KIND, ToolManagerActionHandler);
+    configureActionHandler(context, EnableToolsAction.KIND, ToolManagerActionHandler);
+});

package/src/base/drag-aware-mouse-listener.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2019-2022 EclipseSource and others.
+ * Copyright (c) 2019-2023 EclipseSource and others.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -13,8 +13,7 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { Action } from '@eclipse-glsp/protocol';
-import { MouseListener, SModelElement } from 'sprotty';
+import { Action, MouseListener, SModelElement } from '~glsp-sprotty';
 
 /**
  * A mouse listener that is aware of prior mouse dragging.
@@ -25,8 +24,8 @@ import { MouseListener, SModelElement } from 'sprotty';
  * of mouse up events.
  */
 export class DragAwareMouseListener extends MouseListener {
-    private _isMouseDown = false;
-    private _isMouseDrag = false;
+    protected _isMouseDown = false;
+    protected _isMouseDrag = false;
 
     override mouseDown(target: SModelElement, event: MouseEvent): Action[] {
         this._isMouseDown = true;

package/src/base/editor-context-service.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2020-2022 EclipseSource and others.
+ * Copyright (c) 2020-2023 EclipseSource and others.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -13,17 +13,35 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { Action, Args, distinctAdd, EditMode, EditorContext, remove, SetEditModeAction } from '@eclipse-glsp/protocol';
-import { inject, injectable, multiInject, optional } from 'inversify';
-import { IActionHandler, ModelSource, MousePositionTracker, SModelElement, SModelRoot } from 'sprotty';
-import { SelectionService } from '../features/select/selection-service';
-import { isSourceUriAware } from './source-uri-aware';
-import { TYPES } from './types';
-
-export interface EditModeListener {
-    editModeChanged(newValue: string, oldvalue: string): void;
+import { inject, injectable, multiInject, optional, postConstruct, preDestroy } from 'inversify';
+import {
+    Action,
+    Args,
+    Disposable,
+    DisposableCollection,
+    EditMode,
+    EditorContext,
+    Emitter,
+    Event,
+    IActionHandler,
+    MaybePromise,
+    MousePositionTracker,
+    SModelElement,
+    SModelRoot,
+    SetDirtyStateAction,
+    SetEditModeAction,
+    TYPES,
+    ValueChange
+} from '~glsp-sprotty';
+import { GLSPActionDispatcher } from './action-dispatcher';
+import { IDiagramOptions, IDiagramStartup } from './model/diagram-loader';
+import { SelectionService } from './selection-service';
+
+export interface IEditModeListener {
+    editModeChanged(newValue: string, oldValue: string): void;
 }
 
+export type DirtyStateChange = Pick<SetDirtyStateAction, 'isDirty' | 'reason'>;
 /**
  * The `EditorContextService` is a central injectable component that gives read-only access to
  * certain aspects of the diagram, such as the currently selected elements, the model root,
@@ -37,28 +55,49 @@ export interface EditModeListener {
  *    position, etc.).
  */
 @injectable()
-export class EditorContextService implements IActionHandler {
-    @inject(TYPES.SelectionService)
+export class EditorContextService implements IActionHandler, Disposable, IDiagramStartup {
+    @inject(SelectionService)
     protected selectionService: SelectionService;
 
     @inject(MousePositionTracker)
     protected mousePositionTracker: MousePositionTracker;
 
+    @inject(TYPES.IDiagramOptions)
+    protected diagramOptions: IDiagramOptions;
+
     @multiInject(TYPES.IEditModeListener)
     @optional()
-    protected editModeListeners: EditModeListener[] = [];
+    protected editModeListeners: IEditModeListener[] = [];
 
-    @inject(TYPES.ModelSourceProvider)
-    protected modelSourceProvider: () => Promise<ModelSource>;
+    @inject(GLSPActionDispatcher)
+    protected actionDispatcher: GLSPActionDispatcher;
 
     protected _editMode: string;
+    protected onEditModeChangedEmitter = new Emitter<ValueChange<string>>();
+    get onEditModeChanged(): Event<ValueChange<string>> {
+        return this.onEditModeChangedEmitter.event;
+    }
+
+    protected _isDirty: boolean;
+    protected onDirtyStateChangedEmitter = new Emitter<DirtyStateChange>();
+    get onDirtyStateChanged(): Event<DirtyStateChange> {
+        return this.onDirtyStateChangedEmitter.event;
+    }
 
-    register(editModeListener: EditModeListener): void {
-        distinctAdd(this.editModeListeners, editModeListener);
+    protected toDispose = new DisposableCollection();
+
+    @postConstruct()
+    protected initialize(): void {
+        this._editMode = this.diagramOptions.editMode ?? EditMode.EDITABLE;
+        this.toDispose.push(this.onEditModeChangedEmitter, this.onDirtyStateChangedEmitter);
+        this.editModeListeners.forEach(listener =>
+            this.onEditModeChanged(change => listener.editModeChanged(change.newValue, change.oldValue))
+        );
     }
 
-    deregister(editModeListener: EditModeListener): void {
-        remove(this.editModeListeners, editModeListener);
+    @preDestroy()
+    dispose(): void {
+        this.toDispose.dispose();
     }
 
     get(args?: Args): EditorContext {
@@ -79,28 +118,41 @@ export class EditorContextService implements IActionHandler {
 
     handle(action: Action): void {
         if (SetEditModeAction.is(action)) {
-            const oldValue = this._editMode;
-            this._editMode = action.editMode;
-            this.notifiyEditModeListeners(oldValue);
+            this.handleSetEditModeAction(action);
+        } else if (SetDirtyStateAction.is(action)) {
+            this.handleSetDirtyStateAction(action);
         }
     }
 
-    protected notifiyEditModeListeners(oldValue: string): void {
-        this.editModeListeners.forEach(listener => listener.editModeChanged(oldValue, this.editMode));
+    protected handleSetEditModeAction(action: SetEditModeAction): void {
+        const oldValue = this._editMode;
+        this._editMode = action.editMode;
+        this.onEditModeChangedEmitter.fire({ newValue: this.editMode, oldValue });
     }
 
-    async getSourceUri(): Promise<string | undefined> {
-        const modelSource = await this.modelSourceProvider();
-        if (isSourceUriAware(modelSource)) {
-            return modelSource.sourceURI;
+    protected handleSetDirtyStateAction(action: SetDirtyStateAction): void {
+        if (action.isDirty !== this._isDirty) {
+            this._isDirty = action.isDirty;
+            this.onDirtyStateChangedEmitter.fire(action);
         }
-        return undefined;
+    }
+
+    get sourceUri(): string | undefined {
+        return this.diagramOptions.sourceUri;
     }
 
     get editMode(): string {
         return this._editMode;
     }
 
+    get diagramType(): string {
+        return this.diagramOptions.diagramType;
+    }
+
+    get clientId(): string {
+        return this.diagramOptions.clientId;
+    }
+
     get modelRoot(): Readonly<SModelRoot> {
         return this.selectionService.getModelRoot();
     }
@@ -112,6 +164,14 @@ export class EditorContextService implements IActionHandler {
     get isReadonly(): boolean {
         return this.editMode === EditMode.READONLY;
     }
+
+    get isDirty(): boolean {
+        return this._isDirty;
+    }
+
+    postRequestModel(): MaybePromise<void> {
+        this.actionDispatcher.dispatch(SetEditModeAction.create(this.editMode));
+    }
 }
 
 export type EditorContextServiceProvider = () => Promise<EditorContextService>;

package/src/base/feedback/css-feedback.ts

@@ -0,0 +1,101 @@
+/********************************************************************************
+ * Copyright (c) 2019-2023 EclipseSource and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the Eclipse
+ * Public License v. 2.0 are satisfied: GNU General Public License, version 2
+ * with the GNU Classpath Exception which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ ********************************************************************************/
+import { inject, injectable } from 'inversify';
+import { Action, CommandExecutionContext, SModelElement, SModelRoot, TYPES, hasArrayProp } from '~glsp-sprotty';
+import { addCssClasses, getElements, removeCssClasses } from '../../utils/smodel-util';
+import { FeedbackCommand } from './feedback-command';
+
+export interface ModifyCSSFeedbackAction extends Action {
+    kind: typeof ModifyCSSFeedbackAction.KIND;
+
+    elementIds?: string[];
+    add?: string[];
+    remove?: string[];
+}
+
+export namespace ModifyCSSFeedbackAction {
+    export const KIND = 'modifyCSSFeedback';
+
+    export function is(object: any): object is ModifyCSSFeedbackAction {
+        return Action.hasKind(object, KIND) && hasArrayProp(object, 'elementIds');
+    }
+
+    export function create(options: { elements?: (string | SModelElement)[]; add?: string[]; remove?: string[] }): ModifyCSSFeedbackAction {
+        const { elements, ...rest } = options;
+        const elementIds = elements ? elements.map(element => (typeof element === 'string' ? element : element.id)) : undefined;
+        return {
+            kind: KIND,
+            elementIds,
+            ...rest
+        };
+    }
+}
+
+@injectable()
+export class ModifyCssFeedbackCommand extends FeedbackCommand {
+    static readonly KIND = ModifyCSSFeedbackAction.KIND;
+
+    constructor(@inject(TYPES.Action) readonly action: ModifyCSSFeedbackAction) {
+        super();
+    }
+
+    execute(context: CommandExecutionContext): SModelRoot {
+        const elements = this.action.elementIds ? getElements(context.root.index, this.action.elementIds) : [context.root];
+
+        elements.forEach(e => {
+            if (this.action.remove) {
+                removeCssClasses(e, this.action.remove);
+            }
+
+            if (this.action.add) {
+                addCssClasses(e, this.action.add);
+            }
+        });
+
+        return context.root;
+    }
+}
+
+export enum CursorCSS {
+    DEFAULT = 'default-mode',
+    OVERLAP_FORBIDDEN = 'overlap-forbidden-mode',
+    NODE_CREATION = 'node-creation-mode',
+    EDGE_CREATION_SOURCE = 'edge-creation-select-source-mode',
+    EDGE_CREATION_TARGET = 'edge-creation-select-target-mode',
+    EDGE_RECONNECT = 'edge-reconnect-select-target-mode',
+    OPERATION_NOT_ALLOWED = 'edge-modification-not-allowed-mode',
+    ELEMENT_DELETION = 'element-deletion-mode',
+    RESIZE_NESW = 'resize-nesw-mode',
+    RESIZE_NWSE = 'resize-nwse-mode',
+    MOVE = 'move-mode',
+    MARQUEE = 'marquee-mode'
+}
+
+export function cursorFeedbackAction(cursorCss?: CursorCSS): ModifyCSSFeedbackAction {
+    const add = [];
+    if (cursorCss) {
+        add.push(cursorCss);
+    }
+    return ModifyCSSFeedbackAction.create({ add, remove: Object.values(CursorCSS) });
+}
+
+export function applyCssClasses(element: SModelElement, ...add: string[]): ModifyCSSFeedbackAction {
+    return ModifyCSSFeedbackAction.create({ elements: [element], add });
+}
+
+export function deleteCssClasses(element: SModelElement, ...remove: string[]): ModifyCSSFeedbackAction {
+    return ModifyCSSFeedbackAction.create({ elements: [element], remove });
+}

package/src/base/feedback/feedback-action-dispatcher.ts

@@ -0,0 +1,107 @@
+/********************************************************************************
+ * Copyright (c) 2019-2023 EclipseSource and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the Eclipse
+ * Public License v. 2.0 are satisfied: GNU General Public License, version 2
+ * with the GNU Classpath Exception which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ ********************************************************************************/
+import { inject, injectable } from 'inversify';
+import { Action, Disposable, IActionDispatcher, ILogger, TYPES } from '~glsp-sprotty';
+
+export interface IFeedbackEmitter {}
+
+/**
+ * Dispatcher for actions that are meant to show visual feedback on
+ * the diagram that is not part of the diagram sent from the server
+ * after a model update.
+ *
+ * The purpose of this dispatcher is to re-establish the feedback
+ * after the model has been updated or reset by the server, as this would
+ * overwrite the already established feedback, in case it is drawn by
+ * extending the `SModelRoot`. Therefore, tools can register themselves
+ * as feedback emitters with actions they want to place for showing
+ * feedback. This dispatcher will then re-establish all feedback actions
+ * of the registered emitters, whenever the `SModelRoot` has been set or updated.
+ */
+export interface IFeedbackActionDispatcher {
+    /**
+     * Registers `actions` to be sent out by a `feedbackEmitter`.
+     * @param feedbackEmitter the emitter sending out feedback actions.
+     * @param feedbackActions the actions to be sent out.
+     * @param cleanupActions the actions to be sent out when the feedback is de-registered through the returned Disposable.
+     * @returns A 'Disposable' that de-registers the feedback and cleans up any pending feedback with the given `cleanupActions`.
+     */
+    registerFeedback(feedbackEmitter: IFeedbackEmitter, feedbackActions: Action[], cleanupActions?: Action[]): Disposable;
+
+    /**
+     * Deregisters a `feedbackEmitter` from this dispatcher and thereafter
+     * dispatches the provided `actions`.
+     * @param feedbackEmitter the emitter to be deregistered.
+     * @param cleanupActions the actions to be dispatched right after the deregistration.
+     * These actions do not have to be related to the actions sent out by the
+     * deregistered `feedbackEmitter`. The purpose of these actions typically is
+     * to reset the normal state of the diagram without the feedback (e.g., reset a
+     * CSS class that was set by a feedbackEmitter).
+     */
+    deregisterFeedback(feedbackEmitter: IFeedbackEmitter, cleanupActions?: Action[]): void;
+
+    /**
+     * Retrieve all `actions` sent out by currently registered `feedbackEmitter`.
+     */
+    getRegisteredFeedback(): Action[];
+}
+
+@injectable()
+export class FeedbackActionDispatcher implements IFeedbackActionDispatcher {
+    protected registeredFeedback: Map<IFeedbackEmitter, Action[]> = new Map();
+
+    @inject(TYPES.IActionDispatcherProvider) protected actionDispatcher: () => Promise<IActionDispatcher>;
+    @inject(TYPES.ILogger) protected logger: ILogger;
+
+    registerFeedback(feedbackEmitter: IFeedbackEmitter, feedbackActions: Action[], cleanupActions?: Action[] | undefined): Disposable {
+        this.registeredFeedback.set(feedbackEmitter, feedbackActions);
+        this.dispatchFeedback(feedbackActions, feedbackEmitter);
+        return Disposable.create(() => this.deregisterFeedback(feedbackEmitter, cleanupActions));
+    }
+
+    deregisterFeedback(feedbackEmitter: IFeedbackEmitter, cleanupActions?: Action[] | undefined): void {
+        this.registeredFeedback.delete(feedbackEmitter);
+        if (cleanupActions) {
+            this.dispatchFeedback(cleanupActions, feedbackEmitter);
+        }
+    }
+
+    getRegisteredFeedback(): Action[] {
+        const result: Action[] = [];
+        this.registeredFeedback.forEach(actions => result.push(...actions));
+        return result;
+    }
+
+    getRegisteredFeedbackEmitters(action: Action): IFeedbackEmitter[] {
+        const result: IFeedbackEmitter[] = [];
+        this.registeredFeedback.forEach((actions, emitter) => {
+            if (actions.includes(action)) {
+                result.push(emitter);
+            }
+        });
+        return result;
+    }
+
+    protected async dispatchFeedback(actions: Action[], feedbackEmitter: IFeedbackEmitter): Promise<void> {
+        try {
+            const actionDispatcher = await this.actionDispatcher();
+            await actionDispatcher.dispatchAll(actions);
+            this.logger.info(this, `Dispatched feedback actions for ${feedbackEmitter}`);
+        } catch (reason) {
+            this.logger.error(this, 'Failed to dispatch feedback actions', reason);
+        }
+    }
+}

package/src/base/feedback/feedback-command.ts

@@ -0,0 +1,29 @@
+/********************************************************************************
+ * Copyright (c) 2019-2023 EclipseSource and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the Eclipse
+ * Public License v. 2.0 are satisfied: GNU General Public License, version 2
+ * with the GNU Classpath Exception which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ ********************************************************************************/
+import { Command, CommandExecutionContext, CommandReturn } from '~glsp-sprotty';
+
+export abstract class FeedbackCommand extends Command {
+    // used by the `FeedbackAwareUpdateModelCommand`
+    readonly priority: number = 0;
+
+    undo(context: CommandExecutionContext): CommandReturn {
+        return context.root;
+    }
+
+    redo(context: CommandExecutionContext): CommandReturn {
+        return context.root;
+    }
+}

package/src/base/feedback/update-model-command.ts

@@ -0,0 +1,100 @@
+/********************************************************************************
+ * Copyright (c) 2019-2023 EclipseSource and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the Eclipse
+ * Public License v. 2.0 are satisfied: GNU General Public License, version 2
+ * with the GNU Classpath Exception which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ ********************************************************************************/
+import { inject, injectable, optional } from 'inversify';
+import {
+    ActionHandlerRegistry,
+    Animation,
+    Command,
+    CommandActionHandler,
+    CommandExecutionContext,
+    CommandReturn,
+    ILogger,
+    MorphEdgesAnimation,
+    SModelRoot,
+    TYPES,
+    UpdateAnimationData,
+    UpdateModelAction,
+    UpdateModelCommand,
+    toTypeGuard
+} from '~glsp-sprotty';
+import { IFeedbackActionDispatcher } from './feedback-action-dispatcher';
+import { FeedbackCommand } from './feedback-command';
+
+/**
+ * A special {@link UpdateModelCommand} that retrieves all registered {@link Action}s from the {@link IFeedbackActionDispatcher}
+ * (if present) and applies their feedback to the `newRoot` before performing the update. This enables persistent client-side feedback
+ * across model updates initiated by the GLSP server.
+ */
+@injectable()
+export class FeedbackAwareUpdateModelCommand extends UpdateModelCommand {
+    @inject(TYPES.ILogger)
+    protected logger: ILogger;
+
+    @inject(TYPES.IFeedbackActionDispatcher)
+    @optional()
+    protected feedbackActionDispatcher: IFeedbackActionDispatcher;
+
+    protected actionHandlerRegistry?: ActionHandlerRegistry;
+
+    constructor(
+        @inject(TYPES.Action) action: UpdateModelAction,
+        @inject(TYPES.ActionHandlerRegistryProvider)
+        actionHandlerRegistryProvider: () => Promise<ActionHandlerRegistry>
+    ) {
+        super({ animate: true, ...action });
+        actionHandlerRegistryProvider().then(registry => (this.actionHandlerRegistry = registry));
+    }
+
+    protected override performUpdate(oldRoot: SModelRoot, newRoot: SModelRoot, context: CommandExecutionContext): CommandReturn {
+        if (this.feedbackActionDispatcher && this.actionHandlerRegistry) {
+            // Create a temporary context which defines the `newRoot` as `root`
+            // This way we do not corrupt the redo/undo behavior of the super class
+            const tempContext: CommandExecutionContext = {
+                ...context,
+                root: newRoot
+            };
+
+            const feedbackCommands = this.getFeedbackCommands(this.actionHandlerRegistry);
+            feedbackCommands.forEach(command => command.execute(tempContext));
+        }
+
+        return super.performUpdate(oldRoot, newRoot, context);
+    }
+
+    protected getFeedbackCommands(registry: ActionHandlerRegistry): Command[] {
+        const result: Command[] = [];
+        this.feedbackActionDispatcher.getRegisteredFeedback().forEach(action => {
+            const commands = registry
+                .get(action.kind)
+                .filter<CommandActionHandler>(toTypeGuard(CommandActionHandler))
+                .map(handler => handler.handle(action));
+            result.push(...commands);
+        });
+        // sort commands descanting by priority
+        return result.sort((a, b) => this.getPriority(b) - this.getPriority(a));
+    }
+
+    protected getPriority(command: Partial<FeedbackCommand>): number {
+        return command.priority ?? 0;
+    }
+
+    // Override the `createAnimations` implementation and remove the animation for edge morphing. Otherwise routing & reconnect
+    // handles flicker after each server update.
+    protected override createAnimations(data: UpdateAnimationData, root: SModelRoot, context: CommandExecutionContext): Animation[] {
+        const animations = super.createAnimations(data, root, context);
+        return animations.filter(animation => !(animation instanceof MorphEdgesAnimation));
+    }
+}