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

package/src/features/edit-label/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,16 +14,15 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 import { ContainerModule } from 'inversify';
-import { ApplyLabelEditCommand, configureCommand, TYPES } from 'sprotty';
-
-import { GLSP_TYPES } from '../../base/types';
+import { ApplyLabelEditCommand, configureCommand } from 'sprotty';
+import { TYPES } from '../../base/types';
 import { DirectLabelEditTool } from './edit-label-tool';
 import { BalloonLabelValidationDecorator, ServerEditLabelValidator } from './edit-label-validator';
 
 const glspEditLabelModule = new ContainerModule((bind, _unbind, isBound, _rebind) => {
     bind(TYPES.IEditLabelValidator).to(ServerEditLabelValidator);
     bind(TYPES.IEditLabelValidationDecorator).to(BalloonLabelValidationDecorator);
-    bind(GLSP_TYPES.IDefaultTool).to(DirectLabelEditTool);
+    bind(TYPES.IDefaultTool).to(DirectLabelEditTool);
     configureCommand({ bind, isBound }, ApplyLabelEditCommand);
 });
 

package/src/features/edit-label/edit-label-tool.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
@@ -15,7 +15,6 @@
  ********************************************************************************/
 import { injectable } from 'inversify';
 import { EditLabelKeyListener, EditLabelMouseListener, KeyListener, MouseListener } from 'sprotty';
-
 import { BaseGLSPTool } from '../tools/base-glsp-tool';
 
 @injectable()

package/src/features/edit-label/edit-label-validator.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,10 +13,9 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { isSetEditValidationResultAction, RequestEditValidationAction, ValidationStatus } from '@eclipse-glsp/protocol';
+import { Action, RequestEditValidationAction, SetEditValidationResultAction, ValidationStatus } from '@eclipse-glsp/protocol';
 import { inject, injectable } from 'inversify';
 import {
-    Action,
     EditableLabel,
     EditLabelValidationResult,
     IEditLabelValidationDecorator,
@@ -25,7 +24,6 @@ import {
     SModelElement,
     TYPES
 } from 'sprotty';
-
 import { GLSPActionDispatcher } from '../../base/action-dispatcher';
 
 export namespace LabelEditValidation {
@@ -41,11 +39,9 @@ export namespace LabelEditValidation {
         }
         return { message, severity };
     }
-}
 
