@eclipse-glsp/client 0.10.0-next.6bee8eb.163 → 0.10.0-next.88e4725.166

package/src/features/navigation/navigation-target-resolver.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2020-2021 EclipseSource and others.
+ * Copyright (c) 2020-2022 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,16 +13,11 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import {
-    isSetResolvedNavigationTargets,
-    NavigationTarget,
-    ResolveNavigationTargetAction,
-    SetResolvedNavigationTargetAction
-} from '@eclipse-glsp/protocol';
+import { NavigationTarget, ResolveNavigationTargetAction, ResponseAction, SetResolvedNavigationTargetAction } from '@eclipse-glsp/protocol';
 import { inject, injectable } from 'inversify';
-import { IActionDispatcher, ILogger, ResponseAction, TYPES } from 'sprotty';
+import { IActionDispatcher, ILogger } from 'sprotty';
 import { EditorContextServiceProvider } from '../../base/editor-context-service';
-import { GLSP_TYPES } from '../../base/types';
+import { TYPES } from '../../base/types';
 
 /**
  * Resolves `NavigationTargets` to element ids.
@@ -32,7 +27,7 @@ import { GLSP_TYPES } from '../../base/types';
  */
 @injectable()
 export class NavigationTargetResolver {
-    @inject(GLSP_TYPES.IEditorContextServiceProvider) protected editorContextService: EditorContextServiceProvider;
+    @inject(TYPES.IEditorContextServiceProvider) protected editorContextService: EditorContextServiceProvider;
     @inject(TYPES.IActionDispatcher) protected dispatcher: IActionDispatcher;
     @inject(TYPES.ILogger) protected readonly logger: ILogger;
 
@@ -53,16 +48,16 @@ export class NavigationTargetResolver {
             return undefined;
         }
         if (NavigationTarget.getElementIds(target).length > 0) {
-            return new SetResolvedNavigationTargetAction(NavigationTarget.getElementIds(target));
+            return SetResolvedNavigationTargetAction.create(NavigationTarget.getElementIds(target));
         }
         const response = await this.requestResolution(target);
-        if (isSetResolvedNavigationTargets(response)) {
+        if (SetResolvedNavigationTargetAction.is(response)) {
             return response;
         }
         return undefined;
     }
 
     protected requestResolution(target: NavigationTarget): Promise<ResponseAction> {
-        return this.dispatcher.request(new ResolveNavigationTargetAction(target));
+        return this.dispatcher.request(ResolveNavigationTargetAction.create(target));
     }
 }

