@eclipse-glsp/server 1.1.0-next.3d7585d.42

package/src/common/features/navigation/navigation-target-provider.ts

@@ -0,0 +1,50 @@
+/********************************************************************************
+ * Copyright (c) 2022-2023 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 { EditorContext, NavigationTarget } from '@eclipse-glsp/protocol';
+
+export const NavigationTargetProvider = Symbol('NavigationTargetProviders');
+
+/**
+ * This provider retrieves navigation targets for its target type from a given {@link EditorContext}.
+ */
+export interface NavigationTargetProvider {
+    /**
+     * Specifies the navigation targets for the given target type.
+     *
+     * If the `args` of a returned {@link NavigationTarget} contain a
+     * {@link NavigationTarget.ELEMENT_IDS_SEPARATOR}, GLSP diagram clients should navigate to
+     * the model elements with the specified ID within the current diagram. Multiple element
+     * IDs can be concatenated with {@link NavigationTarget.ELEMENT_IDS_SEPARATOR}.
+     *
+     * If the `args` of a returned {@link NavigationTarget} contain a property
+     * `JSON_OPENER_OPTIONS` and its uri is outside of the current diagram, the string
+     * value of the `JSON_OPENER_OPTIONS` property will be parsed as JSON
+     * and merged into the opener options by the Theia integration of the GLSP client.
+     * This allows GLSP servers to pass additional opener options, such as a selection, etc.
+     * Other clients (non-Theia clients) should behave the same way.
+     *
+     * @param editorContext The editor context
+     * @returns the list of navigation targets
+     */
+    getTargets(editorContext: EditorContext): NavigationTarget[];
+
+    /**
+     * Returns the targetTypeId of the provider.
+     *
+     * @returns The targetTypeId of the provider.
+     */
+    targetTypeId: string;
+}

package/src/common/features/navigation/navigation-target-resolution.ts

