@eclipse-glsp/client 0.9.0-next.d9bed812 → 0.9.0-next.eb280175

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

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2020 EclipseSource and others.
+ * Copyright (c) 2020-2021 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,18 +13,19 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { AssertionError, expect } from "chai";
-import { Container, injectable } from "inversify";
-import { Action, defaultModule, SGraphFactory, SModelElementSchema, SModelRoot, TYPES } from "sprotty";
-
-import { GLSP_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";
+/* eslint-disable import/no-deprecated,no-unused-expressions */
+import { Action } 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 { IFeedbackActionDispatcher, IFeedbackEmitter } from '../tool-feedback/feedback-action-dispatcher';
+import { SelectFeedbackAction } from './select-feedback-action';
+import { SelectionListener, SelectionService } from './selection-service';
 
 @injectable()
 class MockFeedbackActionDispatcher implements IFeedbackActionDispatcher {
-    protected feedbackEmitters: Map<IFeedbackEmitter, Action[]> = new Map;
+    protected feedbackEmitters: Map<IFeedbackEmitter, Action[]> = new Map();
 
     registerFeedback(feedbackEmitter: IFeedbackEmitter, actions: Action[]): void {
         this.feedbackEmitters.set(feedbackEmitter, actions);
@@ -42,12 +43,12 @@ class MockFeedbackActionDispatcher implements IFeedbackActionDispatcher {
 
     getSingleFeedbackAction(): SelectFeedbackAction | undefined {
         const actions = this.getRegisteredFeedback();
-        return actions.length === 1 ? actions[0] as SelectFeedbackAction : undefined;
+        return actions.length === 1 ? (actions[0] as SelectFeedbackAction) : undefined;
     }
 }
 
 class MockSelectionListener implements SelectionListener {
-    private called: number = 0;
+    private called = 0;
     private root: SModelRoot;
     private selectedElements: string[] = [];
 
@@ -57,15 +58,15 @@ class MockSelectionListener implements SelectionListener {
         this.selectedElements = selectedElements;
     }
 
-    getRoot() {
+    getRoot(): SModelRoot {
         return this.root;
     }
 
-    getSelectedElements() {
+    getSelectedElements(): string[] {
         return this.selectedElements;
     }
 
-    getCalled() {
+    getCalled(): number {
         return this.called;
     }
 }
@@ -332,12 +333,12 @@ describe('SelectionService', () => {
         });
     }
 
-    function assertSelectionAndFeedback(expectedSelection: string[], expectedDeselection: string[]) {
+    function assertSelectionAndFeedback(expectedSelection: string[], expectedDeselection: string[]): void {
         assertSelectionService(expectedSelection);
         assertDispatchedFeedback(expectedSelection, expectedDeselection);
     }
 
-    function assertSelectionService(expectedSelection: string[]) {
+    function assertSelectionService(expectedSelection: string[]): void {
         expect(selectionService.isSingleSelection()).to.equal(expectedSelection.length === 1);
         expect(selectionService.isMultiSelection()).to.equal(expectedSelection.length > 1);
         expect(selectionService.hasSelectedElements()).to.equal(expectedSelection.length > 0);
@@ -347,7 +348,7 @@ describe('SelectionService', () => {
         }
     }
 
-    function assertDispatchedFeedback(expectedSelection: string[], expectedDeselection: string[]) {
+    function assertDispatchedFeedback(expectedSelection: string[], expectedDeselection: string[]): void {
         // a single feedback action reflects aggregated selection/deselection
         const hasFeedback = expectedSelection.length > 0 || expectedDeselection.length > 0;
         if (hasFeedback) {
@@ -362,7 +363,12 @@ describe('SelectionService', () => {
         }
     }
 
-    function assertListener(listener: MockSelectionListener, expectedRoot: SModelRoot | undefined, expectedSelection: string[], expectedCalled: number) {
+    function assertListener(
+        listener: MockSelectionListener,
+        expectedRoot: SModelRoot | undefined,
+        expectedSelection: string[],
+        expectedCalled: number
+    ): void {
         expect(listener.getRoot()).to.equal(expectedRoot);
         expect(listener.getSelectedElements()).to.have.lengthOf(expectedSelection.length);
         expect(listener.getSelectedElements()).to.have.ordered.members(expectedSelection);

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

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2019-2020 EclipseSource and others.
+ * Copyright (c) 2019-2021 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,30 +13,26 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { inject, injectable, multiInject, optional } from "inversify";
+import { Action, distinctAdd, remove, SelectAction, SelectAllAction } from '@eclipse-glsp/protocol';
+import { inject, injectable, multiInject, optional } from 'inversify';
 import {
-    Action,
     Command,
     CommandExecutionContext,
     ILogger,
     isSelectable,
     isSelected,
     SChildElement,
-    SelectAction,
-    SelectAllAction,
     SelectAllCommand as SprottySelectAllCommand,
     SelectCommand as SprottySelectCommand,
     SModelElement,
     SModelRoot,
     SParentElement,
     TYPES
-} from "sprotty";
-
-import { SModelRootListener } from "../../base/model/update-model-command";
-import { GLSP_TYPES } from "../../base/types";
-import { distinctAdd, remove } from "../../utils/array-utils";
-import { IFeedbackActionDispatcher } from "../tool-feedback/feedback-action-dispatcher";
-import { SelectFeedbackAction } from "./select-feedback-action";
+} from 'sprotty';
+import { SModelRootListener } from '../../base/model/update-model-command';
+import { GLSP_TYPES } from '../../base/types';
+import { IFeedbackActionDispatcher } from '../tool-feedback/feedback-action-dispatcher';
+import { SelectFeedbackAction } from './select-feedback-action';
 
 export interface SelectionListener {
     selectionChanged(root: Readonly<SModelRoot>, selectedElements: string[]): void;
@@ -50,13 +46,13 @@ export class SelectionService implements SModelRootListener {
     @inject(GLSP_TYPES.IFeedbackActionDispatcher) protected feedbackDispatcher: IFeedbackActionDispatcher;
     @inject(TYPES.ILogger) protected logger: ILogger;
 
-    constructor(@multiInject(GLSP_TYPES.SelectionListener) @optional() protected selectionListeners: SelectionListener[] = []) { }
+    constructor(@multiInject(GLSP_TYPES.SelectionListener) @optional() protected selectionListeners: SelectionListener[] = []) {}
 
-    register(selectionListener: SelectionListener) {
+    register(selectionListener: SelectionListener): void {
         distinctAdd(this.selectionListeners, selectionListener);
     }
 
-    deregister(selectionListener: SelectionListener) {
+    deregister(selectionListener: SelectionListener): void {
         remove(this.selectionListeners, selectionListener);
     }
 
@@ -64,7 +60,7 @@ export class SelectionService implements SModelRootListener {
         this.updateSelection(root, [], []);
     }
 
-    updateSelection(root: Readonly<SModelRoot>, select: string[], deselect: string[]) {
+    updateSelection(root: Readonly<SModelRoot>, select: string[], deselect: string[]): void {
         if (root === undefined && select.length === 0 && deselect.length === 0) {
             return;
         }
@@ -99,7 +95,9 @@ export class SelectionService implements SModelRootListener {
         }
 
         // only send out changes if there actually are changes, i.e., the root or the selected elements changed
-        const selectionChanged = prevSelectedElementIDs.size !== this.selectedElementIDs.size || ![...prevSelectedElementIDs].every(value => this.selectedElementIDs.has(value));
+        const selectionChanged =
+            prevSelectedElementIDs.size !== this.selectedElementIDs.size ||
+            ![...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])]);
@@ -112,11 +110,11 @@ export class SelectionService implements SModelRootListener {
         }
     }
 
-    dispatchFeedback(actions: Action[]) {
+    dispatchFeedback(actions: Action[]): void {
         this.feedbackDispatcher.registerFeedback(this, actions);
     }
 
-    notifyListeners(root: SModelRoot, selectedElementIDs: Set<string>) {
+    notifyListeners(root: SModelRoot, selectedElementIDs: Set<string>): void {
         this.selectionListeners.forEach(listener => listener.selectionChanged(root, Array.from(selectedElementIDs)));
     }
 
@@ -149,7 +147,6 @@ export class SelectionService implements SModelRootListener {
     }
 }
 
-
 @injectable()
 export class SelectCommand extends Command {
     static readonly KIND = SprottySelectCommand.KIND;
@@ -157,7 +154,10 @@ export class SelectCommand extends Command {
     protected selected: SModelElement[] = [];
     protected deselected: SModelElement[] = [];
 
-    constructor(@inject(TYPES.Action) public action: SelectAction, @inject(GLSP_TYPES.SelectionService) public selectionService: SelectionService) {
+    constructor(
+        @inject(TYPES.Action) public action: SelectAction,
+        @inject(GLSP_TYPES.SelectionService) public selectionService: SelectionService
+    ) {
         super();
     }
 
@@ -198,7 +198,10 @@ export class SelectAllCommand extends Command {
     static readonly KIND = SprottySelectAllCommand.KIND;
     protected previousSelection: Map<string, boolean> = new Map<string, boolean>();
 
-    constructor(@inject(TYPES.Action) public action: SelectAllAction, @inject(GLSP_TYPES.SelectionService) public selectionService: SelectionService) {
+    constructor(
+        @inject(TYPES.Action) public action: SelectAllAction,
+        @inject(GLSP_TYPES.SelectionService) public selectionService: SelectionService
+    ) {
         super();
     }
 

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

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2019 EclipseSource and others.
+ * Copyright (c) 2019-2021 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,10 +13,10 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { inject, injectable } from "inversify";
-import { VNode } from "snabbdom/vnode";
+import { Action, Point } from '@eclipse-glsp/protocol';
+import { inject, injectable } from 'inversify';
+import { VNode } from 'snabbdom';
 import {
-    Action,
     CommandExecutionContext,
     CommandReturn,
     ElementMove,
@@ -26,38 +26,35 @@ import {
     isViewport,
     MouseListener,
     MoveAction,
-    Point,
+    SChildElement,
     SModelElement,
     SModelRoot,
     TYPES
-} from "sprotty";
-
-import { isNotUndefined } from "../../utils/smodel-util";
-import { addResizeHandles, isResizable, removeResizeHandles, SResizeHandle } from "../change-bounds/model";
-import { createMovementRestrictionFeedback, removeMovementRestrictionFeedback } from "../change-bounds/movement-restrictor";
-import { ChangeBoundsTool } from "../tools/change-bounds-tool";
-import { FeedbackCommand } from "./model";
+} from 'sprotty';
+import { isNotUndefined } 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) { }
+    constructor(readonly elementId?: string, public readonly kind: string = ShowChangeBoundsToolResizeFeedbackCommand.KIND) {}
 }
 
 export class HideChangeBoundsToolResizeFeedbackAction implements Action {
-    constructor(public readonly kind: string = HideChangeBoundsToolResizeFeedbackCommand.KIND) { }
+    constructor(public readonly kind: string = HideChangeBoundsToolResizeFeedbackCommand.KIND) {}
 }
 
 @injectable()
 export class ShowChangeBoundsToolResizeFeedbackCommand extends FeedbackCommand {
-    static readonly KIND = "showChangeBoundsToolResizeFeedback";
+    static readonly KIND = 'showChangeBoundsToolResizeFeedback';
 
     @inject(TYPES.Action) protected action: ShowChangeBoundsToolResizeFeedbackAction;
 
     execute(context: CommandExecutionContext): CommandReturn {
         const index = context.root.index;
-        index
-            .all()
-            .filter(isResizable)
-            .forEach(removeResizeHandles);
+        index.all().filter(isResizable).forEach(removeResizeHandles);
 
         if (isNotUndefined(this.action.elementId)) {
             const resizeElement = index.getById(this.action.elementId);
@@ -71,16 +68,13 @@ export class ShowChangeBoundsToolResizeFeedbackCommand extends FeedbackCommand {
 
 @injectable()
 export class HideChangeBoundsToolResizeFeedbackCommand extends FeedbackCommand {
-    static readonly KIND = "hideChangeBoundsToolResizeFeedback";
+    static readonly KIND = 'hideChangeBoundsToolResizeFeedback';
 
     @inject(TYPES.Action) protected action: HideChangeBoundsToolResizeFeedbackAction;
 
     execute(context: CommandExecutionContext): CommandReturn {
         const index = context.root.index;
-        index
-            .all()
-            .filter(isResizable)
-            .forEach(removeResizeHandles);
+        index.all().filter(isResizable).forEach(removeResizeHandles);
         return context.root;
     }
 }
@@ -116,22 +110,27 @@ export class FeedbackMoveMouseListener extends MouseListener {
 
     mouseMove(target: SModelElement, event: MouseEvent): Action[] {
         const result: Action[] = [];
-        if (event.buttons === 0) this.mouseUp(target, event);
-        else if (this.startDragPosition) {
+        if (event.buttons === 0) {
+            this.mouseUp(target, event);
+        } else if (this.startDragPosition) {
             if (this.elementId2startPos.size === 0) {
                 this.collectStartPositions(target.root);
             }
             this.hasDragged = true;
             const moveAction = this.getElementMoves(target, event, false);
-            if (moveAction) result.push(moveAction);
+            if (moveAction) {
+                result.push(moveAction);
+                result.push(cursorFeedbackAction(CursorCSS.MOVE));
+            }
         }
         return result;
     }
 
-    protected collectStartPositions(root: SModelRoot) {
-        root.index
-            .all()
-            .filter(element => isSelectable(element) && element.selected)
+    protected collectStartPositions(root: SModelRoot): void {
+        const selectedElements = root.index.all().filter(element => isSelectable(element) && element.selected);
+        const elementsSet = new Set(selectedElements);
+        selectedElements
+            .filter(element => !this.isChildOfSelected(elementsSet, element))
             .forEach(element => {
                 if (isMoveable(element)) {
                     this.elementId2startPos.set(element.id, element.position);
@@ -139,8 +138,20 @@ export class FeedbackMoveMouseListener extends MouseListener {
             });
     }
 
+    protected isChildOfSelected(selectedElements: Set<SModelElement>, element: SModelElement): boolean {
+        while (element instanceof SChildElement) {
+            element = element.parent;
+            if (selectedElements.has(element)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
     protected getElementMoves(target: SModelElement, event: MouseEvent, isFinished: boolean): MoveAction | undefined {
-        if (!this.startDragPosition) return undefined;
+        if (!this.startDragPosition) {
+            return undefined;
+        }
         const elementMoves: ElementMove[] = [];
         const viewport = findParentByFeature(target, isViewport);
         const zoom = viewport ? viewport.zoom : 1;
@@ -173,12 +184,14 @@ export class FeedbackMoveMouseListener extends MouseListener {
                 }
             }
         });
-        if (elementMoves.length > 0)
+        if (elementMoves.length > 0) {
             return new MoveAction(elementMoves, false, isFinished);
-        else return undefined;
+        } else {
+            return undefined;
+        }
     }
 
-    protected validateMove(startPostion: Point, toPosition: Point, element: SModelElement, isFinished: boolean) {
+    protected validateMove(startPostion: Point, toPosition: Point, element: SModelElement, isFinished: boolean): Point {
         let newPosition = toPosition;
         if (this.tool.movementRestrictor) {
             const valid = this.tool.movementRestrictor.validate(toPosition, element);
@@ -199,13 +212,17 @@ export class FeedbackMoveMouseListener extends MouseListener {
     }
 
     protected snap(position: Point, element: SModelElement, isSnap: boolean): Point {
-        if (isSnap && this.tool.snapper) return this.tool.snapper.snap(position, element);
-        else return position;
+        if (isSnap && this.tool.snapper) {
+            return this.tool.snapper.snap(position, element);
+        } else {
+            return position;
+        }
     }
 
     mouseEnter(target: SModelElement, event: MouseEvent): Action[] {
-        if (target instanceof SModelRoot && event.buttons === 0)
+        if (target instanceof SModelRoot && event.buttons === 0 && !this.startDragPosition) {
             this.mouseUp(target, event);
+        }
         return [];
     }
 
@@ -219,7 +236,7 @@ export class FeedbackMoveMouseListener extends MouseListener {
             if (this.tool.movementRestrictor) {
                 this.tool.deregisterFeedback([removeMovementRestrictionFeedback(target, this.tool.movementRestrictor)], this);
             }
-
+            result.push(cursorFeedbackAction(CursorCSS.DEFAULT));
         }
         this.hasDragged = false;
         this.startDragPosition = undefined;

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

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2019 EclipseSource and others.
+ * Copyright (c) 2019-2021 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,9 +13,10 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { inject, injectable } from "inversify";
+import { Action, Point } from '@eclipse-glsp/protocol';
+import { inject, injectable } from 'inversify';
 import {
-    Action,
+    add,
     AnchorComputerRegistry,
     center,
     CommandExecutionContext,
@@ -36,18 +37,18 @@ import {
     SModelRoot,
     SRoutableElement,
     TYPES
-} from "sprotty";
-
-import { isRoutable } from "../../utils/smodel-util";
-import { getAbsolutePosition, toAbsolutePosition } from "../../utils/viewpoint-util";
-import { FeedbackCommand } from "./model";
+} from 'sprotty';
+import { isRoutable } from '../../utils/smodel-util';
+import { getAbsolutePosition, toAbsoluteBounds, toAbsolutePosition } from '../../utils/viewpoint-util';
+import { FeedbackCommand } from './model';
 
 export class DrawFeedbackEdgeAction implements Action {
     constructor(
         public readonly elementTypeId: string,
         public readonly sourceId: string,
         public readonly edgeSchema?: SEdgeSchema,
-        public readonly kind: string = DrawFeedbackEdgeCommand.KIND) { }
+        public readonly kind: string = DrawFeedbackEdgeCommand.KIND
+    ) {}
 }
 
 @injectable()
@@ -66,7 +67,7 @@ export class DrawFeedbackEdgeCommand extends FeedbackCommand {
 }
 
 export class RemoveFeedbackEdgeAction implements Action {
-    constructor(public readonly kind: string = RemoveFeedbackEdgeCommand.KIND) { }
+    constructor(public readonly kind: string = RemoveFeedbackEdgeCommand.KIND) {}
 }
 
 @injectable()
@@ -81,10 +82,12 @@ export class RemoveFeedbackEdgeCommand extends FeedbackCommand {
 
 export class FeedbackEdgeEnd extends SDanglingAnchor {
     static readonly TYPE = 'feedback-edge-end';
-    constructor(readonly sourceId: string,
+    constructor(
+        readonly sourceId: string,
         readonly elementTypeId: string,
         public feedbackEdge: SRoutableElement | undefined = undefined,
-        public readonly type: string = FeedbackEdgeEnd.TYPE) {
+        public readonly type: string = FeedbackEdgeEnd.TYPE
+    ) {
         super();
     }
 }
@@ -103,12 +106,12 @@ export class FeedbackEdgeEndMovingMouseListener extends MouseListener {
 
         const edge = edgeEnd.feedbackEdge;
         const position = getAbsolutePosition(edgeEnd, event);
-        const endAtMousePosition = findChildrenAtPosition(target.root, position)
-            .find(element => isConnectable(element) && element.canConnect(edge, 'target'));
+        const endAtMousePosition = findChildrenAtPosition(target.root, position).find(
+            element => isConnectable(element) && element.canConnect(edge, 'target')
+        );
 
         if (endAtMousePosition instanceof SConnectableElement && edge.source && isBoundsAware(edge.source)) {
-            const anchorComputer = this.anchorRegistry.get(PolylineEdgeRouter.KIND, endAtMousePosition.anchorKind);
-            const anchor = anchorComputer.getAnchor(endAtMousePosition, center(edge.source.bounds));
+            const anchor = this.computeAbsoluteAnchor(endAtMousePosition, center(edge.source.bounds));
             if (euclideanDistance(anchor, edgeEnd.position) > 1) {
                 return [new MoveAction([{ elementId: edgeEnd.id, toPosition: anchor }], false)];
             }
@@ -118,6 +121,21 @@ export class FeedbackEdgeEndMovingMouseListener extends MouseListener {
 
         return [];
     }
+
+    protected computeAbsoluteAnchor(element: SConnectableElement, referencePoint: Point, offset?: number): Point {
+        const anchorComputer = this.anchorRegistry.get(PolylineEdgeRouter.KIND, element.anchorKind);
+        let anchor = anchorComputer.getAnchor(element, referencePoint, offset);
+        // The anchor is computed in the local coordinate system of the element.
+        // If the element is a nested child element we have to add the absolute position of its parent to the anchor.
+        if (element.parent !== element.root) {
+            const parent = findParentByFeature(element.parent, isBoundsAware);
+            if (parent) {
+                const absoluteParentPosition = toAbsoluteBounds(parent);
+                anchor = add(absoluteParentPosition, anchor);
+            }
+        }
+        return anchor;
+    }
 }
 
 export function feedbackEdgeId(root: SModelRoot): string {
@@ -128,12 +146,17 @@ export function feedbackEdgeEndId(root: SModelRoot): string {
     return root.id + '_feedback_anchor';
 }
 
-export const defaultFeedbackEdgeSchema: SEdgeSchema = <SEdgeSchema>{
-    cssClasses: ["feedback-edge"],
+export const defaultFeedbackEdgeSchema: SEdgeSchema = {
+    cssClasses: ['feedback-edge'],
     opacity: 0.3
-};
-
-export function drawFeedbackEdge(context: CommandExecutionContext, sourceId: string, elementTypeId: string, feedbackEdgeSchema: SEdgeSchema) {
+} as SEdgeSchema;
+
+export function drawFeedbackEdge(
+    context: CommandExecutionContext,
+    sourceId: string,
+    elementTypeId: string,
+    feedbackEdgeSchema: SEdgeSchema
+): void {
     const root = context.root;
     const sourceChild = root.index.getById(sourceId);
     if (!sourceChild) {
@@ -162,11 +185,13 @@ export function drawFeedbackEdge(context: CommandExecutionContext, sourceId: str
     }
 }
 
-export function removeFeedbackEdge(root: SModelRoot) {
+export function removeFeedbackEdge(root: SModelRoot): void {
     const feedbackEdge = root.index.getById(feedbackEdgeId(root));
     const feedbackEdgeEnd = root.index.getById(feedbackEdgeEndId(root));
-    if (feedbackEdge instanceof SChildElement)
+    if (feedbackEdge instanceof SChildElement) {
         root.remove(feedbackEdge);
-    if (feedbackEdgeEnd instanceof SChildElement)
+    }
+    if (feedbackEdgeEnd instanceof SChildElement) {
         root.remove(feedbackEdgeEnd);
+    }
 }

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

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2019 EclipseSource and others.
+ * Copyright (c) 2019-2021 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,12 +13,11 @@
  *
  * 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 } from "sprotty";
-
-import { isStringArray } from "../../utils/array-utils";
-import { addCssClasses, removeCssClasses } from "../../utils/smodel-util";
-import { FeedbackCommand } from "./model";
+import { Action, isStringArray } from '@eclipse-glsp/protocol';
+import { inject, injectable } from 'inversify';
+import { CommandExecutionContext, SModelElement, SModelRoot, TYPES } from 'sprotty';
+import { addCssClasses, removeCssClasses } from '../../utils/smodel-util';
+import { FeedbackCommand } from './model';
 
 export class ModifyCSSFeedbackAction implements Action {
     readonly elementIds?: string[];
@@ -27,7 +26,8 @@ export class ModifyCSSFeedbackAction implements Action {
         public readonly input?: string[] | SModelElement[],
         public readonly addClasses?: string[],
         public readonly removeClasses?: string[],
-        public kind = ModifyCssFeedbackCommand.KIND) {
+        public kind = ModifyCssFeedbackCommand.KIND
+    ) {
         if (input) {
             this.elementIds = isStringArray(input) ? input : input.map(element => element.id);
         }
@@ -68,6 +68,7 @@ function exists(elt?: SModelElement): elt is SModelElement {
     return elt !== undefined;
 }
 
+// eslint-disable-next-line no-shadow
 export enum CursorCSS {
     DEFAULT = 'default-mode',
     OVERLAP_FORBIDDEN = 'overlap-forbidden-mode',
@@ -76,9 +77,11 @@ export enum CursorCSS {
     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 = "resize-mode",
-    MARQUEE = "marquee-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 {
@@ -89,10 +92,10 @@ export function cursorFeedbackAction(cursorCss?: CursorCSS): ModifyCSSFeedbackAc
     return new ModifyCSSFeedbackAction(undefined, addCss, Object.values(CursorCSS));
 }
 
-export function applyCssClasses(element: SModelElement, ...classes: string[]) {
+export function applyCssClasses(element: SModelElement, ...classes: string[]): ModifyCSSFeedbackAction {
     return new ModifyCSSFeedbackAction([element], classes, []);
 }
 
-export function deleteCssClasses(element: SModelElement, ...classes: string[]) {
+export function deleteCssClasses(element: SModelElement, ...classes: string[]): ModifyCSSFeedbackAction {
     return new ModifyCSSFeedbackAction([element], [], classes);
 }