package/src/features/save/di.config.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2019-2021 EclipseSource and others.
+ * Copyright (c) 2019-2022 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 { TYPES } from 'sprotty';
-
+import { TYPES } from '../../base/types';
 import { SaveModelKeyboardListener } from './save-keylistener';
 
 /**

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

@@ -20,7 +20,7 @@ import { matchesKeystroke } from 'sprotty/lib/utils/keyboard';
 export class SaveModelKeyboardListener extends KeyListener {
     override keyDown(_element: SModelRoot, event: KeyboardEvent): Action[] {
         if (matchesKeystroke(event, 'KeyS', 'ctrlCmd')) {
-            return [new SaveModelAction()];
+            return [SaveModelAction.create()];
         }
         return [];
     }

package/src/features/select/di.config.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2019 EclipseSource and others.
+ * Copyright (c) 2019-2022 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,22 +14,20 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 import { ContainerModule } from 'inversify';
-import { configureCommand, TYPES } from 'sprotty';
-
-import { GLSP_TYPES } from '../../base/types';
-import { SelectAllFeedbackCommand, SelectFeedbackCommand } from './select-feedback-action';
+import { configureCommand } from 'sprotty';
+import { TYPES } from '../../base/types';
+import { SelectFeedbackCommand } from './select-feedback-action';
 import { RankedSelectMouseListener } from './select-mouse-listener';
 import { SelectAllCommand, SelectCommand, SelectionService } from './selection-service';
 
 const glspSelectModule = new ContainerModule((bind, _unbind, isBound) => {
     bind(SelectionService).toSelf().inSingletonScope();
-    bind(GLSP_TYPES.SelectionService).toService(SelectionService);
+    bind(TYPES.SelectionService).toService(SelectionService);
     configureCommand({ bind, isBound }, SelectCommand);
     configureCommand({ bind, isBound }, SelectAllCommand);
     configureCommand({ bind, isBound }, SelectFeedbackCommand);
-    configureCommand({ bind, isBound }, SelectAllFeedbackCommand);
     bind(TYPES.MouseListener).to(RankedSelectMouseListener);
-    bind(GLSP_TYPES.SModelRootListener).toService(SelectionService);
+    bind(TYPES.SModelRootListener).toService(SelectionService);
 });
 
 export default glspSelectModule;

package/src/features/select/select-feedback-action.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2019-2021 EclipseSource and others.
+ * Copyright (c) 2019-2022 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,39 +13,34 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
+import { Action, hasArrayProp, SelectAction } from '@eclipse-glsp/protocol';
 import { inject, injectable } from 'inversify';
-import {
-    Command,
-    CommandExecutionContext,
-    SelectAllCommand as SprottySelectAllCommand,
-    SelectCommand as SprottySelectCommand,
-    SModelRoot,
-    TYPES
-} from 'sprotty';
+import { Command, CommandExecutionContext, SelectCommand as SprottySelectCommand, SModelRoot } from 'sprotty';
+import { TYPES } from '../../base/types';
 
-export class SelectFeedbackAction {
-    constructor(
-        public readonly selectedElementsIDs: string[] = [],
-        public readonly deselectedElementsIDs: string[] = [],
-        public readonly kind: string = SelectFeedbackCommand.KIND
-    ) {}
+export interface SelectFeedbackAction extends Omit<SelectAction, 'kind'>, Action {
+    kind: typeof SelectFeedbackAction.KIND;
 }
 
-export class SelectAllFeedbackAction {
-    /**
-     * If `select` is true, all elements are selected, othewise they are deselected.
-     */
-    constructor(public readonly select: boolean = true, public readonly kind: string = SelectFeedbackCommand.KIND) {}
-}
+export namespace SelectFeedbackAction {
+    export const KIND = 'selectFeedback';
+
+    export function is(object: any): object is SelectFeedbackAction {
+        return Action.hasKind(object, KIND) && hasArrayProp(object, 'selectedElementsIDs') && hasArrayProp(object, 'deselectedElementsIDs');
+    }
 
+    export function create(options?: { selectedElementsIDs?: string[]; deselectedElementsIDs?: string[] }): SelectFeedbackAction {
+        return { ...SelectAction.create(options), kind: KIND };
+    }
+}
 @injectable()
 export class SelectFeedbackCommand extends Command {
-    static readonly KIND = 'elementSelectedFeedback';
+    static readonly KIND = SelectFeedbackAction.KIND;
     private sprottySelectCommand: SprottySelectCommand;
 
     constructor(@inject(TYPES.Action) public action: SelectFeedbackAction) {
         super();
-        this.sprottySelectCommand = new SprottySelectCommand(action);
+        this.sprottySelectCommand = new SprottySelectCommand({ ...action, kind: SelectAction.KIND });
     }
 
     execute(context: CommandExecutionContext): SModelRoot {
@@ -60,26 +55,3 @@ export class SelectFeedbackCommand extends Command {
         return this.sprottySelectCommand.redo(context);
     }
 }
-
-@injectable()
-export class SelectAllFeedbackCommand extends Command {
-    static readonly KIND = 'allSelectedFeedback';
-    private sprottySelectAllCommand: SprottySelectAllCommand;
-
-    constructor(@inject(TYPES.Action) public action: SelectAllFeedbackAction) {
-        super();
-        this.sprottySelectAllCommand = new SprottySelectAllCommand(action);
-    }
-
-    execute(context: CommandExecutionContext): SModelRoot {
-        return this.sprottySelectAllCommand.execute(context);
-    }
-
-    undo(context: CommandExecutionContext): SModelRoot {
-        return this.sprottySelectAllCommand.undo(context);
-    }
-
-    redo(context: CommandExecutionContext): SModelRoot {
-        return this.sprottySelectAllCommand.redo(context);
-    }
-}

package/src/features/select/select-mouse-listener.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2019 EclipseSource and others.
+ * Copyright (c) 2019-2022 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,7 +14,6 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 import { SelectMouseListener } from 'sprotty';
-
 import { DEFAULT_RANK, Ranked } from '../rank/model';
 
 /**

package/src/features/select/selection-service.spec.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2020-2021 EclipseSource and others.
+ * Copyright (c) 2020-2022 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,11 +14,11 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 /* eslint-disable import/no-deprecated,no-unused-expressions */
-import { Action } from '@eclipse-glsp/protocol';
+import { Action, SModelElementSchema } from '@eclipse-glsp/protocol';
 import { AssertionError, expect } from 'chai';
 import { Container, injectable } from 'inversify';
-import { defaultModule, SGraphFactory, SModelElementSchema, SModelRoot, TYPES } from 'sprotty';
-import { GLSP_TYPES } from '../../base/types';
+import { defaultModule, SGraphFactory, SModelRoot } from 'sprotty';
+import { TYPES } from '../../base/types';
 import { IFeedbackActionDispatcher, IFeedbackEmitter } from '../tool-feedback/feedback-action-dispatcher';
 import { SelectFeedbackAction } from './select-feedback-action';
 import { SelectionListener, SelectionService } from './selection-service';
@@ -74,14 +74,16 @@ class MockSelectionListener implements SelectionListener {
 function createContainer(): Container {
     const container = new Container();
     container.load(defaultModule);
+    // eslint-disable-next-line deprecation/deprecation
     container.rebind(TYPES.IModelFactory).to(SGraphFactory).inSingletonScope();
-    container.bind(GLSP_TYPES.IFeedbackActionDispatcher).to(MockFeedbackActionDispatcher).inSingletonScope();
+    container.bind(TYPES.IFeedbackActionDispatcher).to(MockFeedbackActionDispatcher).inSingletonScope();
     container.bind(SelectionService).toSelf().inSingletonScope();
-    container.bind(GLSP_TYPES.SelectionService).toService(SelectionService);
+    container.bind(TYPES.SelectionService).toService(SelectionService);
     return container;
 }
 
 describe('SelectionService', () => {
+    // eslint-disable-next-line deprecation/deprecation
     let graphFactory: SGraphFactory;
     let root: SModelRoot;
     let selectionService: SelectionService;
@@ -89,10 +91,11 @@ describe('SelectionService', () => {
 
     beforeEach(() => {
         const container = createContainer();
+        // eslint-disable-next-line deprecation/deprecation
         graphFactory = container.get<SGraphFactory>(TYPES.IModelFactory);
         root = createRoot('node1', 'node2', 'node3', 'node4', 'node5');
-        selectionService = container.get<SelectionService>(GLSP_TYPES.SelectionService);
-        feedbackDispatcher = container.get<MockFeedbackActionDispatcher>(GLSP_TYPES.IFeedbackActionDispatcher);
+        selectionService = container.get<SelectionService>(TYPES.SelectionService);
+        feedbackDispatcher = container.get<MockFeedbackActionDispatcher>(TYPES.IFeedbackActionDispatcher);
     });
 
     describe('Initial State', () => {

package/src/features/select/selection-service.ts

@@ -26,12 +26,11 @@ import {
     SelectCommand as SprottySelectCommand,
     SModelElement,
     SModelRoot,
-    SParentElement,
-    TYPES
+    SParentElement
 } from 'sprotty';
 import { SModelRootListener } from '../../base/model/update-model-command';
-import { GLSP_TYPES } from '../../base/types';
-import { getMatchingElements } from '../../utils/smodel-util';
+import { TYPES } from '../../base/types';
+import { getElements } from '../../utils/smodel-util';
 import { IFeedbackActionDispatcher } from '../tool-feedback/feedback-action-dispatcher';
 import { SelectFeedbackAction } from './select-feedback-action';
 
@@ -44,10 +43,10 @@ export class SelectionService implements SModelRootListener {
     private root: Readonly<SModelRoot>;
     private selectedElementIDs: Set<string> = new Set();
 
-    @inject(GLSP_TYPES.IFeedbackActionDispatcher) protected feedbackDispatcher: IFeedbackActionDispatcher;
+    @inject(TYPES.IFeedbackActionDispatcher) protected feedbackDispatcher: IFeedbackActionDispatcher;
     @inject(TYPES.ILogger) protected logger: ILogger;
 
-    constructor(@multiInject(GLSP_TYPES.SelectionListener) @optional() protected selectionListeners: SelectionListener[] = []) {}
+    constructor(@multiInject(TYPES.SelectionListener) @optional() protected selectionListeners: SelectionListener[] = []) {}
 
     register(selectionListener: SelectionListener): void {
         distinctAdd(this.selectionListeners, selectionListener);
@@ -101,7 +100,12 @@ export class SelectionService implements SModelRootListener {
             ![...prevSelectedElementIDs].every(value => this.selectedElementIDs.has(value));
         if (selectionChanged) {
             // aggregate to feedback action handling all elements as only the last feedback is restored
-            this.dispatchFeedback([new SelectFeedbackAction([...this.selectedElementIDs], [...deselectedElementIDs])]);
+            this.dispatchFeedback([
+                SelectFeedbackAction.create({
+                    selectedElementsIDs: [...this.selectedElementIDs],
+                    deselectedElementsIDs: [...deselectedElementIDs]
+                })
+            ]);
         }
 
         const rootChanged = prevRoot !== root;
@@ -124,7 +128,7 @@ export class SelectionService implements SModelRootListener {
     }
 
     getSelectedElements(): Readonly<SModelElement & Selectable>[] {
-        return getMatchingElements(this.root.index, isSelectable);
+        return getElements(this.root.index, Array.from(this.selectedElementIDs), isSelectable);
     }
 
     /**
@@ -157,7 +161,7 @@ export class SelectCommand extends Command {
 
     constructor(
         @inject(TYPES.Action) public action: SelectAction,
-        @inject(GLSP_TYPES.SelectionService) public selectionService: SelectionService
+        @inject(TYPES.SelectionService) public selectionService: SelectionService
     ) {
         super();
     }
@@ -201,7 +205,7 @@ export class SelectAllCommand extends Command {
 
     constructor(
         @inject(TYPES.Action) public action: SelectAllAction,
-        @inject(GLSP_TYPES.SelectionService) public selectionService: SelectionService
+        @inject(TYPES.SelectionService) public selectionService: SelectionService
     ) {
         super();
     }

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

@@ -13,7 +13,7 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { Action, Point } from '@eclipse-glsp/protocol';
+import { Action, hasStringProp, Point } from '@eclipse-glsp/protocol';
 import { inject, injectable } from 'inversify';
 import { VNode } from 'snabbdom';
 import {
@@ -31,24 +31,53 @@ import {
     SModelRoot,
     TYPES
 } from 'sprotty';
-import { forEachElement, isNotUndefined } from '../../utils/smodel-util';
+import { forEachElement } from '../../utils/smodel-util';
 import { addResizeHandles, isResizable, removeResizeHandles, SResizeHandle } from '../change-bounds/model';
 import { createMovementRestrictionFeedback, removeMovementRestrictionFeedback } from '../change-bounds/movement-restrictor';
 import { CursorCSS, cursorFeedbackAction } from '../tool-feedback/css-feedback';
 import { ChangeBoundsTool } from '../tools/change-bounds-tool';
 import { FeedbackCommand } from './model';
 
-export class ShowChangeBoundsToolResizeFeedbackAction implements Action {
-    constructor(readonly elementId?: string, public readonly kind: string = ShowChangeBoundsToolResizeFeedbackCommand.KIND) {}
+export interface ShowChangeBoundsToolResizeFeedbackAction extends Action {
+    kind: typeof ShowChangeBoundsToolResizeFeedbackAction.KIND;
+
+    elementId: string;
+}
+
+export namespace ShowChangeBoundsToolResizeFeedbackAction {
+    export const KIND = 'showChangeBoundsToolResizeFeedback';
+
+    export function is(object: any): object is ShowChangeBoundsToolResizeFeedbackAction {
+        return Action.hasKind(object, KIND) && hasStringProp(object, 'elementId');
+    }
+
+    export function create(elementId: string): ShowChangeBoundsToolResizeFeedbackAction {
+        return {
+            kind: KIND,
+            elementId
+        };
+    }
+}
+
+export interface HideChangeBoundsToolResizeFeedbackAction extends Action {
+    kind: typeof HideChangeBoundsToolResizeFeedbackAction.KIND;
 }
 
-export class HideChangeBoundsToolResizeFeedbackAction implements Action {
-    constructor(public readonly kind: string = HideChangeBoundsToolResizeFeedbackCommand.KIND) {}
+export namespace HideChangeBoundsToolResizeFeedbackAction {
+    export const KIND = 'hideChangeBoundsToolResizeFeedback';
+
+    export function is(object: any): object is HideChangeBoundsToolResizeFeedbackAction {
+        return Action.hasKind(object, KIND);
+    }
+
+    export function create(): HideChangeBoundsToolResizeFeedbackAction {
+        return { kind: KIND };
+    }
 }
 
 @injectable()
 export class ShowChangeBoundsToolResizeFeedbackCommand extends FeedbackCommand {
-    static readonly KIND = 'showChangeBoundsToolResizeFeedback';
+    static readonly KIND = ShowChangeBoundsToolResizeFeedbackAction.KIND;
 
     @inject(TYPES.Action) protected action: ShowChangeBoundsToolResizeFeedbackAction;
 
@@ -57,9 +86,9 @@ export class ShowChangeBoundsToolResizeFeedbackCommand extends FeedbackCommand {
 
         forEachElement(index, isResizable, removeResizeHandles);
 
-        if (isNotUndefined(this.action.elementId)) {
+        if (this.action.elementId) {
             const resizeElement = index.getById(this.action.elementId);
-            if (isNotUndefined(resizeElement) && isResizable(resizeElement)) {
+            if (resizeElement && isResizable(resizeElement)) {
                 addResizeHandles(resizeElement);
             }
         }
@@ -69,7 +98,7 @@ export class ShowChangeBoundsToolResizeFeedbackCommand extends FeedbackCommand {
 
 @injectable()
 export class HideChangeBoundsToolResizeFeedbackCommand extends FeedbackCommand {
-    static readonly KIND = 'hideChangeBoundsToolResizeFeedback';
+    static readonly KIND = HideChangeBoundsToolResizeFeedbackAction.KIND;
 
     @inject(TYPES.Action) protected action: HideChangeBoundsToolResizeFeedbackAction;
 
@@ -149,7 +178,7 @@ export class FeedbackMoveMouseListener extends MouseListener {
         return false;
     }
 
-    protected getElementMoves(target: SModelElement, event: MouseEvent, isFinished: boolean): MoveAction | undefined {
+    protected getElementMoves(target: SModelElement, event: MouseEvent, finished: boolean): MoveAction | undefined {
         if (!this.startDragPosition) {
             return undefined;
         }
@@ -173,7 +202,7 @@ export class FeedbackMoveMouseListener extends MouseListener {
                 );
 
                 if (isMoveable(element)) {
-                    toPosition = this.validateMove(startPosition, toPosition, element, isFinished);
+                    toPosition = this.validateMove(startPosition, toPosition, element, finished);
                     elementMoves.push({
                         elementId: element.id,
                         fromPosition: {
@@ -186,7 +215,7 @@ export class FeedbackMoveMouseListener extends MouseListener {
             }
         });
         if (elementMoves.length > 0) {
-            return new MoveAction(elementMoves, false, isFinished);
+            return MoveAction.create(elementMoves, { animate: false, finished });
         } else {
             return undefined;
         }

package/src/features/tool-feedback/creation-tool-feedback.ts

@@ -13,15 +13,12 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { Action, Point } from '@eclipse-glsp/protocol';
+import { Action, Bounds, Point } from '@eclipse-glsp/protocol';
 import { inject, injectable } from 'inversify';
 import {
-    add,
     AnchorComputerRegistry,
-    center,
     CommandExecutionContext,
     CommandReturn,
-    euclideanDistance,
     findChildrenAtPosition,
     findParentByFeature,
     isBoundsAware,
@@ -32,7 +29,7 @@ import {
     SChildElement,
     SConnectableElement,
     SDanglingAnchor,
-    SEdgeSchema,
+    SEdge as SEdgeSchema,
     SModelElement,
     SModelRoot,
     SRoutableElement,
@@ -41,19 +38,31 @@ import {
 import { BoundsAwareModelElement, isRoutable } from '../../utils/smodel-util';
 import { getAbsolutePosition, toAbsoluteBounds, toAbsolutePosition } from '../../utils/viewpoint-util';
 import { FeedbackCommand } from './model';
+export interface DrawFeedbackEdgeAction extends Action {
+    kind: typeof DrawFeedbackEdgeAction.KIND;
+    elementTypeId: string;
+    sourceId: string;
+    edgeSchema?: SEdgeSchema;
+}
 
-export class DrawFeedbackEdgeAction implements Action {
-    constructor(
-        public readonly elementTypeId: string,
-        public readonly sourceId: string,
-        public readonly edgeSchema?: SEdgeSchema,
-        public readonly kind: string = DrawFeedbackEdgeCommand.KIND
-    ) {}
+export namespace DrawFeedbackEdgeAction {
+    export const KIND = 'drawFeedbackEdge';
+
+    export function is(object: any): object is DrawFeedbackEdgeAction {
+        return Action.hasKind(object, KIND);
+    }
+
+    export function create(options: { elementTypeId: string; sourceId: string; edgeSchema?: SEdgeSchema }): DrawFeedbackEdgeAction {
+        return {
+            kind: KIND,
+            ...options
+        };
+    }
 }
 
 @injectable()
 export class DrawFeedbackEdgeCommand extends FeedbackCommand {
-    static readonly KIND = 'drawFeedbackEdge';
+    static readonly KIND = DrawFeedbackEdgeAction.KIND;
 
     constructor(@inject(TYPES.Action) protected action: DrawFeedbackEdgeAction) {
         super();
@@ -66,13 +75,25 @@ export class DrawFeedbackEdgeCommand extends FeedbackCommand {
     }
 }
 
-export class RemoveFeedbackEdgeAction implements Action {
-    constructor(public readonly kind: string = RemoveFeedbackEdgeCommand.KIND) {}
+export interface RemoveFeedbackEdgeAction extends Action {
+    kind: typeof RemoveFeedbackEdgeAction.KIND;
+}
+
+export namespace RemoveFeedbackEdgeAction {
+    export const KIND = 'removeFeedbackEdgeCommand';
+
+    export function is(object: any): object is RemoveFeedbackEdgeAction {
+        return Action.hasKind(object, KIND);
+    }
+
+    export function create(): RemoveFeedbackEdgeAction {
+        return { kind: KIND };
+    }
 }
 
 @injectable()
 export class RemoveFeedbackEdgeCommand extends FeedbackCommand {
-    static readonly KIND = 'removeFeedbackEdgeCommand';
+    static readonly KIND = RemoveFeedbackEdgeAction.KIND;
 
     execute(context: CommandExecutionContext): CommandReturn {
         removeFeedbackEdge(context.root);
@@ -111,12 +132,12 @@ export class FeedbackEdgeEndMovingMouseListener extends MouseListener {
             .find(element => isConnectable(element) && element.canConnect(edge, 'target'));
 
         if (endAtMousePosition instanceof SConnectableElement && edge.source && isBoundsAware(edge.source)) {
-            const anchor = this.computeAbsoluteAnchor(endAtMousePosition, center(toAbsoluteBounds(edge.source)));
-            if (euclideanDistance(anchor, edgeEnd.position) > 1) {
-                return [new MoveAction([{ elementId: edgeEnd.id, toPosition: anchor }], false)];
+            const anchor = this.computeAbsoluteAnchor(endAtMousePosition, Bounds.center(toAbsoluteBounds(edge.source)));
+            if (Point.euclideanDistance(anchor, edgeEnd.position) > 1) {
+                return [MoveAction.create([{ elementId: edgeEnd.id, toPosition: anchor }], { animate: false })];
             }
         } else {
-            return [new MoveAction([{ elementId: edgeEnd.id, toPosition: position }], false)];
+            return [MoveAction.create([{ elementId: edgeEnd.id, toPosition: position }], { animate: false })];
         }
 
         return [];
@@ -132,7 +153,7 @@ export class FeedbackEdgeEndMovingMouseListener extends MouseListener {
             const parent = findParentByFeature(element.parent, isBoundsAware);
             if (parent) {
                 const absoluteParentPosition = toAbsoluteBounds(parent);
-                anchor = add(absoluteParentPosition, anchor);
+                anchor = Point.add(absoluteParentPosition, anchor);
             }
         }
         return anchor;