@@ -0,0 +1,22 @@
+/********************************************************************************
+ * Copyright (c) 2022-2023 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 { Args } from '@eclipse-glsp/protocol';
+
+export class NavigationTargetResolution {
+    static readonly EMPTY = new NavigationTargetResolution([]);
+
+    constructor(readonly elementIds: string[], readonly args?: Args) {}
+}

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

@@ -0,0 +1,61 @@
+/********************************************************************************
+ * Copyright (c) 2022-2023 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 { Args, MaybePromise, NavigationTarget } from '@eclipse-glsp/protocol';
+import { injectable } from 'inversify';
+import { NavigationTargetResolution } from './navigation-target-resolution';
+
+@injectable()
+export abstract class NavigationTargetResolver {
+    readonly INFO = 'info';
+    readonly WARNING = 'warning';
+    readonly ERROR = 'error';
+
+    abstract resolve(navigationTarget: NavigationTarget): MaybePromise<NavigationTargetResolution>;
+
+    createArgs(): Args {
+        return {};
+    }
+
+    createArgsWithInfo(message: string): Args {
+        const args = this.createArgs();
+        this.addInfo(message, args);
+        return args;
+    }
+
+    createArgsWithWarning(message: string): Args {
+        const args = this.createArgs();
+        this.addWarning(message, args);
+        return args;
+    }
+
+    createArgsWithError(message: string): Args {
+        const args = this.createArgs();
+        this.addError(message, args);
+        return args;
+    }
+
+    addInfo(message: string, args: Args): void {
+        args[this.INFO] = message;
+    }
+
+    addWarning(message: string, args: Args): void {
+        args[this.WARNING] = message;
+    }
+
+    addError(message: string, args: Args): void {
+        args[this.ERROR] = message;
+    }
+}

package/src/common/features/navigation/request-navigation-targets-action-handler.ts

@@ -0,0 +1,39 @@
+/********************************************************************************
+ * Copyright (c) 2022-2023 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, MaybePromise, NavigationTarget, RequestNavigationTargetsAction, SetNavigationTargetsAction } from '@eclipse-glsp/protocol';
+import { injectable } from 'inversify';
+import { inject } from 'inversify/lib/annotation/inject';
+import { ActionHandler } from '../../actions/action-handler';
+import { NavigationTargetProviderRegistry } from './navigation-target-provider-registry';
+
+@injectable()
+export class RequestNavigationTargetsActionHandler implements ActionHandler {
+    actionKinds = [RequestNavigationTargetsAction.KIND];
+
+    @inject(NavigationTargetProviderRegistry)
+    protected navigationTargetProviderRegistry: NavigationTargetProviderRegistry;
+
+    execute(action: RequestNavigationTargetsAction): MaybePromise<Action[]> {
+        const editorContext = action.editorContext;
+        const allTargets: NavigationTarget[] = [];
+        const provider = this.navigationTargetProviderRegistry.get(action.targetTypeId);
+        if (provider) {
+            const targets = provider.getTargets(editorContext);
+            targets.forEach(target => allTargets.push(target));
+        }
+        return [SetNavigationTargetsAction.create(allTargets, { args: editorContext.args })];
+    }
+}

package/src/common/features/navigation/resolve-navigation-targets-action-handler.ts

@@ -0,0 +1,42 @@
+/********************************************************************************
+ * Copyright (c) 2022-2023 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, ResolveNavigationTargetAction, SetResolvedNavigationTargetAction } from '@eclipse-glsp/protocol';
+import { inject, injectable, optional } from 'inversify';
+import { ActionHandler } from '../../actions/action-handler';
+import { Logger } from '../../utils/logger';
+import { NavigationTargetResolver } from './navigation-target-resolver';
+
+@injectable()
+export class ResolveNavigationTargetsActionHandler implements ActionHandler {
+    actionKinds = [ResolveNavigationTargetAction.KIND];
+
+    @inject(Logger)
+    protected logger: Logger;
+
+    @inject(NavigationTargetResolver)
+    @optional()
+    protected readonly navigationTargetResolver: NavigationTargetResolver;
+
+    async execute(action: ResolveNavigationTargetAction): Promise<Action[]> {
+        if (!this.navigationTargetResolver) {
+            this.logger.warn('Could not resolve navigation target. No implementation for: NavigationTargetResolver has been bound');
+            return [];
+        }
+        const target = action.navigationTarget;
+        const resolution = await this.navigationTargetResolver.resolve(target);
+        return [SetResolvedNavigationTargetAction.create(resolution.elementIds, { args: resolution.args })];
+    }
+}

package/src/common/features/popup/popup-model-factory.ts

@@ -0,0 +1,38 @@
+/********************************************************************************
+ * Copyright (c) 2022-2023 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 { GModelElement, GModelRoot } from '@eclipse-glsp/graph';
+import { RequestPopupModelAction } from '@eclipse-glsp/protocol';
+
+export const PopupModelFactory = Symbol('PopupModelFactory');
+
+/**
+ * A PopupModelFactory creates a popup model for the given element.
+ * A popup model is a {@link GHtmlRoot} that is self contained and not part of the diagram model.
+ * In contrast to diagram elements popup models typically don't contain dynamically rendered {@link GModelElement}s and
+ * use{@link GPreRenderedElement}s that contain server-side computed html or svg code instead.
+ */
+export interface PopupModelFactory {
+    /**
+     * Returns an {@link GModelRoot} for a given {@link GModelElement} triggered by a
+     * {@link RequestPopupModelAction}.
+     *
+     * @param element The element to create the popup model for.
+     * @param action  The {@link RequestPopupModelAction} that triggered this popup model creation.
+     * @returns An optional {@link GHtmlRoot} for a given {@link GModelElement}.
+     */
+    createPopupModel(element: GModelElement, action: RequestPopupModelAction): GModelRoot | undefined;
+}

package/src/common/features/popup/request-popup-model-action-handler.ts

