@eclipse-glsp/server 1.1.0-next.3d7585d.42 → 1.1.0-next.44bd1e0.43

package/src/common/gmodel/change-bounds-operation-handler.ts

@@ -15,24 +15,28 @@
  ********************************************************************************/
 import { GModelRoot, GNode } from '@eclipse-glsp/graph';
 import { ChangeBoundsOperation, Dimension, MaybePromise, Point } from '@eclipse-glsp/protocol';
-import { inject, injectable } from 'inversify';
-import { ModelState } from '../features/model/model-state';
-import { OperationHandler } from '../operations/operation-handler';
+import { injectable } from 'inversify';
+import { Command } from '../command/command';
+import { GModelOperationHandler } from './gmodel-operation-handler';
 
+/**
+ * Applies {@link ChangeBoundsOperation} directly to the GModel.
+ */
 @injectable()
-export class ChangeBoundsOperationHandler implements OperationHandler {
+export class GModelChangeBoundsOperationHandler extends GModelOperationHandler {
     operationType = ChangeBoundsOperation.KIND;
 
-    @inject(ModelState)
-    protected modelState: ModelState;
+    createCommand(operation: ChangeBoundsOperation): MaybePromise<Command | undefined> {
+        return this.commandOf(() => this.executeChangeBounds(operation));
+    }
 
-    execute(operation: ChangeBoundsOperation): MaybePromise<void> {
+    protected executeChangeBounds(operation: ChangeBoundsOperation): void {
         for (const element of operation.newBounds) {
             this.changeElementBounds(element.elementId, element.newSize, element.newPosition);
         }
     }
 
-    changeElementBounds(elementId: string, newSize: Dimension, newPosition: Point | undefined): void {
+    protected changeElementBounds(elementId: string, newSize: Dimension, newPosition: Point | undefined): void {
         const index = this.modelState.index;
         const nodeToUpdate = index.findByClass(elementId, GNode);
         if (!nodeToUpdate) {

package/src/common/gmodel/change-routing-points-operation-handler.ts

@@ -15,20 +15,21 @@
  ********************************************************************************/
 
 import { ChangeRoutingPointsOperation, MaybePromise } from '@eclipse-glsp/protocol';
-import { inject, injectable } from 'inversify';
-import { ModelState } from '../features/model/model-state';
-import { OperationHandler } from '../operations/operation-handler';
+import { injectable } from 'inversify';
+import { Command } from '../command/command';
 import { GLSPServerError } from '../utils/glsp-server-error';
 import { applyRoutingPoints } from '../utils/layout-util';
+import { GModelOperationHandler } from './gmodel-operation-handler';
 
 @injectable()
-export class ChangeRoutingPointsOperationHandler implements OperationHandler {
+export class GModelChangeRoutingPointsOperationHandler extends GModelOperationHandler {
     operationType = ChangeRoutingPointsOperation.KIND;
 
-    @inject(ModelState)
-    protected modelState: ModelState;
+    createCommand(operation: ChangeRoutingPointsOperation): MaybePromise<Command | undefined> {
+        return this.commandOf(() => this.executeChangeRoutingPoints(operation));
+    }
 
-    execute(operation: ChangeRoutingPointsOperation): MaybePromise<void> {
+    executeChangeRoutingPoints(operation: ChangeRoutingPointsOperation): MaybePromise<void> {
         if (!operation.newRoutingPoints) {
             throw new GLSPServerError('Incomplete change routingPoints  action');
         }

package/src/common/{operations → gmodel}/cut-operation-handler.ts

@@ -16,20 +16,21 @@
 import { CutOperation, DeleteElementOperation, MaybePromise } from '@eclipse-glsp/protocol';
 import { inject, injectable } from 'inversify';
 import { ActionDispatcher } from '../actions/action-dispatcher';
-import { OperationHandler } from './operation-handler';
+import { Command } from '../command/command';
+import { GModelOperationHandler } from './gmodel-operation-handler';
 
 @injectable()
-export class CutOperationHandler implements OperationHandler {
-    operationType = CutOperation.KIND;
+export class GModelCutOperationHandler extends GModelOperationHandler {
+    readonly operationType = CutOperation.KIND;
 
     @inject(ActionDispatcher)
     protected actionDispatcher: ActionDispatcher;
 
-    execute(operation: CutOperation): MaybePromise<void> {
-        const cutableElementIds = this.getElementToCut(operation);
-        if (cutableElementIds.length > 0) {
-            this.actionDispatcher.dispatch(DeleteElementOperation.create(cutableElementIds));
-        }
+    createCommand(operation: CutOperation): MaybePromise<Command | undefined> {
+        const cuttableElementIds = this.getElementToCut(operation);
+        return cuttableElementIds.length > 0 //
+            ? this.commandOf(() => this.actionDispatcher.dispatch(DeleteElementOperation.create(cuttableElementIds)))
+            : undefined;
     }
 
     protected getElementToCut(cutOperation: CutOperation): string[] {

package/src/common/gmodel/delete-operation-handler.ts

@@ -16,32 +16,38 @@
 import { GEdge, GModelElement, GNode } from '@eclipse-glsp/graph';
 import { DeleteElementOperation, MaybePromise } from '@eclipse-glsp/protocol';
 import { inject, injectable } from 'inversify';
+import { Command } from '../command/command';
 import { GModelIndex } from '../features/model/gmodel-index';
-import { ModelState } from '../features/model/model-state';
-import { OperationHandler } from '../operations/operation-handler';
 import { Logger } from '../utils/logger';
+import { GModelOperationHandler } from './gmodel-operation-handler';
 
 @injectable()
-export class GModelDeleteOperationHandler implements OperationHandler {
+export class GModelDeleteOperationHandler extends GModelOperationHandler {
     @inject(Logger)
     protected logger: Logger;
 
-    protected allDependantsIds: Set<string>;
-
-    @inject(ModelState) protected readonly modelState: ModelState;
+    protected allDependentsIds: Set<string>;
 
     get operationType(): string {
         return DeleteElementOperation.KIND;
     }
 
-    execute(operation: DeleteElementOperation): MaybePromise<void> {
+    createCommand(operation: DeleteElementOperation): MaybePromise<Command | undefined> {
         const elementIds = operation.elementIds;
+        if (!elementIds || elementIds.length === 0) {
+            this.logger.warn('Elements to delete are not specified');
+            return undefined;
+        }
+        return this.commandOf(() => this.deleteElements(elementIds));
+    }
+
+    deleteElements(elementIds: string[]): MaybePromise<void> {
         if (!elementIds || elementIds.length === 0) {
             this.logger.warn('Elements to delete are not specified');
             return;
         }
         const index = this.modelState.index;
-        this.allDependantsIds = new Set<string>();
+        this.allDependentsIds = new Set<string>();
         const success = elementIds.every(eId => this.delete(eId, index));
         if (!success) {
             this.logger.warn('Could not delete all elements as requested (see messages above to find out why)');
@@ -49,7 +55,7 @@ export class GModelDeleteOperationHandler implements OperationHandler {
     }
 
     protected delete(elementId: string, index: GModelIndex): boolean {
-        if (this.allDependantsIds.has(elementId)) {
+        if (this.allDependentsIds.has(elementId)) {
             return true;
         }
 
@@ -73,7 +79,7 @@ export class GModelDeleteOperationHandler implements OperationHandler {
             if (index > -1) {
                 this.modelState.root.children.splice(index, 1);
             }
-            this.allDependantsIds.add(dependant.id);
+            this.allDependentsIds.add(dependant.id);
         });
 
         return true;

package/src/common/gmodel/gmodel-create-edge-operation-handler.ts

@@ -16,10 +16,11 @@
 
 import { GEdge, GModelElement, GPort } from '@eclipse-glsp/graph';
 import { GNode } from '@eclipse-glsp/graph/lib/gnode';
-import { CreateEdgeOperation } from '@eclipse-glsp/protocol';
-import { inject, injectable } from 'inversify';
-import { ModelState } from '../features/model/model-state';
-import { CreateOperationHandler } from '../operations/create-operation-handler';
+import { CreateEdgeOperation, MaybePromise, TriggerEdgeCreationAction } from '@eclipse-glsp/protocol';
+import { injectable } from 'inversify';
+import { Command } from '../command/command';
+import { CreateOperationHandler, CreateOperationKind } from '../operations/create-operation-handler';
+import { GModelOperationHandler } from './gmodel-operation-handler';
 
 /**
  * An abstract base implementation of {@link CreateEdgeOperation} handlers for diagram implementations
@@ -27,15 +28,20 @@ import { CreateOperationHandler } from '../operations/create-operation-handler';
  * (i.e. all operation handlers directly modify the graphical model).
  */
 @injectable()
-export abstract class GModelCreateEdgeOperationHandler extends CreateOperationHandler {
-    @inject(ModelState)
-    protected modelState: ModelState;
+export abstract class GModelCreateEdgeOperationHandler extends GModelOperationHandler implements CreateOperationHandler {
+    override readonly operationType: CreateOperationKind = CreateEdgeOperation.KIND;
+    abstract override label: string;
+    abstract elementTypeIds: string[];
 
-    get operationType(): string {
-        return CreateEdgeOperation.KIND;
+    override createCommand(operation: CreateEdgeOperation): MaybePromise<Command | undefined> {
+        return this.commandOf(() => this.executeCreation(operation));
     }
 
-    execute(operation: CreateEdgeOperation): void {
+    getTriggerActions(): TriggerEdgeCreationAction[] {
+        return this.elementTypeIds.map(typeId => TriggerEdgeCreationAction.create(typeId));
+    }
+
+    executeCreation(operation: CreateEdgeOperation): void {
         const index = this.modelState.index;
 
         const source = index.find(operation.sourceElementId, element => element instanceof GNode || element instanceof GPort);

package/src/common/gmodel/gmodel-create-node-operation-handler.ts

@@ -14,11 +14,14 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 
-import { GNode } from '@eclipse-glsp/graph';
-import { CreateNodeOperation, Point, SelectAction } from '@eclipse-glsp/protocol';
+import { GModelElement, GNode } from '@eclipse-glsp/graph';
+import { CreateNodeOperation, MaybePromise, Point, SelectAction, TriggerNodeCreationAction } from '@eclipse-glsp/protocol';
 import { inject, injectable } from 'inversify';
 import { ActionDispatcher } from '../actions/action-dispatcher';
-import { CreateNodeOperationHandler } from '../operations/create-operation-handler';
+import { Command } from '../command/command';
+import { CreateOperationHandler, CreateOperationKind } from '../operations/create-operation-handler';
+import { getRelativeLocation } from '../utils/layout-util';
+import { GModelOperationHandler } from './gmodel-operation-handler';
 
 /**
  * An abstract base implementation of {@link CreateNodeOperationHandler} for diagram implementations
@@ -26,13 +29,21 @@ import { CreateNodeOperationHandler } from '../operations/create-operation-handl
  * (i.e. all operation handlers directly modify the graphical model).
  */
 @injectable()
-export abstract class GModelCreateNodeOperationHandler extends CreateNodeOperationHandler {
+export abstract class GModelCreateNodeOperationHandler extends GModelOperationHandler implements CreateOperationHandler {
     @inject(ActionDispatcher)
     protected actionDispatcher: ActionDispatcher;
 
-    abstract override elementTypeIds: string[];
+    abstract elementTypeIds: string[];
 
-    execute(operation: CreateNodeOperation): void {
+    abstract override label: string;
+
+    override operationType: CreateOperationKind = CreateNodeOperation.KIND;
+
+    override createCommand(operation: CreateNodeOperation): MaybePromise<Command | undefined> {
+        return this.commandOf(() => this.executeCreation(operation));
+    }
+
+    executeCreation(operation: CreateNodeOperation): void {
         const container = this.getContainer(operation) ?? this.modelState.root;
         const relativeLocation = this.getRelativeLocation(operation);
         const element = this.createNode(operation, relativeLocation);
@@ -43,5 +54,42 @@ export abstract class GModelCreateNodeOperationHandler extends CreateNodeOperati
         }
     }
 
+    getTriggerActions(): TriggerNodeCreationAction[] {
+        return this.elementTypeIds.map(typeId => TriggerNodeCreationAction.create(typeId));
+    }
+
+    /**
+     * Return the GModelElement that will contain the newly created node. It is usually
+     * the target element ({@link CreateNodeOperation.containerId}), but could also
+     * be e.g. an intermediate compartment, or even a different Node.
+     *
+     * @param operation
+     * @return the GModelElement that will contain the newly created node.
+     */
+    getContainer(operation: CreateNodeOperation): GModelElement | undefined {
+        const index = this.modelState.index;
+        return operation.containerId ? index.get(operation.containerId) : undefined;
+    }
+
+    getLocation(operation: CreateNodeOperation): Point | undefined {
+        return operation.location;
+    }
+
+    /**
+     * Retrieves the diagram absolute location and the target container from the given {@link CreateNodeOperation}
+     * and converts the absolute location to coordinates relative to the given container.
+     *  Relative coordinates can only be retrieved if the given container element is part of
+     * a hierarchy of {@link GBoundsAware} elements. This means each (recursive) parent element need to
+     * implement {@link GBoundsAware}. If that is not the case this method returns `undefined`.
+     * @param absoluteLocation The diagram absolute position.
+     * @param container The container element.
+     * @returns The relative position or `undefined`.
+     */
+    getRelativeLocation(operation: CreateNodeOperation): Point | undefined {
+        const container = this.getContainer(operation) ?? this.modelState.root;
+        const absoluteLocation = this.getLocation(operation) ?? Point.ORIGIN;
+        return getRelativeLocation(absoluteLocation, container);
+    }
+
     abstract createNode(operation: CreateNodeOperation, relativeLocation?: Point): GNode | undefined;
 }

package/src/common/gmodel/gmodel-diagram-module.ts

@@ -19,19 +19,17 @@ import { BindingTarget } from '../di/binding-target';
 import { DiagramModule } from '../di/diagram-module';
 import { InstanceMultiBinding } from '../di/multi-binding';
 import { RequestClipboardDataActionHandler } from '../features/clipboard/request-clipboard-data-action-handler';
-import { LayoutOperationHandler } from '../features/layout/layout-operation-handler';
 import { GModelFactory, GModelFactoryNullImpl } from '../features/model/gmodel-factory';
 import { DefaultModelState, ModelState } from '../features/model/model-state';
-import { SaveModelActionHandler } from '../features/model/save-model-action-handler';
-import { CutOperationHandler } from '../operations/cut-operation-handler';
-import { OperationHandlerConstructor } from '../operations/operation-handler';
-import { ApplyLabelEditOperationHandler } from './apply-label-edit-operation-handler';
-import { ChangeBoundsOperationHandler } from './change-bounds-operation-handler';
-import { ChangeRoutingPointsOperationHandler } from './change-routing-points-operation-handler';
-import { ComputedBoundsActionHandler } from './computed-bounds-action-handler';
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+import { OperationHandler, OperationHandlerConstructor } from '../operations/operation-handler';
+import { GModelApplyLabelEditOperationHandler } from './apply-label-edit-operation-handler';
+import { GModelChangeBoundsOperationHandler } from './change-bounds-operation-handler';
+import { GModelChangeRoutingPointsOperationHandler } from './change-routing-points-operation-handler';
+import { GModelCutOperationHandler } from './cut-operation-handler';
 import { GModelDeleteOperationHandler } from './delete-operation-handler';
-import { PasteOperationHandler } from './paste-operation-handler';
-import { ReconnectEdgeOperationHandler } from './reconnect-edge-operation-handler';
+import { GModelPasteOperationHandler } from './paste-operation-handler';
+import { GModelReconnectEdgeOperationHandler } from './reconnect-edge-operation-handler';
 
 /**
  * Extension of the {@link DiagramModule} to provide GModel integration.
@@ -39,16 +37,16 @@ import { ReconnectEdgeOperationHandler } from './reconnect-edge-operation-handle
  * Contains all bindings of {@link DiagramModule}.
  *
  * Additionally binds:
- * - {@link CommandStack} to {@link DefaultCommandStack}
- * - {@link ModelState} to {@link ModelState}
  * - {@link GModelFactory} to {@link GModelFactoryNullImpl}
- * - {@link GModelIndex} to self
- * - {@link ComputedBoundsActionHandler} to {@link ActionHandler}
  * - {@link RequestClipboardDataActionHandler} to {@link ActionHandler}
- * - {@link ApplyLabelEditOperationHandler} to {@link OperationHandler}
- * - {@link ChangeBoundsOperationHandler} to {@link OperationHandler}
- * - {@link CutOperationHandler} to {@link OperationHandler}
- * - {@link PasteOperationHandler} to {@link OperationHandler}
+ * - {@link GModelApplyLabelEditOperationHandler} to {@link OperationHandler}
+ * - {@link GModelChangeBoundsOperationHandler} to {@link OperationHandler}
+ * - {@link GModelCutOperationHandler} to {@link OperationHandler}
+ * - {@link GModelDeleteOperationHandler} to {@link OperationHandler}
+ * - {@link GModelPasteOperationHandler} to {@link OperationHandler}
+ * - {@link GModelReconnectEdgeOperationHandler} to {@link OperationHandler}
+ * - {@link GModelChangeRoutingPointsOperationHandler} to {@link OperationHandler}
+
  */
 @injectable()
 export abstract class GModelDiagramModule extends DiagramModule {
@@ -62,20 +60,17 @@ export abstract class GModelDiagramModule extends DiagramModule {
 
     protected override configureActionHandlers(binding: InstanceMultiBinding<ActionHandlerConstructor>): void {
         super.configureActionHandlers(binding);
-        binding.add(ComputedBoundsActionHandler);
-        binding.add(SaveModelActionHandler);
         binding.add(RequestClipboardDataActionHandler);
     }
 
     protected override configureOperationHandlers(binding: InstanceMultiBinding<OperationHandlerConstructor>): void {
         super.configureOperationHandlers(binding);
-        binding.add(ApplyLabelEditOperationHandler);
-        binding.add(ChangeBoundsOperationHandler);
-        binding.add(CutOperationHandler);
+        binding.add(GModelApplyLabelEditOperationHandler);
+        binding.add(GModelChangeBoundsOperationHandler);
+        binding.add(GModelCutOperationHandler);
         binding.add(GModelDeleteOperationHandler);
-        binding.add(PasteOperationHandler);
-        binding.add(ReconnectEdgeOperationHandler);
-        binding.add(LayoutOperationHandler);
-        binding.add(ChangeRoutingPointsOperationHandler);
+        binding.add(GModelPasteOperationHandler);
+        binding.add(GModelReconnectEdgeOperationHandler);
+        binding.add(GModelChangeRoutingPointsOperationHandler);
     }
 }

package/src/common/gmodel/gmodel-operation-handler.ts

@@ -0,0 +1,31 @@
+/********************************************************************************
+ * Copyright (c) 2022-2023 EclipseSource and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the Eclipse
+ * Public License v. 2.0 are satisfied: GNU General Public License, version 2
+ * with the GNU Classpath Exception which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ ********************************************************************************/
+
+import { inject, injectable } from 'inversify';
+import { Command } from '../command/command';
+import { GModelRecordingCommand } from '../command/recording-command';
+import { GModelSerializer } from '../features/model/gmodel-serializer';
+import { OperationHandler } from '../operations/operation-handler';
+
+injectable();
+export abstract class GModelOperationHandler extends OperationHandler {
+    @inject(GModelSerializer)
+    protected serializer: GModelSerializer;
+
+    protected commandOf(runnable: () => void): Command {
+        return new GModelRecordingCommand(this.modelState, this.serializer, runnable);
+    }
+}

package/src/common/gmodel/index.ts

@@ -17,10 +17,11 @@
 export * from './apply-label-edit-operation-handler';
 export * from './change-bounds-operation-handler';
 export * from './change-routing-points-operation-handler';
-export * from './computed-bounds-action-handler';
+export * from './cut-operation-handler';
 export * from './delete-operation-handler';
 export * from './gmodel-create-edge-operation-handler';
 export * from './gmodel-create-node-operation-handler';
 export * from './gmodel-diagram-module';
+export * from './gmodel-operation-handler';
 export * from './paste-operation-handler';
 export * from './reconnect-edge-operation-handler';

package/src/common/gmodel/paste-operation-handler.ts

@@ -14,29 +14,37 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 import { GBoundsAware, GEdge, GModelElement, isGBoundsAware } from '@eclipse-glsp/graph';
-import { MaybePromise, PasteOperation, Point, SModelElementSchema } from '@eclipse-glsp/protocol';
+import { EditorContext, MaybePromise, PasteOperation, Point, SModelElementSchema } from '@eclipse-glsp/protocol';
 import { inject, injectable } from 'inversify';
 import * as uuid from 'uuid';
+import { Command } from '../command/command';
 import { GModelSerializer } from '../features/model/gmodel-serializer';
-import { ModelState } from '../features/model/model-state';
-import { OperationHandler } from '../operations/operation-handler';
+import { GModelOperationHandler } from './gmodel-operation-handler';
 
 @injectable()
-export class PasteOperationHandler implements OperationHandler {
+export class GModelPasteOperationHandler extends GModelOperationHandler {
     operationType = PasteOperation.KIND;
 
     protected readonly DEFAULT_OFFSET = 20;
 
-    @inject(ModelState)
-    protected modelState: ModelState;
-
     @inject(GModelSerializer)
     protected modelSerializer: GModelSerializer;
 
-    execute(operation: PasteOperation): MaybePromise<void> {
-        const schemas: SModelElementSchema[] = JSON.parse(operation.clipboardData['application/json']);
-        const elements = schemas.map(schema => this.modelSerializer.createElement(schema, this.modelState.root));
-        shift(elements, this.computeOffset(elements, operation.editorContext.lastMousePosition));
+    createCommand(operation: PasteOperation): MaybePromise<Command | undefined> {
+        const elements = this.getCopiedElements(operation.clipboardData['application/json']);
+        return elements.length > 0 //
+            ? this.commandOf(() => this.executePaste(elements, operation.editorContext))
+            : undefined;
+    }
+
+    protected getCopiedElements(jsonString: string): GModelElement[] {
+        const schemas: SModelElementSchema[] = JSON.parse(jsonString);
+        return schemas.map(schema => this.modelSerializer.createElement(schema, this.modelState.root));
+    }
+
+    protected executePaste(elements: GModelElement[], context: EditorContext): MaybePromise<void> {
+        shift(elements, this.computeOffset(elements, context.lastMousePosition));
+
         const idMap = this.reassignIds(elements);
         this.filterElements(elements, idMap);
         this.rewireEdges(elements, idMap);

package/src/common/gmodel/reconnect-edge-operation-handler.ts

@@ -15,19 +15,20 @@
  ********************************************************************************/
 import { GEdge, GNode, GPort } from '@eclipse-glsp/graph';
 import { MaybePromise, ReconnectEdgeOperation } from '@eclipse-glsp/protocol';
-import { inject, injectable } from 'inversify';
-import { ModelState } from '../features/model/model-state';
-import { OperationHandler } from '../operations/operation-handler';
+import { injectable } from 'inversify';
+import { Command } from '../command/command';
 import { GLSPServerError } from '../utils/glsp-server-error';
+import { GModelOperationHandler } from './gmodel-operation-handler';
 
 @injectable()
-export class ReconnectEdgeOperationHandler implements OperationHandler {
+export class GModelReconnectEdgeOperationHandler extends GModelOperationHandler {
     operationType = ReconnectEdgeOperation.KIND;
 
-    @inject(ModelState)
-    protected readonly modelState: ModelState;
+    createCommand(operation: ReconnectEdgeOperation): MaybePromise<Command | undefined> {
+        return this.commandOf(() => this.executeReconnect(operation));
+    }
 
-    execute(operation: ReconnectEdgeOperation): MaybePromise<void> {
+    executeReconnect(operation: ReconnectEdgeOperation): MaybePromise<void> {
         if (!operation.edgeElementId || !operation.sourceElementId || !operation.targetElementId) {
             throw new GLSPServerError('Incomplete reconnect connection action');
         }

package/src/common/index.ts

@@ -43,6 +43,7 @@ export * from './features/directediting/context-edit-validator';
 export * from './features/directediting/context-edit-validator-registry';
 export * from './features/directediting/label-edit-validator';
 export * from './features/directediting/request-edit-validation-handler';
+export * from './features/layout/computed-bounds-action-handler';
 export * from './features/layout/layout-engine';
 export * from './features/layout/layout-operation-handler';
 export * from './features/model/gmodel-factory';
@@ -64,11 +65,11 @@ export * from './features/popup/popup-model-factory';
 export * from './features/popup/request-popup-model-action-handler';
 export * from './features/validation/model-validator';
 export * from './features/validation/request-markers-handler';
+export * from './gmodel/cut-operation-handler';
 export * from './gmodel/index';
 export * from './launch/glsp-server-launcher';
 export * from './operations/compound-operation-handler';
 export * from './operations/create-operation-handler';
-export * from './operations/cut-operation-handler';
 export * from './operations/operation-action-handler';
 export * from './operations/operation-handler';
 export * from './operations/operation-handler-registry';

package/src/common/operations/compound-operation-handler.ts

@@ -13,26 +13,28 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { CompoundOperation, MaybePromise, Operation } from '@eclipse-glsp/protocol';
+import { CompoundOperation } from '@eclipse-glsp/protocol';
 import { inject, injectable } from 'inversify';
-import { OperationActionHandler } from './operation-action-handler';
+import { Command, CompoundCommand } from '../command/command';
 import { OperationHandler } from './operation-handler';
 import { OperationHandlerRegistry } from './operation-handler-registry';
 
 @injectable()
-export class CompoundOperationHandler implements OperationHandler {
-    operationType = CompoundOperation.KIND;
+export class CompoundOperationHandler extends OperationHandler {
+    @inject(OperationHandlerRegistry)
+    protected operationHandlerRegistry: OperationHandlerRegistry;
 
-    @inject(OperationHandlerRegistry) protected operationHandlerRegistry: OperationHandlerRegistry;
+    operationType = CompoundOperation.KIND;
 
-    execute(operation: CompoundOperation): void {
-        operation.operationList.forEach(nestedOperation => this.executeNestedOperation(nestedOperation));
-    }
+    async createCommand(operation: CompoundOperation): Promise<Command | undefined> {
+        const maybeCommands = operation.operationList.map(op => this.operationHandlerRegistry.getExecutableCommand(op));
+        const commands: Command[] = [];
 
-    executeNestedOperation(operation: Operation): MaybePromise<void> {
-        const operationHandler = OperationActionHandler.getOperationHandler(operation, this.operationHandlerRegistry);
-        if (operationHandler) {
-            operationHandler.execute(operation);
+        for await (const command of maybeCommands) {
+            if (command) {
+                commands.push(command);
+            }
         }
+        return new CompoundCommand(commands);
     }
 }