@eclipse-glsp/client 0.9.0 → 0.10.0-next.17bfb07.173

package/src/base/editor-context-service.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,25 +13,51 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { Action, Args, distinctAdd, EditMode, EditorContext, isSetEditModeAction, remove } from '@eclipse-glsp/protocol';
-import { inject, injectable, multiInject, optional } from 'inversify';
-import { IActionHandler, ModelSource, MousePositionTracker, SModelElement, SModelRoot, TYPES } from 'sprotty';
+import { Action, Args, distinctAdd, EditMode, EditorContext, remove, SetEditModeAction } from '@eclipse-glsp/protocol';
+import { inject, injectable, multiInject, optional, postConstruct } from 'inversify';
+import { IActionHandler, ModelSource, MousePositionTracker, SModelElement, SModelRoot } from 'sprotty';
 import { SelectionService } from '../features/select/selection-service';
 import { isSourceUriAware } from './source-uri-aware';
-import { GLSP_TYPES } from './types';
+import { TYPES } from './types';
 
 export interface EditModeListener {
     editModeChanged(newValue: string, oldvalue: string): void;
 }
 
+/**
+ * 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,
+ * the edit mode, the latest position of the mouse in the diagram.
+ *
+ * It has been introduced for two main reasons:
+ * 1. to simplify accessing the model root and the current selection from components that are
+ *    not commands,
+ * 2. to conveniently create an EditorContext, which is a context object sent as part of several
+ *    actions to the server to describe the current state of the editor (selection, last mouse
+ *    position, etc.).
+ */
 @injectable()
 export class EditorContextService implements IActionHandler {
-    @inject(GLSP_TYPES.SelectionService) protected selectionService: SelectionService;
-    @inject(MousePositionTracker) protected mousePositionTracker: MousePositionTracker;
-    @inject(TYPES.ModelSourceProvider) protected modelSource: () => Promise<ModelSource>;
+    @inject(TYPES.SelectionService)
+    protected selectionService: SelectionService;
+
+    @inject(MousePositionTracker)
+    protected mousePositionTracker: MousePositionTracker;
+
+    @multiInject(TYPES.IEditModeListener)
+    @optional()
+    protected editModeListeners: EditModeListener[] = [];
+
+    @inject(TYPES.ModelSourceProvider)
+    protected modelSourceProvider: () => Promise<ModelSource>;
+
     protected _editMode: string;
+    protected modelSource: ModelSource | undefined;
 
-    constructor(@multiInject(GLSP_TYPES.IEditModeListener) @optional() protected editModeListeners: EditModeListener[] = []) {}
+    @postConstruct()
+    async initialize(): Promise<void> {
+        this.modelSource = await this.modelSourceProvider();
+    }
 
     register(editModeListener: EditModeListener): void {
         distinctAdd(this.editModeListeners, editModeListener);
@@ -58,7 +84,7 @@ export class EditorContextService implements IActionHandler {
     }
 
     handle(action: Action): void {
-        if (isSetEditModeAction(action)) {
+        if (SetEditModeAction.is(action)) {
             const oldValue = this._editMode;
             this._editMode = action.editMode;
             this.notifiyEditModeListeners(oldValue);
@@ -69,12 +95,8 @@ export class EditorContextService implements IActionHandler {
         this.editModeListeners.forEach(listener => listener.editModeChanged(oldValue, this.editMode));
     }
 
-    async getSourceUri(): Promise<string | undefined> {
-        const modelSource = await this.modelSource();
-        if (isSourceUriAware(modelSource)) {
-            return modelSource.getSourceURI();
-        }
-        return undefined;
+    get sourceUri(): string | undefined {
+        return this.modelSource && isSourceUriAware(this.modelSource) ? this.modelSource.sourceURI : undefined;
     }
 
     get editMode(): string {

package/src/base/focus-tracker.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2021 EclipseSource and others.
+ * Copyright (c) 2021-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
@@ -15,8 +15,9 @@
  ********************************************************************************/
 import { Action } from '@eclipse-glsp/protocol';
 import { inject, injectable } from 'inversify';
-import { IActionHandler, ICommand, TYPES, ViewerOptions } from 'sprotty';
-import { isFocusStateChangedAction } from './actions/focus-change-action';
+import { IActionHandler, ICommand, ViewerOptions } from 'sprotty';
+import { FocusStateChangedAction } from './actions/focus-change-action';
+import { TYPES } from './types';
 
 @injectable()
 export class FocusTracker implements IActionHandler {
@@ -30,7 +31,7 @@ export class FocusTracker implements IActionHandler {
     }
 
     handle(action: Action): void | Action | ICommand {
-        if (isFocusStateChangedAction(action)) {
+        if (FocusStateChangedAction.is(action)) {
             this._hasFocus = action.hasFocus;
             const placeholder = document.getElementById(this.options.baseDiv);
             if (!placeholder) {

package/src/base/model/model-registry.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2021 EclipseSource and others.
+ * Copyright (c) 2021-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
@@ -18,7 +18,7 @@ import { SModelElement, SModelRegistry } from 'sprotty';
 
 @injectable()
 export class GLSPModelRegistry extends SModelRegistry {
-    register(key: string, factory: (u: void) => SModelElement): void {
+    override register(key: string, factory: (u: void) => SModelElement): void {
         if (key === undefined) {
             throw new Error('Key is undefined');
         }

package/src/base/model/update-model-command.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,7 +13,7 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { Action, isSetModelAction, UpdateModelAction } from '@eclipse-glsp/protocol';
+import { Action, SetModelAction, UpdateModelAction } from '@eclipse-glsp/protocol';
 import { inject, injectable, multiInject, optional, postConstruct } from 'inversify';
 import {
     ActionHandlerRegistry,
@@ -24,20 +24,19 @@ import {
     IActionHandler,
     ILogger,
     SModelRoot,
-    TYPES,
     UpdateModelCommand
 } from 'sprotty';
 import { IFeedbackActionDispatcher } from '../../features/tool-feedback/feedback-action-dispatcher';
 import { FeedbackCommand } from '../../features/tool-feedback/model';
-import { GLSP_TYPES } from '../types';
+import { TYPES } from '../types';
 
 /* ActionHandler that transforms a SetModelAction into an (feedback-aware) UpdateModelAction. This can be done because in sprotty
  *  UpdateModel behaves the same as SetModel if no model is present yet.*/
 @injectable()
 export class SetModelActionHandler implements IActionHandler {
     handle(action: Action): Action | void {
-        if (isSetModelAction(action)) {
-            return new UpdateModelAction(action.newRoot, false);
+        if (SetModelAction.is(action)) {
+            return UpdateModelAction.create(action.newRoot, { animate: false });
         }
     }
 }
@@ -53,14 +52,14 @@ export interface SModelRootListener {
 @injectable()
 export class FeedbackAwareUpdateModelCommand extends UpdateModelCommand {
     @inject(TYPES.ILogger) protected logger: ILogger;
-    @inject(GLSP_TYPES.IFeedbackActionDispatcher) @optional() protected readonly feedbackActionDispatcher: IFeedbackActionDispatcher;
+    @inject(TYPES.IFeedbackActionDispatcher) @optional() protected readonly feedbackActionDispatcher: IFeedbackActionDispatcher;
     @inject(TYPES.ActionHandlerRegistryProvider) protected actionHandlerRegistryProvider: () => Promise<ActionHandlerRegistry>;
-    @multiInject(GLSP_TYPES.SModelRootListener) @optional() protected modelRootListeners: SModelRootListener[] = [];
+    @multiInject(TYPES.SModelRootListener) @optional() protected modelRootListeners: SModelRootListener[] = [];
 
     protected actionHandlerRegistry?: ActionHandlerRegistry;
 
     constructor(@inject(TYPES.Action) action: UpdateModelAction) {
-        super(action);
+        super({ animate: true, ...action });
     }
 
     @postConstruct()
@@ -68,7 +67,7 @@ export class FeedbackAwareUpdateModelCommand extends UpdateModelCommand {
         this.actionHandlerRegistryProvider().then(registry => (this.actionHandlerRegistry = registry));
     }
 
-    protected performUpdate(oldRoot: SModelRoot, newRoot: SModelRoot, context: CommandExecutionContext): CommandReturn {
+    protected override performUpdate(oldRoot: SModelRoot, newRoot: SModelRoot, context: CommandExecutionContext): CommandReturn {
         if (this.feedbackActionDispatcher && this.actionHandlerRegistry) {
             // Create a temporary context wich defines the `newRoot` as `root`
             // This way we do not corrupt the redo/undo behavior of the super class

package/src/base/model-initialization-constraint.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,10 +13,9 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { Action, UpdateModelAction } from '@eclipse-glsp/protocol';
+import { Action, Deferred, SetModelAction, UpdateModelAction } from '@eclipse-glsp/protocol';
 import { injectable } from 'inversify';
 import { InitializeCanvasBoundsAction } from 'sprotty';
-import { Deferred } from 'sprotty/lib/utils/async';
 
 /**
  * The constraint defining when the initialization of the GLSP model is completed.
@@ -74,21 +73,20 @@ export abstract class ModelInitializationConstraint {
  */
 @injectable()
 export class DefaultModelInitializationConstraint extends ModelInitializationConstraint {
-    protected seenNonEmptyUpdateModel = false;
+    protected seenNonEmptyModelAction = false;
 
     isInitializedAfter(action: Action): boolean {
-        if (this.isNonEmptyUpdateModel(action)) {
-            this.seenNonEmptyUpdateModel = true;
-        } else if (this.seenNonEmptyUpdateModel && action.kind === InitializeCanvasBoundsAction.KIND) {
+        if (this.isNonEmptyModelAction(action)) {
+            this.seenNonEmptyModelAction = true;
+        } else if (this.seenNonEmptyModelAction && action.kind === InitializeCanvasBoundsAction.KIND) {
             return true;
         }
         return false;
     }
 
-    protected isNonEmptyUpdateModel(action: Action): boolean {
-        if (action && action.kind === UpdateModelAction.KIND) {
-            const updateModelAction = action as UpdateModelAction;
-            return updateModelAction.newRoot !== undefined && updateModelAction.newRoot.type !== 'NONE';
+    protected isNonEmptyModelAction(action: Action): boolean {
+        if (SetModelAction.is(action) || UpdateModelAction.is(action)) {
+            return action.newRoot.type !== 'NONE';
         }
         return false;
     }

package/src/base/selection-clearing-mouse-listener.ts

@@ -30,7 +30,7 @@ import { MouseListener, SModelElement } from 'sprotty';
  */
 @injectable()
 export class SelectionClearingMouseListener extends MouseListener {
-    mouseDown(_target: SModelElement, event: MouseEvent): never[] {
+    override mouseDown(_target: SModelElement, event: MouseEvent): never[] {
         const selection = document.getSelection();
         // eslint-disable-next-line no-null/no-null
         if (selection === null) {

package/src/base/source-uri-aware.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2020 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,10 +13,11 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-export abstract class SourceUriAware {
-    abstract getSourceURI(): string;
+import { AnyObject, hasStringProp } from '@eclipse-glsp/protocol';
+export interface SourceUriAware {
+    sourceURI: string;
 }
 
 export function isSourceUriAware(obj: any): obj is SourceUriAware {
-    return obj !== undefined && typeof obj.getSourceURI === 'function';
+    return AnyObject.is(obj) && hasStringProp(obj, 'sourceURI');
 }

package/src/base/tool-manager/glsp-tool-manager.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
@@ -17,7 +17,7 @@ import { distinctAdd, EditMode } from '@eclipse-glsp/protocol';
 import { inject, injectable, multiInject, optional, postConstruct } from 'inversify';
 import { Tool, ToolManager } from 'sprotty';
 import { EditModeListener, EditorContextService, EditorContextServiceProvider } from '../editor-context-service';
-import { GLSP_TYPES } from '../types';
+import { TYPES } from '../types';
 
 export interface IGLSPToolManager extends ToolManager {
     /* Disables all actives tools and activates only default tool with non-edit function*/
@@ -28,9 +28,9 @@ export interface IGLSPToolManager extends ToolManager {
 export class GLSPToolManager extends ToolManager implements IGLSPToolManager, EditModeListener {
     protected editorContext?: EditorContextService;
 
-    @multiInject(GLSP_TYPES.ITool) @optional() tools: Tool[];
-    @multiInject(GLSP_TYPES.IDefaultTool) @optional() defaultTools: Tool[];
-    @inject(GLSP_TYPES.IEditorContextServiceProvider) contextServiceProvider: EditorContextServiceProvider;
+    @multiInject(TYPES.ITool) @optional() override tools: Tool[];
+    @multiInject(TYPES.IDefaultTool) @optional() override defaultTools: Tool[];
+    @inject(TYPES.IEditorContextServiceProvider) contextServiceProvider: EditorContextServiceProvider;
 
     @postConstruct()
     protected initialize(): void {
@@ -43,19 +43,19 @@ export class GLSPToolManager extends ToolManager implements IGLSPToolManager, Ed
         });
     }
 
-    registerDefaultTools(...tools: Tool[]): void {
+    override registerDefaultTools(...tools: Tool[]): void {
         for (const tool of tools) {
             distinctAdd(this.defaultTools, tool);
         }
     }
 
-    registerTools(...tools: Tool[]): void {
+    override registerTools(...tools: Tool[]): void {
         for (const tool of tools) {
             distinctAdd(this.tools, tool);
         }
     }
 
-    enable(toolIds: string[]): void {
+    override enable(toolIds: string[]): void {
         this.disableActiveTools();
         let tools = toolIds.map(id => this.tool(id));
         if (this.editorContext && this.editorContext.isReadonly) {
@@ -90,6 +90,6 @@ export interface GLSPTool extends Tool {
     isEditTool: boolean;
 }
 
-export function isGLSPTool(tool: Tool): tool is GLSPTool {
+export function isGLSPTool(tool: any): tool is GLSPTool {
     return 'isEditTool' in tool && typeof tool['isEditTool'] === 'boolean';
 }

package/src/base/tool-manager/tool-actions.ts

@@ -0,0 +1,37 @@
+/********************************************************************************
+ * Copyright (c) 2022 STMicroelectronics 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 { Action, hasArrayProp } from '@eclipse-glsp/protocol';
+import { EnableDefaultToolsAction, EnableToolsAction } from 'sprotty/lib/base/tool-manager/tool';
+/* eslint-disable no-shadow */
+
+/**
+ * Use module augmentation to add the `is` utility function to the tool action namespaces provided by sprotty
+ */
+declare module 'sprotty/lib/base/tool-manager/tool' {
+    export namespace EnableDefaultToolsAction {
+        export function is(object: any): object is EnableDefaultToolsAction;
+    }
+    export namespace EnableToolsAction {
+        export function is(object: any): object is EnableToolsAction;
+    }
+}
+
+EnableDefaultToolsAction.is = (object: any): object is EnableDefaultToolsAction => Action.hasKind(object, EnableDefaultToolsAction.KIND);
+
+EnableToolsAction.is = (object: any): object is EnableToolsAction =>
+    Action.hasKind(object, EnableToolsAction.KIND) && hasArrayProp(object, 'toolIds');
+
+export { EnableDefaultToolsAction, EnableToolsAction };

package/src/base/types.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,27 +13,34 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-export const GLSP_TYPES = {
-    IAsyncClipboardService: Symbol.for('IAsyncClipboardService'),
-    ICommandPaletteActionProviderRegistry: Symbol.for('ICommandPaletteActionProviderRegistry'),
-    IEditorContextServiceProvider: Symbol.for('IEditorContextProvider'),
-    IFeedbackActionDispatcher: Symbol.for('IFeedbackActionDispatcher'),
-    IToolFactory: Symbol.for('Factory<Tool>'),
-    ITypeHintProvider: Symbol.for('ITypeHintProvider'),
-    IMovementRestrictor: Symbol.for('IMovmementRestrictor'),
-    SelectionService: Symbol.for('SelectionService'),
-    SelectionListener: Symbol.for('SelectionListener'),
-    SModelRootListener: Symbol.for('SModelRootListener'),
-    MouseTool: Symbol.for('MouseTool'),
-    IContextMenuService: Symbol.for('IContextMenuService'),
-    IContextMenuServiceProvider: Symbol.for('IContextMenuServiceProvider'),
-    IContextMenuProviderRegistry: Symbol.for('IContextMenuProviderRegistry'),
-    IContextMenuProvider: Symbol.for('IContextMenuProvider'),
-    ICopyPasteHandler: Symbol.for('ICopyPasteHandler'),
-    IGLSPToolManager: Symbol.for('IGLSPToolManager'),
-    ITool: Symbol.for('ITool'),
-    IDefaultTool: Symbol.for('IDefaultTool'),
-    IEditModeListener: Symbol.for('IEditModeListener'),
-    LayoutRegistration: Symbol.for('LayoutRegistration'),
-    IMarqueeBehavior: Symbol.for('IMarqueeBehavior')
+import { TYPES as SprottyTYPES } from 'sprotty';
+/**
+ * Reexport of the TYPES namespace of sprotty augments with additional GLSP specific service
+ * identifiers.
+ */
+export const TYPES = {
+    ...SprottyTYPES,
+    IAsyncClipboardService: Symbol('IAsyncClipboardService'),
+    IEditorContextServiceProvider: Symbol('IEditorContextProvider'),
+    IFeedbackActionDispatcher: Symbol('IFeedbackActionDispatcher'),
+    IToolFactory: Symbol('Factory<Tool>'),
+    ITypeHintProvider: Symbol('ITypeHintProvider'),
+    IMovementRestrictor: Symbol('IMovementRestrictor'),
+    SelectionService: Symbol('SelectionService'),
+    SelectionListener: Symbol('SelectionListener'),
+    SModelRootListener: Symbol('SModelRootListener'),
+    MouseTool: Symbol('MouseTool'),
+    IContextMenuProvider: Symbol('IContextMenuProvider'),
+    ICopyPasteHandler: Symbol('ICopyPasteHandler'),
+    ITool: Symbol('ITool'),
+    IDefaultTool: Symbol('IDefaultTool'),
+    IEditModeListener: Symbol('IEditModeListener'),
+    IMarqueeBehavior: Symbol('IMarqueeBehavior')
 };
+
+/**
+ * Keep a reexport under the old deprecated namespace to avoid hard API breaks.
+ * This gives adopters a grace period but all deprecated API will be removed before the 1.0.0 release.
+ * @deprecated Please use `TYPES` from `@eclipse-glsp/client` instead
+ */
+export const GLSP_TYPES = TYPES;

package/src/base/view/view-registry.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2021 EclipseSource and others.
+ * Copyright (c) 2021-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
@@ -18,7 +18,7 @@ import { IView, ViewRegistry } from 'sprotty';
 
 @injectable()
 export class GLSPViewRegistry extends ViewRegistry {
-    register(key: string, instance: IView): void {
+    override register(key: string, instance: IView): void {
         if (key === undefined) {
             throw new Error('Key is undefined');
         }

package/src/features/change-bounds/model.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
@@ -51,14 +51,14 @@ export class SResizeHandle extends SChildElement implements Hoverable {
     static readonly TYPE = 'resize-handle';
 
     constructor(
-        public readonly location?: ResizeHandleLocation,
-        public readonly type: string = SResizeHandle.TYPE,
-        public readonly hoverFeedback: boolean = false
+        readonly location?: ResizeHandleLocation,
+        override readonly type: string = SResizeHandle.TYPE,
+        readonly hoverFeedback: boolean = false
     ) {
         super();
     }
 
-    hasFeature(feature: symbol): boolean {
+    override hasFeature(feature: symbol): boolean {
         return feature === hoverFeedbackFeature;
     }
 

package/src/features/change-bounds/movement-restrictor.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
@@ -20,40 +20,35 @@ import { toAbsoluteBounds } from '../../utils/viewpoint-util';
 import { ModifyCSSFeedbackAction } from '../tool-feedback/css-feedback';
 import { isBoundsAwareMoveable, SResizeHandle } from './model';
 
+/**
+ * A `MovementRestrictor` is an optional service that can be used by tools to validate
+ * whether a certain move operation (e.g. `ChangeBoundsOperation`) in the diagram is valid.
+ */
 export interface IMovementRestrictor {
-    validate(newLocation: Point, element: SModelElement): boolean;
+    /**
+     * Validate whether moving the given element to a new given location is allowed.
+     * @param element The element that should be moved.
+     * @param newLocation The new location of the element.
+     * @returns `true` if the the element is movable and moving to the given location is allowed, `false` otherwise.
+     *          Should also return `false` if the newLocation is `undefined`:
+     */
+    validate(element: SModelElement, newLocation?: Point): boolean;
+    /**
+     * Feedback css-classes. Can be applied to elements that did fail the validation.
+     */
     cssClasses?: string[];
 }
 
-export function createMovementRestrictionFeedback(
-    element: SModelElement,
-    movementRestrictor: IMovementRestrictor
-): ModifyCSSFeedbackAction {
-    const elements: SModelElement[] = [element];
-    if (element instanceof SParentElement) {
-        element.children.filter(child => child instanceof SResizeHandle).forEach(e => elements.push(e));
-    }
-    return new ModifyCSSFeedbackAction(elements, movementRestrictor.cssClasses);
-}
-
-export function removeMovementRestrictionFeedback(
-    element: SModelElement,
-    movementRestrictor: IMovementRestrictor
-): ModifyCSSFeedbackAction {
-    const elements: SModelElement[] = [element];
-    if (element instanceof SParentElement) {
-        element.children.filter(child => child instanceof SResizeHandle).forEach(e => elements.push(e));
-    }
-
-    return new ModifyCSSFeedbackAction(elements, undefined, movementRestrictor.cssClasses);
-}
-
+/**
+ *  A `IMovementRestrictor` that checks for overlapping elements. Move operations
+ *  are only valid if the element does not collide with another element after moving.
+ */
 @injectable()
-export class NoOverlapMovmentRestrictor implements IMovementRestrictor {
+export class NoOverlapMovementRestrictor implements IMovementRestrictor {
     cssClasses = ['movement-not-allowed'];
 
-    validate(newLocation: Point, element: SModelElement): boolean {
-        if (!isBoundsAwareMoveable(element)) {
+    validate(element: SModelElement, newLocation?: Point): boolean {
+        if (!isBoundsAwareMoveable(element) || !newLocation) {
             return false;
         }
         // Create ghost element at the newLocation
@@ -71,27 +66,62 @@ export class NoOverlapMovmentRestrictor implements IMovementRestrictor {
                 .all()
                 .filter(e => e.id !== ghostElement.id && e !== ghostElement.root && e instanceof SNode)
                 .map(e => e as SModelElement & BoundsAware)
-        ).some(e => areOverlapping(e, ghostElement));
+        ).some(e => this.areOverlapping(e, ghostElement));
     }
-}
 
-export function areOverlapping(element1: SModelElement & BoundsAware, element2: SModelElement & BoundsAware): boolean {
-    const b1 = toAbsoluteBounds(element1);
-    const b2 = toAbsoluteBounds(element2);
-    const r1TopLeft: Point = b1;
-    const r1BottomRight = { x: b1.x + b1.width, y: b1.y + b1.height };
-    const r2TopLeft: Point = b2;
-    const r2BottomRight = { x: b2.x + b2.width, y: b2.y + b2.height };
+    protected areOverlapping(element1: SModelElement & BoundsAware, element2: SModelElement & BoundsAware): boolean {
+        const b1 = toAbsoluteBounds(element1);
+        const b2 = toAbsoluteBounds(element2);
+        const r1TopLeft: Point = b1;
+        const r1BottomRight = { x: b1.x + b1.width, y: b1.y + b1.height };
+        const r2TopLeft: Point = b2;
+        const r2BottomRight = { x: b2.x + b2.width, y: b2.y + b2.height };
+
+        // If one rectangle is on left side of other
+        if (r1TopLeft.x > r2BottomRight.x || r2TopLeft.x > r1BottomRight.x) {
+            return false;
+        }
+
+        // If one rectangle is above other
+        if (r1BottomRight.y < r2TopLeft.y || r2BottomRight.y < r1TopLeft.y) {
+            return false;
+        }
 
-    // If one rectangle is on left side of other
-    if (r1TopLeft.x > r2BottomRight.x || r2TopLeft.x > r1BottomRight.x) {
-        return false;
+        return true;
     }
+}
 
-    // If one rectangle is above other
-    if (r1BottomRight.y < r2TopLeft.y || r2BottomRight.y < r1TopLeft.y) {
-        return false;
+/**
+ * Utility function to create an action that applies the given {@link IMovementRestrictor.cssClasses} to the given element.
+ * @param element The element on which the css classes should be applied.
+ * @param movementRestrictor The movement restrictor whose cssClasses should be applied.
+ * @returns The corresponding {@link ModifyCSSFeedbackAction}
+ */
+export function createMovementRestrictionFeedback(
+    element: SModelElement,
+    movementRestrictor: IMovementRestrictor
+): ModifyCSSFeedbackAction {
+    const elements: SModelElement[] = [element];
+    if (element instanceof SParentElement) {
+        element.children.filter(child => child instanceof SResizeHandle).forEach(e => elements.push(e));
+    }
+    return ModifyCSSFeedbackAction.create({ elements, add: movementRestrictor.cssClasses });
+}
+
+/**
+ * Utility function to create an action that removes the given {@link IMovementRestrictor.cssClasses} from the given element.
+ * @param element The element from which the css classes should be removed.
+ * @param movementRestrictor The movement restrictor whose cssClasses should be removed.
+ * @returns The corresponding {@link ModifyCSSFeedbackAction}
+ */
+export function removeMovementRestrictionFeedback(
+    element: SModelElement,
+    movementRestrictor: IMovementRestrictor
+): ModifyCSSFeedbackAction {
+    const elements: SModelElement[] = [element];
+    if (element instanceof SParentElement) {
+        element.children.filter(child => child instanceof SResizeHandle).forEach(e => elements.push(e));
     }
 
-    return true;
+    return ModifyCSSFeedbackAction.create({ elements, remove: movementRestrictor.cssClasses });
 }