@@ -0,0 +1,60 @@
+/********************************************************************************
+ * Copyright (c) 2022-2023 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, MaybePromise, RequestPopupModelAction, SetPopupModelAction } from '@eclipse-glsp/protocol';
+import { inject, injectable, optional } from 'inversify';
+import { ActionHandler } from '../../actions/action-handler';
+import { GLSPServerError } from '../../utils/glsp-server-error';
+import { Logger } from '../../utils/logger';
+import { GModelSerializer } from '../model/gmodel-serializer';
+import { ModelState } from '../model/model-state';
+import { PopupModelFactory } from './popup-model-factory';
+
+@injectable()
+export class RequestPopupModelActionHandler implements ActionHandler {
+    @inject(Logger)
+    protected logger: Logger;
+
+    @inject(PopupModelFactory)
+    @optional()
+    protected popupModelFactory?: PopupModelFactory;
+
+    @inject(ModelState)
+    protected modelState: ModelState;
+
+    @inject(GModelSerializer)
+    protected modelSerializer: GModelSerializer;
+
+    actionKinds = [RequestPopupModelAction.KIND];
+
+    execute(action: RequestPopupModelAction): MaybePromise<Action[]> {
+        if (this.popupModelFactory) {
+            const hoverElement = this.modelState.index.find(action.elementId);
+            if (hoverElement) {
+                const popupModel = this.popupModelFactory.createPopupModel(hoverElement, action);
+                if (popupModel) {
+                    const modelSchema = this.modelSerializer.createSchema(popupModel);
+                    return [SetPopupModelAction.create(modelSchema)];
+                }
+                return [];
+            }
+            throw new GLSPServerError(`Could not process 'RequestPopupModelAction'. Hover element with id ${action.elementId} not found`);
+        }
+        this.logger.warn('Could not process `RequestPopupModelAction`. No `PopupModelFactory` is bound');
+        return [];
+    }
+
+    priority?: number | undefined;
+}

package/src/common/features/validation/model-validator.ts

@@ -0,0 +1,34 @@
+/********************************************************************************
+ * Copyright (c) 2022-2023 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 { GModelElement } from '@eclipse-glsp/graph';
+import { Marker, MaybePromise } from '@eclipse-glsp/protocol';
+
+export const ModelValidator = Symbol('ModelValidator');
+
+/**
+ * Validates a list of {@link GModelElement}s based on a set of validation rules and returns corresponding issue
+ * {@link Marker}s.
+ * An issue marker is a serializable description of the validation violation that can be visualized by the GLSP client.
+ */
+export interface ModelValidator {
+    /**
+     * Validates the given list of {@link GModelElement}s and returns a list of {@link Marker}s.
+     *
+     * @param elements The list of {@link GModelElement} to validate.
+     * @returns A list of {@link Marker}s for the validated {@link GModelElement}s.
+     */
+    validate(elements: GModelElement[]): MaybePromise<Marker[]>;
+}

package/src/common/features/validation/request-markers-handler.ts