-export class ValidateLabelEditAction extends RequestEditValidationAction {
-    constructor(value: string, labelId: string) {
-        super(LabelEditValidation.CONTEXT_ID, labelId, value);
+    export function createValidationRequestAction(value: string, labelId: string): RequestEditValidationAction {
+        return RequestEditValidationAction.create({ contextId: CONTEXT_ID, modelElementId: labelId, text: value });
     }
 }
 
@@ -54,12 +50,12 @@ export class ServerEditLabelValidator implements IEditLabelValidator {
     @inject(TYPES.IActionDispatcher) protected actionDispatcher: GLSPActionDispatcher;
 
     validate(value: string, label: EditableLabel & SModelElement): Promise<EditLabelValidationResult> {
-        const action = new ValidateLabelEditAction(value, label.id);
+        const action = LabelEditValidation.createValidationRequestAction(value, label.id);
         return this.actionDispatcher.requestUntil(action).then(response => this.getValidationResultFromResponse(response));
     }
 
     getValidationResultFromResponse(action: Action): EditLabelValidationResult {
-        if (isSetEditValidationResultAction(action)) {
+        if (SetEditValidationResultAction.is(action)) {
             return LabelEditValidation.toEditLabelValidationResult(action.status);
         }
         return { severity: 'ok' as Severity };

package/src/features/hints/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
@@ -16,12 +16,12 @@
 import { SetTypeHintsAction } from '@eclipse-glsp/protocol';
 import { ContainerModule } from 'inversify';
 import { configureActionHandler, configureCommand } from 'sprotty';
-import { GLSP_TYPES } from '../../base/types';
+import { TYPES } from '../../base/types';
 import { ApplyTypeHintsCommand, TypeHintProvider } from './type-hints';
 
 const modelHintsModule = new ContainerModule((bind, _unbind, isBound) => {
     bind(TypeHintProvider).toSelf().inSingletonScope();
-    bind(GLSP_TYPES.ITypeHintProvider).toService(TypeHintProvider);
+    bind(TYPES.ITypeHintProvider).toService(TypeHintProvider);
     configureActionHandler({ bind, isBound }, SetTypeHintsAction.KIND, TypeHintProvider);
     configureCommand({ bind, isBound }, ApplyTypeHintsCommand);
 });

package/src/features/hints/type-hints.ts

@@ -13,7 +13,7 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { Action, EdgeTypeHint, isSetTypeHintsAction, ShapeTypeHint, TypeHint } from '@eclipse-glsp/protocol';
+import { Action, EdgeTypeHint, SetTypeHintsAction, ShapeTypeHint, TypeHint } from '@eclipse-glsp/protocol';
 import { inject, injectable } from 'inversify';
 import {
     CommandExecutionContext,
@@ -29,10 +29,9 @@ import {
     SEdge,
     SModelElement,
     SModelRoot,
-    SShapeElement,
-    TYPES
+    SShapeElement
 } from 'sprotty';
-import { GLSP_TYPES } from '../../base/types';
+import { TYPES } from '../../base/types';
 import { getElementTypeId, hasCompatibleType } from '../../utils/smodel-util';
 import { resizeFeature } from '../change-bounds/model';
 import { reconnectFeature } from '../reconnect/model';
@@ -40,19 +39,35 @@ import { IFeedbackActionDispatcher } from '../tool-feedback/feedback-action-disp
 import { FeedbackCommand } from '../tool-feedback/model';
 import { Containable, containerFeature, reparentFeature } from './model';
 
-@injectable()
-export class ApplyTypeHintsAction implements Action {
-    readonly kind = ApplyTypeHintsCommand.KIND;
+/**
+ * Is dispatched by the {@link TypeHintProvider} to apply the type hints received from the server
+ * onto the graphical model. The action is dispatched as persistent feedback to ensure the applied type hints
+ * don't get lost after a server-side model update.
+ */
+export interface ApplyTypeHintsAction extends Action {
+    kind: typeof ApplyTypeHintsAction.KIND;
+}
+
+export namespace ApplyTypeHintsAction {
+    export const KIND = 'applyTypeHints';
+
+    export function is(object: any): object is ApplyTypeHintsAction {
+        return Action.hasKind(object, KIND);
+    }
+
+    export function create(): ApplyTypeHintsAction {
+        return { kind: KIND };
+    }
 }
 
 @injectable()
 export class ApplyTypeHintsCommand extends FeedbackCommand {
-    public static KIND = 'applyTypeHints';
+    public static KIND = ApplyTypeHintsAction.KIND;
     public override readonly priority = 10;
 
-    @inject(GLSP_TYPES.ITypeHintProvider) protected typeHintProvider: ITypeHintProvider;
+    @inject(TYPES.ITypeHintProvider) protected typeHintProvider: ITypeHintProvider;
 
-    constructor(@inject(TYPES.Action) protected action: ApplyTypeHintsAction) {
+    constructor(@inject(TYPES.Action) protected action: Action) {
         super();
     }
 
@@ -69,7 +84,7 @@ export class ApplyTypeHintsCommand extends FeedbackCommand {
 
     protected applyEdgeTypeHint(element: SModelElement): void {
         const hint = this.typeHintProvider.getEdgeTypeHint(element);
-        if (hint && isModifiableFetureSet(element.features)) {
+        if (hint && isModifiableFeatureSet(element.features)) {
             addOrRemove(element.features, deletableFeature, hint.deletable);
             addOrRemove(element.features, editFeature, hint.routable);
             addOrRemove(element.features, reconnectFeature, hint.repositionable);
@@ -78,7 +93,7 @@ export class ApplyTypeHintsCommand extends FeedbackCommand {
 
     protected applyShapeTypeHint(element: SModelElement): void {
         const hint = this.typeHintProvider.getShapeTypeHint(element);
-        if (hint && isModifiableFetureSet(element.features)) {
+        if (hint && isModifiableFeatureSet(element.features)) {
             addOrRemove(element.features, deletableFeature, hint.deletable);
             addOrRemove(element.features, moveFeature, hint.repositionable);
             addOrRemove(element.features, resizeFeature, hint.resizable);
@@ -119,7 +134,7 @@ function addOrRemove(features: Set<symbol>, feature: symbol, add: boolean): void
     }
 }
 
-function isModifiableFetureSet(featureSet?: FeatureSet): featureSet is FeatureSet & Set<symbol> {
+function isModifiableFeatureSet(featureSet?: FeatureSet): featureSet is FeatureSet & Set<symbol> {
     return featureSet !== undefined && featureSet instanceof Set;
 }
 
@@ -131,17 +146,17 @@ export interface ITypeHintProvider {
 
 @injectable()
 export class TypeHintProvider implements IActionHandler, ITypeHintProvider {
-    @inject(GLSP_TYPES.IFeedbackActionDispatcher)
+    @inject(TYPES.IFeedbackActionDispatcher)
     protected feedbackActionDispatcher: IFeedbackActionDispatcher;
 
     protected shapeHints: Map<string, ShapeTypeHint> = new Map();
     protected edgeHints: Map<string, EdgeTypeHint> = new Map();
 
     handle(action: Action): ICommand | Action | void {
-        if (isSetTypeHintsAction(action)) {
+        if (SetTypeHintsAction.is(action)) {
             action.shapeHints.forEach(hint => this.shapeHints.set(hint.elementTypeId, hint));
             action.edgeHints.forEach(hint => this.edgeHints.set(hint.elementTypeId, hint));
-            this.feedbackActionDispatcher.registerFeedback(this, [new ApplyTypeHintsAction()]);
+            this.feedbackActionDispatcher.registerFeedback(this, [ApplyTypeHintsAction.create()]);
         }
     }
 

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

@@ -19,6 +19,8 @@ import {
     ClosePopupActionHandler,
     configureActionHandler,
     configureCommand,
+    EnableDefaultToolsAction,
+    EnableToolsAction,
     FitToScreenCommand,
     HoverFeedbackCommand,
     HoverKeyListener,
@@ -56,6 +58,8 @@ const glspHoverModule = new ContainerModule((bind, _unbind, isBound) => {
     configureActionHandler(context, SetViewportCommand.KIND, ClosePopupActionHandler);
     configureActionHandler(context, MoveCommand.KIND, ClosePopupActionHandler);
     configureActionHandler(context, FocusStateChangedAction.KIND, ClosePopupActionHandler);
+    configureActionHandler(context, EnableToolsAction.KIND, GlspHoverMouseListener);
+    configureActionHandler(context, EnableDefaultToolsAction.KIND, GlspHoverMouseListener);
     configureActionHandler(context, FocusStateChangedAction.KIND, GlspHoverMouseListener);
 });
 

package/src/features/hover/hover.ts

@@ -13,7 +13,15 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { Action, Bounds, RequestPopupModelAction, SetPopupModelAction } from '@eclipse-glsp/protocol';
+import {
+    Action,
+    Bounds,
+    PreRenderedElementSchema,
+    RequestPopupModelAction,
+    SetPopupModelAction,
+    SModelElementSchema,
+    SModelRootSchema
+} from '@eclipse-glsp/protocol';
 import { injectable } from 'inversify';
 import {
     EMPTY_ROOT,
@@ -21,18 +29,17 @@ import {
     HoverMouseListener,
     IActionHandler,
     ICommand,
-    PreRenderedElementSchema,
     SIssueMarker,
     SIssueSeverity,
-    SModelElement,
-    SModelElementSchema,
-    SModelRootSchema
+    SModelElement
 } from 'sprotty';
-import { isFocusStateChangedAction } from '../../base/actions/focus-change-action';
+import { FocusStateChangedAction } from '../../base/actions/focus-change-action';
+import { EnableDefaultToolsAction, EnableToolsAction } from '../../base/tool-manager/tool-actions';
+import { EdgeCreationTool } from '../tools/edge-creation-tool';
 import { GIssueMarker } from '../validation/issue-marker';
-
 @injectable()
 export class GlspHoverMouseListener extends HoverMouseListener implements IActionHandler {
+    protected enableHover = true;
     /**
      * Stops mouse over timer and remove hover feedback, if focus is lost.
      *
@@ -43,14 +50,25 @@ export class GlspHoverMouseListener extends HoverMouseListener implements IActio
      * @returns a `HoverFeedbackAction` resetting the state, if the specified action indicates lost focus
      */
     handle(action: Action): void | Action | ICommand {
-        if (isFocusStateChangedAction(action) && !action.hasFocus) {
+        if (FocusStateChangedAction.is(action) && !action.hasFocus) {
             this.stopMouseOverTimer();
             if (this.lastHoverFeedbackElementId) {
                 const previousTargetId = this.lastHoverFeedbackElementId;
                 this.lastHoverFeedbackElementId = undefined;
-                return new HoverFeedbackAction(previousTargetId, false);
+                return HoverFeedbackAction.create({ mouseoverElement: previousTargetId, mouseIsOver: false });
             }
+        } else if (EnableToolsAction.is(action)) {
+            this.enableHover = !(action as EnableToolsAction).toolIds.includes(EdgeCreationTool.ID);
+        } else if (EnableDefaultToolsAction.is(action)) {
+            this.enableHover = true;
+        }
+    }
+
+    override mouseOver(target: SModelElement, event: MouseEvent): (Action | Promise<Action>)[] {
+        if (this.enableHover) {
+            return super.mouseOver(target, event);
         }
+        return [];
     }
 
     protected override startMouseOverTimer(target: SModelElement, event: MouseEvent): Promise<Action> {
@@ -59,9 +77,9 @@ export class GlspHoverMouseListener extends HoverMouseListener implements IActio
             this.state.mouseOverTimer = window.setTimeout(() => {
                 const popupBounds = this.computePopupBounds(target, { x: event.pageX, y: event.pageY });
                 if (target instanceof GIssueMarker) {
-                    resolve(new SetPopupModelAction(this.createPopupModel(target as GIssueMarker, popupBounds)));
+                    resolve(SetPopupModelAction.create(this.createPopupModel(target as GIssueMarker, popupBounds)));
                 } else {
-                    resolve(new RequestPopupModelAction(target.id, popupBounds));
+                    resolve(RequestPopupModelAction.create({ elementId: target.id, bounds: popupBounds }));
                 }
 
                 this.state.popupOpen = true;

package/src/features/layout/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

package/src/features/layout/freeform-layout.ts

@@ -13,18 +13,9 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
+import { Bounds, Dimension, Point } from '@eclipse-glsp/protocol';
 import { injectable } from 'inversify';
-import {
-    Bounds,
-    BoundsData,
-    Dimension,
-    isValidDimension,
-    LayoutContainer,
-    Point,
-    SChildElement,
-    SParentElement,
-    StatefulLayouter
-} from 'sprotty';
+import { BoundsData, LayoutContainer, SChildElement, SParentElement, StatefulLayouter } from 'sprotty';
 import { AbstractLayout } from 'sprotty/lib/features/bounds/abstract-layout';
 import { AbstractLayoutOptions } from 'sprotty/lib/features/bounds/layout-options';
 
@@ -64,7 +55,7 @@ export class FreeFormLayouter extends AbstractLayout<AbstractLayoutOptions> {
         let maxY = 0;
         container.children.forEach(child => {
             const bounds = layouter.getBoundsData(child).bounds;
-            if (bounds !== undefined && isValidDimension(bounds)) {
+            if (bounds !== undefined && Dimension.isValid(bounds)) {
                 const childMaxX = bounds.x + bounds.width;
                 const childMaxY = bounds.y + bounds.height;
                 maxX = Math.max(maxX, childMaxX);

package/src/features/layout/layout-commands.spec.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,8 +13,16 @@
  *
  * 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, Bounds, ChangeBoundsOperation, ElementAndBounds } from '@eclipse-glsp/protocol';
+/* eslint-disable deprecation/deprecation */
+import {
+    Action,
+    Bounds,
+    ChangeBoundsOperation,
+    ElementAndBounds,
+    RequestAction,
+    ResponseAction,
+    SetBoundsAction
+} from '@eclipse-glsp/protocol';
 import { expect } from 'chai';
 import { Container } from 'inversify';
 import 'mocha';
@@ -29,16 +37,12 @@ import {
     IActionDispatcher,
     MoveAction,
     MoveCommand,
-    RequestAction,
-    ResponseAction,
     SChildElement,
-    SetBoundsAction,
     SetBoundsCommand,
     SGraphFactory,
-    SModelRoot,
-    TYPES
+    SModelRoot
 } from 'sprotty';
-import { GLSP_TYPES } from '../../base/types';
+import { TYPES } from '../../base/types';
 import { resizeFeature } from '../change-bounds/model';
 import { SelectionService } from '../select/selection-service';
 import { FeedbackActionDispatcher } from '../tool-feedback/feedback-action-dispatcher';
@@ -69,12 +73,12 @@ class MockActionDispatcher implements IActionDispatcher {
 
 const container = new Container();
 container.load(defaultModule);
-container.bind(GLSP_TYPES.IFeedbackActionDispatcher).to(FeedbackActionDispatcher).inSingletonScope();
+container.bind(TYPES.IFeedbackActionDispatcher).to(FeedbackActionDispatcher).inSingletonScope();
 container.bind(SelectionService).toSelf().inSingletonScope();
-container.bind(GLSP_TYPES.SelectionService).toService(SelectionService);
+container.bind(TYPES.SelectionService).toService(SelectionService);
 container.rebind(TYPES.IModelFactory).to(SGraphFactory).inSingletonScope();
 const graphFactory = container.get<SGraphFactory>(TYPES.IModelFactory);
-const selectionService = container.get<SelectionService>(GLSP_TYPES.SelectionService);
+const selectionService = container.get<SelectionService>(TYPES.SelectionService);
 
 const actionDispatcher = new MockActionDispatcher();
 
@@ -128,7 +132,7 @@ describe('AlignElementsCommand', () => {
             { elementId: 'node2', newPosition: { x: 222, y: 222 }, newSize: defaultSize },
             { elementId: 'node3', newPosition: { x: 333, y: 333 }, newSize: defaultSize }
         ]);
-        const action = new AlignElementsAction(['node1', 'node2', 'node3'], Alignment.Left);
+        const action = AlignElementsAction.create({ elementIds: ['node1', 'node2', 'node3'], alignment: Alignment.Left });
         const command = new AlignElementsCommand(action, actionDispatcher, selectionService);
         command.execute(newContext(newModel));
 
@@ -148,7 +152,7 @@ describe('AlignElementsCommand', () => {
             { elementId: 'node2', newPosition: { x: 222, y: 222 }, newSize: defaultSize },
             { elementId: 'node3', newPosition: { x: 333, y: 333 }, newSize: defaultSize }
         ]);
-        const action = new AlignElementsAction(['node1', 'node2', 'node3'], Alignment.Right);
+        const action = AlignElementsAction.create({ elementIds: ['node1', 'node2', 'node3'], alignment: Alignment.Right });
         const command = new AlignElementsCommand(action, actionDispatcher, selectionService);
         command.execute(newContext(newModel));
 
@@ -168,7 +172,7 @@ describe('AlignElementsCommand', () => {
             { elementId: 'node2', newPosition: { x: 222, y: 222 }, newSize: defaultSize },
             { elementId: 'node3', newPosition: { x: 333, y: 333 }, newSize: defaultSize }
         ]);
-        const action = new AlignElementsAction(['node1', 'node2', 'node3'], Alignment.Center);
+        const action = AlignElementsAction.create({ elementIds: ['node1', 'node2', 'node3'], alignment: Alignment.Center });
         const command = new AlignElementsCommand(action, actionDispatcher, selectionService);
         command.execute(newContext(newModel));
 
@@ -188,7 +192,7 @@ describe('AlignElementsCommand', () => {
             { elementId: 'node2', newPosition: { x: 222, y: 222 }, newSize: defaultSize },
             { elementId: 'node3', newPosition: { x: 333, y: 333 }, newSize: defaultSize }
         ]);
-        const action = new AlignElementsAction(['node1', 'node2', 'node3'], Alignment.Top);
+        const action = AlignElementsAction.create({ elementIds: ['node1', 'node2', 'node3'], alignment: Alignment.Top });
         const command = new AlignElementsCommand(action, actionDispatcher, selectionService);
         command.execute(newContext(newModel));
 
@@ -208,7 +212,7 @@ describe('AlignElementsCommand', () => {
             { elementId: 'node2', newPosition: { x: 222, y: 222 }, newSize: defaultSize },
             { elementId: 'node3', newPosition: { x: 333, y: 333 }, newSize: defaultSize }
         ]);
-        const action = new AlignElementsAction(['node1', 'node2', 'node3'], Alignment.Bottom);
+        const action = AlignElementsAction.create({ elementIds: ['node1', 'node2', 'node3'], alignment: Alignment.Bottom });
         const command = new AlignElementsCommand(action, actionDispatcher, selectionService);
         command.execute(newContext(newModel));
 
@@ -228,7 +232,7 @@ describe('AlignElementsCommand', () => {
             { elementId: 'node2', newPosition: { x: 222, y: 222 }, newSize: defaultSize },
             { elementId: 'node3', newPosition: { x: 333, y: 333 }, newSize: defaultSize }
         ]);
-        const action = new AlignElementsAction(['node1', 'node2', 'node3'], Alignment.Middle);
+        const action = AlignElementsAction.create({ elementIds: ['node1', 'node2', 'node3'], alignment: Alignment.Middle });
         const command = new AlignElementsCommand(action, actionDispatcher, selectionService);
         command.execute(newContext(newModel));
 
@@ -250,7 +254,11 @@ describe('ResizeElementsCommand', () => {
             { elementId: 'node2', newPosition: { x: 100, y: 200 }, newSize: { height: 20, width: 20 } },
             { elementId: 'node3', newPosition: { x: 100, y: 300 }, newSize: { height: 30, width: 30 } }
         ]);
-        const action = new ResizeElementsAction(['node1', 'node2', 'node3'], ResizeDimension.Width, Reduce.last);
+        const action = ResizeElementsAction.create({
+            elementIds: ['node1', 'node2', 'node3'],
+            dimension: ResizeDimension.Width,
+            reductionFunction: Reduce.last
+        });
         const command = new ResizeElementsCommand(action, actionDispatcher, selectionService);
         command.execute(newContext(newModel));
 
@@ -271,7 +279,11 @@ describe('ResizeElementsCommand', () => {
             { elementId: 'node2', newPosition: { x: 100, y: 200 }, newSize: { height: 20, width: 20 } },
             { elementId: 'node3', newPosition: { x: 100, y: 300 }, newSize: { height: 30, width: 30 } }
         ]);
-        const action = new ResizeElementsAction(['node1', 'node2', 'node3'], ResizeDimension.Height, Reduce.last);
+        const action = ResizeElementsAction.create({
+            elementIds: ['node1', 'node2', 'node3'],
+            dimension: ResizeDimension.Height,
+            reductionFunction: Reduce.last
+        });
         const command = new ResizeElementsCommand(action, actionDispatcher, selectionService);
         command.execute(newContext(newModel));
 
@@ -292,7 +304,11 @@ describe('ResizeElementsCommand', () => {
             { elementId: 'node2', newPosition: { x: 100, y: 200 }, newSize: { height: 20, width: 20 } },
             { elementId: 'node3', newPosition: { x: 100, y: 300 }, newSize: { height: 30, width: 30 } }
         ]);
-        const action = new ResizeElementsAction(['node1', 'node2', 'node3'], ResizeDimension.Width_And_Height, Reduce.last);
+        const action = ResizeElementsAction.create({
+            elementIds: ['node1', 'node2', 'node3'],
+            dimension: ResizeDimension.Width_And_Height,
+            reductionFunction: Reduce.last
+        });
         const command = new ResizeElementsCommand(action, actionDispatcher, selectionService);
         command.execute(newContext(newModel));
 
@@ -308,7 +324,7 @@ describe('ResizeElementsCommand', () => {
 });
 
 function initModel(elementAndBounds: ElementAndBounds[]): SModelRoot {
-    const mySetBoundsAction = new SetBoundsAction(elementAndBounds);
+    const mySetBoundsAction = SetBoundsAction.create(elementAndBounds);
     const setBoundsCommand = new SetBoundsCommand(mySetBoundsAction);
     return setBoundsCommand.execute(context) as SModelRoot;
 }