@@ -0,0 +1,51 @@
+/********************************************************************************
+ * Copyright (c) 2022-2023 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 { GGraph } from '@eclipse-glsp/graph';
+import { Action, Marker, RequestMarkersAction, SetMarkersAction } from '@eclipse-glsp/protocol';
+import { inject, injectable, optional } from 'inversify';
+import { ActionHandler } from '../../actions/action-handler';
+import { GLSPServerError } from '../../utils/glsp-server-error';
+import { ModelState } from '../model/model-state';
+import { ModelValidator } from './model-validator';
+
+@injectable()
+export class RequestMarkersHandler implements ActionHandler {
+    actionKinds = [RequestMarkersAction.KIND];
+
+    @inject(ModelValidator) @optional() validator: ModelValidator;
+    @inject(ModelState) modelState: ModelState;
+
+    async execute(action: RequestMarkersAction): Promise<Action[]> {
+        let elementIDs = action.elementsIDs;
+        if (!this.validator) {
+            throw new GLSPServerError('Cannot compute markers! No implementation for ModelValidator has been bound');
+        }
+
+        if (!elementIDs || elementIDs.length === 0 || (elementIDs.length === 1 && elementIDs[0] === 'EMPTY')) {
+            elementIDs = [this.modelState.root.id];
+        }
+
+        let markers: Marker[] = [];
+        const currentModelIndex = this.modelState.index;
+        for (const elementID of elementIDs) {
+            const modelElement = currentModelIndex.findByClass(elementID, GGraph);
+            if (modelElement) {
+                markers = markers.concat(await this.validator.validate([modelElement]));
+            }
+        }
+        return [SetMarkersAction.create(markers)];
+    }
+}

package/src/common/gmodel/README.md

@@ -0,0 +1,7 @@
+# Eclipse GLSP - Node Server
+
+## Direct GModel Library
+
+A collection of reusable base handlers and services to implement GLSP diagram languages directly use the graphical model as source model.
+This means the source model is a serializable representation of the graphical model. All operation and action handlers are operating
+directly on the graphical model.

package/src/common/gmodel/apply-label-edit-operation-handler.spec.ts

@@ -0,0 +1,40 @@
+/********************************************************************************
+ * Copyright (c) 2022-2023 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 { GLabel } from '@eclipse-glsp/graph';
+import { ApplyLabelEditOperation } from '@eclipse-glsp/protocol';
+import { expect } from 'chai';
+import * as sinon from 'sinon';
+import { GModelIndex } from '../features/model/gmodel-index';
+import { DefaultModelState } from '../features/model/model-state';
+import { ApplyLabelEditOperationHandler } from './apply-label-edit-operation-handler';
+
+import assert = require('assert');
+
+describe('Test ApplyLabelEditOperationHandler', () => {
+    const label = new GLabel();
+    const modelState = new DefaultModelState();
+    Object.defineProperty(modelState, 'index', { value: new GModelIndex() });
+    sinon.stub(modelState.index, 'findByClass').returns(label);
+    const applyLabelEditOperationHandler = new ApplyLabelEditOperationHandler();
+    Object.defineProperty(applyLabelEditOperationHandler, 'modelState', { value: modelState });
+
+    it('text is changed after ApplyLabelEditOperation', async () => {
+        assert.doesNotThrow(() =>
+            applyLabelEditOperationHandler.execute(ApplyLabelEditOperation.create({ labelId: 'myId', text: 'test' }))
+        );
+        expect(label.text).to.be.equal('test');
+    });
+});

package/src/common/gmodel/apply-label-edit-operation-handler.ts

@@ -0,0 +1,38 @@
+/********************************************************************************
+ * Copyright (c) 2022-2023 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 { GLabel } from '@eclipse-glsp/graph';
+import { ApplyLabelEditOperation, MaybePromise } from '@eclipse-glsp/protocol';
+import { inject, injectable } from 'inversify';
+import { ModelState } from '../features/model/model-state';
+import { OperationHandler } from '../operations/operation-handler';
+import { GLSPServerError } from '../utils/glsp-server-error';
+
+@injectable()
+export class ApplyLabelEditOperationHandler implements OperationHandler {
+    readonly operationType = ApplyLabelEditOperation.KIND;
+
+    @inject(ModelState)
+    protected readonly modelState: ModelState;
+
+    execute(operation: ApplyLabelEditOperation): MaybePromise<void> {
+        const element = this.modelState.index.findByClass(operation.labelId, GLabel);
+        if (element) {
+            element.text = operation.text;
+        } else {
+            throw new GLSPServerError('Element with provided ID cannot be found or is not a GLabel');
+        }
+    }
+}

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

@@ -0,0 +1,58 @@
+/********************************************************************************
+ * Copyright (c) 2022-2023 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 { 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';
+
+@injectable()
+export class ChangeBoundsOperationHandler implements OperationHandler {
+    operationType = ChangeBoundsOperation.KIND;
+
+    @inject(ModelState)
+    protected modelState: ModelState;
+
+    execute(operation: ChangeBoundsOperation): MaybePromise<void> {
+        for (const element of operation.newBounds) {
+            this.changeElementBounds(element.elementId, element.newSize, element.newPosition);
+        }
+    }
+
+    changeElementBounds(elementId: string, newSize: Dimension, newPosition: Point | undefined): void {
+        const index = this.modelState.index;
+        const nodeToUpdate = index.findByClass(elementId, GNode);
+        if (!nodeToUpdate) {
+            return;
+        }
+
+        const parent = nodeToUpdate.parent;
+        let positionToSet = { x: 0, y: 0 };
+        if (newPosition) {
+            positionToSet = parent instanceof GModelRoot ? newPosition : { x: Math.max(0, newPosition.x), y: Math.max(0, newPosition.y) };
+        }
+        if (nodeToUpdate.layout) {
+            if (!nodeToUpdate.layoutOptions) {
+                nodeToUpdate.layoutOptions = {};
+            }
+            nodeToUpdate.layoutOptions['prefWidth'] = newSize.width;
+            nodeToUpdate.layoutOptions['prefHeight'] = newSize.height;
+        }
+
+        nodeToUpdate.size = newSize;
+        nodeToUpdate.position = positionToSet;
+    }
+}

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

@@ -0,0 +1,39 @@
+/********************************************************************************
+ * 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 { 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 { GLSPServerError } from '../utils/glsp-server-error';
+import { applyRoutingPoints } from '../utils/layout-util';
+
+@injectable()
+export class ChangeRoutingPointsOperationHandler implements OperationHandler {
+    operationType = ChangeRoutingPointsOperation.KIND;
+
+    @inject(ModelState)
+    protected modelState: ModelState;
+
+    execute(operation: ChangeRoutingPointsOperation): MaybePromise<void> {
+        if (!operation.newRoutingPoints) {
+            throw new GLSPServerError('Incomplete change routingPoints  action');
+        }
+
+        const index = this.modelState.index;
+        operation.newRoutingPoints.forEach(routingPoints => applyRoutingPoints(routingPoints, index));
+    }
+}

package/src/common/gmodel/computed-bounds-action-handler.ts

@@ -0,0 +1,51 @@
+/********************************************************************************
+ * Copyright (c) 2022-2023 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 { GModelRoot } from '@eclipse-glsp/graph';
+import { Action, ComputedBoundsAction, MaybePromise } from '@eclipse-glsp/protocol';
+import { inject, injectable } from 'inversify';
+import { ActionHandler } from '../actions/action-handler';
+import { ModelState } from '../features/model/model-state';
+import { ModelSubmissionHandler } from '../features/model/model-submission-handler';
+import { applyAlignment, applyBounds, applyRoute } from '../utils/layout-util';
+
+@injectable()
+export class ComputedBoundsActionHandler implements ActionHandler {
+    @inject(ModelSubmissionHandler)
+    protected submissionHandler: ModelSubmissionHandler;
+
+    @inject(ModelState)
+    protected modelState: ModelState;
+
+    actionKinds = [ComputedBoundsAction.KIND];
+    execute(action: ComputedBoundsAction): MaybePromise<Action[]> {
+        const model = this.modelState.root;
+        if (action.revision === model.revision) {
+            this.applyBounds(model, action);
+            return this.submissionHandler.submitModelDirectly();
+        }
+
+        return [];
+    }
+
+    protected applyBounds(root: GModelRoot, action: ComputedBoundsAction): void {
+        const index = this.modelState.index;
+        action.bounds.forEach(bounds => applyBounds(bounds, index));
+        (action.alignments ?? []).forEach(alignment => applyAlignment(alignment, index));
+        (action.routes ?? []).forEach(route => applyRoute(route, index));
+    }
+
+    priority?: number | undefined;
+}