@eclipse-glsp/layout-elk 0.9.0-next.66aad6e.3 → 0.9.0-next.95961ba.7

package/src/di.config.spec.ts

@@ -13,23 +13,21 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { DefaultModelState, DiagramConfiguration, GGraph, GModelElementConstructor, ModelState } from '@eclipse-glsp/server-node';
+import { DefaultModelState, GGraph, GModelElementConstructor, ModelState } from '@eclipse-glsp/server-node';
 import { StubDiagramConfiguration } from '@eclipse-glsp/server-node/lib/test/mock-util';
 import { expect } from 'chai';
 import { Container, ContainerModule, injectable } from 'inversify';
 import * as sinon from 'sinon';
-import { IElementFilter, ILayoutConfigurator } from 'sprotty-elk';
-import { SModelIndex } from 'sprotty-protocol';
-import { GlspLayoutConfigurator } from '.';
+import { AbstractLayoutConfigurator } from '.';
 import { configureELKLayoutModule } from './di.config';
-import { GlspElementFilter } from './glsp-element-filter';
-import { FallbackGlspLayoutConfigurator } from './glsp-layout-configurator';
+import { DefaultElementFilter, ElementFilter } from './element-filter';
+import { FallbackLayoutConfigurator, LayoutConfigurator } from './layout-configurator';
 
 @injectable()
-class CustomLayoutConfigurator extends GlspLayoutConfigurator {}
+class CustomLayoutConfigurator extends AbstractLayoutConfigurator {}
 
 @injectable()
-class CustomElementFilter extends GlspElementFilter {}
+class CustomElementFilter extends DefaultElementFilter {}
 
 describe('test configureELKLayoutModule', () => {
     const sandbox = sinon.createSandbox();
@@ -40,7 +38,6 @@ describe('test configureELKLayoutModule', () => {
     sandbox.stub(mockDiagramConfiguration, 'typeMapping').value(typeMappings);
     const modelState = new DefaultModelState();
     const baseModule = new ContainerModule(bind => {
-        bind(DiagramConfiguration).toConstantValue(mockDiagramConfiguration);
         bind(ModelState).toConstantValue(modelState);
     });
     it('configure with minimal options', () => {
@@ -48,11 +45,11 @@ describe('test configureELKLayoutModule', () => {
         const elkModule = configureELKLayoutModule({ algorithms: [algorithm] });
         const container = new Container();
         container.load(baseModule, elkModule);
-        const filter = container.get<IElementFilter>(IElementFilter);
-        expect(filter).to.be.instanceOf(GlspElementFilter);
-        const configurator = container.get<ILayoutConfigurator>(ILayoutConfigurator);
-        expect(configurator).to.be.instanceOf(FallbackGlspLayoutConfigurator);
-        const graphOptions = configurator.apply(new GGraph(), new SModelIndex());
+        const filter = container.get<ElementFilter>(ElementFilter);
+        expect(filter).to.be.instanceOf(DefaultElementFilter);
+        const configurator = container.get<LayoutConfigurator>(LayoutConfigurator);
+        expect(configurator).to.be.instanceOf(FallbackLayoutConfigurator);
+        const graphOptions = configurator.apply(new GGraph());
         expect(graphOptions).not.to.be.undefined;
         expect(graphOptions!['elk.algorithm']).to.equal(algorithm);
     });
@@ -66,8 +63,8 @@ describe('test configureELKLayoutModule', () => {
         const elkModule = configureELKLayoutModule({ algorithms: [algorithm], defaultLayoutOptions });
         const container = new Container();
         container.load(baseModule, elkModule);
-        const configurator = container.get<ILayoutConfigurator>(ILayoutConfigurator);
-        const graphOptions = configurator.apply(new GGraph(), new SModelIndex());
+        const configurator = container.get<LayoutConfigurator>(LayoutConfigurator);
+        const graphOptions = configurator.apply(new GGraph());
         expect(graphOptions).not.to.be.undefined;
         expect(graphOptions).to.include(defaultLayoutOptions);
     });
@@ -77,7 +74,7 @@ describe('test configureELKLayoutModule', () => {
         const elkModule = configureELKLayoutModule({ algorithms: [algorithm], layoutConfigurator: CustomLayoutConfigurator });
         const container = new Container();
         container.load(baseModule, elkModule);
-        const configurator = container.get<ILayoutConfigurator>(ILayoutConfigurator);
+        const configurator = container.get<LayoutConfigurator>(LayoutConfigurator);
         expect(configurator).to.be.instanceOf(CustomLayoutConfigurator);
     });
 
@@ -86,7 +83,7 @@ describe('test configureELKLayoutModule', () => {
         const elkModule = configureELKLayoutModule({ algorithms: [algorithm], elementFilter: CustomElementFilter });
         const container = new Container();
         container.load(baseModule, elkModule);
-        const filter = container.get<IElementFilter>(IElementFilter);
+        const filter = container.get<ElementFilter>(ElementFilter);
         expect(filter).to.be.instanceOf(CustomElementFilter);
     });
 });

package/src/di.config.ts

@@ -13,15 +13,14 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { LayoutEngine } from '@eclipse-glsp/server-node/';
+import { LayoutEngine, ModelState } from '@eclipse-glsp/server-node';
 import ElkConstructor, { LayoutOptions } from 'elkjs/lib/elk.bundled';
 import { ContainerModule } from 'inversify';
-import { ElkFactory, ElkLayoutEngine, IElementFilter, ILayoutConfigurator } from 'sprotty-elk';
-import { GlspElkLayoutEngine } from '.';
-import { BasicTypeMapper } from './basic-type-mapper';
-import { GlspElementFilter } from './glsp-element-filter';
-import { BaseElkLayoutEngine } from './glsp-elk-layout-engine';
-import { FallbackGlspLayoutConfigurator, GlspLayoutConfigurator } from './glsp-layout-configurator';
+import { ElkFactory } from 'sprotty-elk';
+import { ElementFilter, LayoutConfigurator } from '.';
+import { DefaultElementFilter } from './element-filter';
+import { GlspElkLayoutEngine } from './glsp-elk-layout-engine';
+import { FallbackLayoutConfigurator } from './layout-configurator';
 
 type Constructor<T> = new (...args: any[]) => T;
 
@@ -39,15 +38,15 @@ export interface ElkModuleOptions {
      */
     defaultLayoutOptions?: LayoutOptions;
     /**
-     * The custom {@link GlspLayoutConfigurator} class that should be bound. If this option is not set
-     * the {@link FallbackGlspLayoutConfigurator} is bound instead.
+     * The custom {@link LayoutConfigurator} class that should be bound. If this option is not set
+     * the {@link FallbackLayoutConfigurator} is bound instead.
      */
-    layoutConfigurator?: Constructor<GlspLayoutConfigurator>;
+    layoutConfigurator?: Constructor<LayoutConfigurator>;
     /**
-     * The custom {@link GlspElementFilter} class that should be bound. If this option is not set, the default implementation
+     * The custom {@link ElementFilter} class that should be bound. If this option is not set, the default implementation
      * is bound.
      */
-    elementFilter?: Constructor<GlspElementFilter>;
+    elementFilter?: Constructor<ElementFilter>;
 }
 
 /**
@@ -58,13 +57,8 @@ export interface ElkModuleOptions {
  * The constructed module is not intended for standalone use cases and only works in combination with a GLSPDiagramModule.
  *
  * * The following bindings are provided:
- * - {@link BasicTypeMapper}
- * - {@link BaseElkLayoutEngine}
- * - {@link ElkLayoutEngine}
- * - {@link GlspElementFilter}
- * - {@link IElementFilter}
- * - {@link GlspLayoutConfigurator}
  * - {@link ILayoutConfigurator}
+ * - {@link IElementFilter}
  * - {@link LayoutEngine}
  * - {@link ElkFactory}
  *
@@ -73,38 +67,19 @@ export interface ElkModuleOptions {
  */
 export function configureELKLayoutModule(options: ElkModuleOptions): ContainerModule {
     return new ContainerModule(bind => {
-        bind(BasicTypeMapper).toSelf().inSingletonScope();
-        bind(BaseElkLayoutEngine)
-            .toDynamicValue(context => {
-                const elkFactory = context.container.get<ElkFactory>(ElkFactory);
-                const elementFilter = context.container.get<IElementFilter>(IElementFilter);
-                const layoutConfigurator = context.container.get<ILayoutConfigurator>(ILayoutConfigurator);
-                const typeMapper = context.container.get<BasicTypeMapper>(BasicTypeMapper);
-                return new BaseElkLayoutEngine(elkFactory, elementFilter, layoutConfigurator, typeMapper);
-            })
-            .inSingletonScope();
-
-        bind(ElkLayoutEngine).to(BaseElkLayoutEngine);
-
         if (options.elementFilter) {
-            bind(GlspElementFilter).to(options.elementFilter).inSingletonScope();
+            bind(ElementFilter).to(options.elementFilter).inSingletonScope();
         } else {
-            bind(GlspElementFilter).toSelf().inSingletonScope();
+            bind(ElementFilter).to(DefaultElementFilter).inSingletonScope();
         }
-        bind(IElementFilter).toService(GlspElementFilter);
 
         if (options.layoutConfigurator) {
-            bind(GlspLayoutConfigurator).to(options.layoutConfigurator);
+            bind(LayoutConfigurator).to(options.layoutConfigurator);
         } else {
-            bind(GlspLayoutConfigurator)
-                .toDynamicValue(context => {
-                    const typeMapper = context.container.get<BasicTypeMapper>(BasicTypeMapper);
-                    return new FallbackGlspLayoutConfigurator(typeMapper, options.algorithms, options.defaultLayoutOptions);
-                })
+            bind(LayoutConfigurator)
+                .toDynamicValue(context => new FallbackLayoutConfigurator(options.algorithms, options.defaultLayoutOptions))
                 .inSingletonScope();
         }
-        bind(ILayoutConfigurator).toService(GlspLayoutConfigurator);
-        bind(LayoutEngine).to(GlspElkLayoutEngine).inSingletonScope();
 
         const elkFactory: ElkFactory = () =>
             new ElkConstructor({
@@ -113,5 +88,17 @@ export function configureELKLayoutModule(options: ElkModuleOptions): ContainerMo
             });
 
         bind(ElkFactory).toConstantValue(elkFactory);
+
+        bind(GlspElkLayoutEngine)
+            .toDynamicValue(context => {
+                const container = context.container;
+                const factory = container.get<ElkFactory>(ElkFactory);
+                const filter = container.get<ElementFilter>(ElementFilter);
+                const configurator = container.get<LayoutConfigurator>(LayoutConfigurator);
+                const modelState = container.get<ModelState>(ModelState);
+                return new GlspElkLayoutEngine(factory, filter, configurator, modelState);
+            })
+            .inSingletonScope();
+        bind(LayoutEngine).toService(GlspElkLayoutEngine);
     });
 }

package/src/element-filter.ts

@@ -0,0 +1,84 @@
+/********************************************************************************
+ * Copyright (c) 2018-2022 TypeFox 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 { GEdge, GLabel, GModelElement, GNode, GPort, ModelState } from '@eclipse-glsp/server-node';
+import { inject, injectable } from 'inversify';
+
+export const ElementFilter = Symbol('ElementFilter');
+/**
+ * Filter used to determine which model elements should be included in the automatic layout.
+ */
+export interface ElementFilter {
+    /**
+     * Applies the element filter on the given element,
+     * @param element The element on which the filter should be applied.
+     * @returns `true` if the element should be included in the automatic layout, `false` otherwise.
+     */
+    apply(element: GModelElement): boolean;
+}
+
+/**
+ * Default implementation of {@link ElementFilter}.
+ * Without further configuration this filter includes all basic model elements (nodes,edges,labels,ports) that are
+ * part of the graphical model. For each basic type a custom filter behavior is in place.
+ * Edges that have no source or target are filtered out. In addition, edges that are connected to a filtered element are filtered out
+ * as well. The filter behavior for each of the basic types can be customized by overriding the corresponding `filter` method.
+ * (e.g. {@link DefaultElementFilter.filterNode})
+ */
+@injectable()
+export class DefaultElementFilter implements ElementFilter {
+    @inject(ModelState)
+    protected modelState: ModelState;
+
+    apply(element: GModelElement): boolean {
+        if (element instanceof GNode) {
+            return this.filterNode(element);
+        } else if (element instanceof GEdge) {
+            return this.filterEdge(element);
+        } else if (element instanceof GLabel) {
+            this.filterLabel(element);
+        } else if (element instanceof GPort) {
+            this.filterPort(element);
+        }
+        return true;
+    }
+
+    protected filterNode(node: GNode): boolean {
+        return true;
+    }
+
+    protected filterEdge(edge: GEdge): boolean {
+        const source = this.modelState.index.get(edge.sourceId);
+
+        if (!source || (source instanceof GNode && !this.filterNode(source)) || (source instanceof GPort && !this.filterPort(source))) {
+            return false;
+        }
+
+        const target = this.modelState.index.get(edge.targetId);
+
+        if (!target || (target instanceof GNode && !this.filterNode(target)) || (target instanceof GPort && !this.filterPort(target))) {
+            return false;
+        }
+        return true;
+    }
+
+    protected filterLabel(label: GLabel): boolean {
+        return true;
+    }
+
+    protected filterPort(port: GPort): boolean {
+        return true;
+    }
+}

package/src/glsp-elk-layout-engine.ts

@@ -1,6 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2022 STMicroelectronics and others.
- *
+ * Copyright (c) 2018-2022 TypeFox 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.
@@ -13,45 +12,321 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { LayoutEngine, ModelState } from '@eclipse-glsp/server-node';
-import { inject, injectable } from 'inversify';
-import { ElkFactory, ElkLayoutEngine, IElementFilter, ILayoutConfigurator } from 'sprotty-elk/lib/inversify';
-import { SModelElement } from 'sprotty-protocol/lib/model';
-import { BasicTypeMapper } from './basic-type-mapper';
+import {
+    findParent,
+    findParentByClass,
+    GCompartment,
+    GEdge,
+    GGraph,
+    GLabel,
+    GModelElement,
+    GModelElementConstructor,
+    GModelRoot,
+    GNode,
+    GPort,
+    GShapeElement,
+    LayoutEngine,
+    MaybePromise,
+    ModelState,
+    Point
+} from '@eclipse-glsp/server-node';
+import { ELK, ElkEdge, ElkExtendedEdge, ElkGraphElement, ElkLabel, ElkNode, ElkPort, ElkPrimitiveEdge, ElkShape } from 'elkjs/lib/elk-api';
+import { injectable } from 'inversify';
+import { ElkFactory } from 'sprotty-elk';
+import { ElementFilter } from './element-filter';
+import { LayoutConfigurator } from './layout-configurator';
 
 /**
- * Layout engine that delegates to ELK by transforming the graphical model into an ELK graph.
+ * An implementation of GLSP's {@link LayoutEngine} interface that retrieves the graphical model from the {@link ModelState},
+ * transforms this model into an ELK graph and then invokes the underlying ELK instance for layout computation.
  */
 @injectable()
-export class BaseElkLayoutEngine extends ElkLayoutEngine {
+export class GlspElkLayoutEngine implements LayoutEngine {
+    protected readonly elk: ELK;
+
+    protected elkEdges: ElkEdge[];
+    protected idToElkElement: Map<string, ElkGraphElement>;
+
     constructor(
-        @inject(ElkFactory) elkFactory: ElkFactory,
-        @inject(IElementFilter) protected readonly filter: IElementFilter,
-        @inject(ILayoutConfigurator) protected readonly configurator: ILayoutConfigurator,
-        @inject(BasicTypeMapper) protected typeMapper: BasicTypeMapper
+        elkFactory: ElkFactory,
+        protected readonly filter: ElementFilter,
+        protected readonly configurator: LayoutConfigurator,
+        protected modelState: ModelState
     ) {
-        super(elkFactory, filter, configurator);
+        this.elk = elkFactory();
     }
+    layout(): MaybePromise<GModelRoot> {
+        const root = this.modelState.root;
+        if (!(root instanceof GGraph)) {
+            return root;
+        }
 
-    protected getBasicType(smodel: SModelElement): string {
-        return this.typeMapper.getBasicType(smodel);
+        this.elkEdges = [];
+        this.idToElkElement = new Map();
+        const elkGraph = this.transformToElk(root) as ElkNode;
+        return this.elk.layout(elkGraph).then(result => {
+            this.applyLayout(result);
+            return root;
+        });
     }
-}
 
-/**
- * A implement of GLSP's {@link LayoutEngine} interface that retrieves the graphical model from the {@link ModelState}
- * and delegates the to an underlying {@link BaseElkLayoutEngine} instance for computing the layout.
- */
-@injectable()
-export class GlspElkLayoutEngine implements LayoutEngine {
-    @inject(ModelState)
-    protected modelState: ModelState;
+    protected transformToElk(model: GModelElement): ElkGraphElement {
+        if (model instanceof GGraph) {
+            const graph = this.transformGraph(model);
+            this.elkEdges.forEach(elkEdge => {
+                const parent = this.findCommonAncestor(elkEdge as ElkPrimitiveEdge);
+                if (parent) {
+                    parent.edges!.push(elkEdge);
+                }
+            });
+            return graph;
+        } else if (model instanceof GNode) {
+            return this.transformNode(model);
+        } else if (model instanceof GEdge) {
+            return this.transformEdge(model);
+        } else if (model instanceof GLabel) {
+            return this.transformPort(model);
+        } else if (model instanceof GPort) {
+            return this.transformPort(model);
+        }
+
+        throw new Error('Type not supported: ' + model.type);
+    }
+
+    /**
+     * Searches for all children of the given element that are an instance of the given {@link GModelElementConstructor}
+     * and are included by the {@link ElementFilter}. Also considers children that are nested inside of {@link GCompartment}s.
+     * @param element The element whose children should be queried.
+     * @param constructor The class instance that should be matched
+     * @returns A list of all matching children.
+     */
+    protected findChildren<G extends GModelElement>(element: GModelElement, constructor: GModelElementConstructor<G>): G[] {
+        const result: G[] = [];
+        element.children.forEach(child => {
+            if (child instanceof constructor && this.filter.apply(element)) {
+                result.push(child);
+            } else if (child instanceof GCompartment) {
+                result.push(...this.findChildren(child, constructor));
+            }
+        });
+
+        return result;
+    }
+
+    protected findCommonAncestor(elkEdge: ElkPrimitiveEdge): ElkNode | undefined {
+        const source = this.modelState.index.get(elkEdge.source);
+        const target = this.modelState.index.get(elkEdge.target);
+        if (!source || !target) {
+            return undefined;
+        }
+
+        const sourceParent = findParent(source.parent, parent => parent instanceof GNode || parent instanceof GGraph);
+        const targetParent = findParent(target.parent, parent => parent instanceof GNode || parent instanceof GGraph);
+
+        if (!sourceParent || !targetParent) {
+            return undefined;
+        }
+
+        if (sourceParent === targetParent) {
+            return this.idToElkElement.get(sourceParent.id);
+        } else if (source === targetParent) {
+            return this.idToElkElement.get(source.id);
+        } else if (target === sourceParent) {
+            return this.idToElkElement.get(target.id);
+        }
+        return undefined;
+    }
+
+    protected transformGraph(graph: GGraph): ElkGraphElement {
+        const elkGraph: ElkNode = {
+            id: graph.id,
+            layoutOptions: this.configurator.apply(graph)
+        };
+        if (graph.children) {
+            elkGraph.children = this.findChildren(graph, GNode).map(child => this.transformToElk(child)) as ElkNode[];
+            elkGraph.edges = [];
+            this.elkEdges.push(...(this.findChildren(graph, GEdge).map(child => this.transformToElk(child)) as ElkEdge[]));
+        }
+
+        this.idToElkElement.set(graph.id, elkGraph);
+        return elkGraph;
+    }
+
+    protected transformNode(node: GNode): ElkNode {
+        const elkNode: ElkNode = {
+            id: node.id,
+            layoutOptions: this.configurator.apply(node)
+        };
+
+        if (node.children) {
+            elkNode.children = this.findChildren(node, GNode).map(child => this.transformToElk(child)) as ElkNode[];
+            elkNode.edges = [];
+            this.elkEdges.push(...(this.findChildren(node, GEdge).map(child => this.transformToElk(child)) as ElkEdge[]));
+
+            elkNode.labels = this.findChildren(node, GLabel).map(child => this.transformToElk(child)) as ElkLabel[];
+            elkNode.ports = this.findChildren(node, GPort).map(child => this.transformToElk(child)) as ElkPort[];
+        }
+
+        this.transformShape(elkNode, node);
+        this.idToElkElement.set(node.id, elkNode);
+
+        return elkNode;
+    }
+
+    protected transformShape(elkShape: ElkShape, shape: GShapeElement): void {
+        if (shape.position) {
+            elkShape.x = shape.position.x;
+            elkShape.y = shape.position.y;
+        }
+        if (shape.size) {
+            elkShape.width = shape.size.width;
+            elkShape.height = shape.size.height;
+        }
+    }
+
+    protected transformEdge(edge: GEdge): ElkEdge {
+        const elkEdge: ElkPrimitiveEdge = {
+            id: edge.id,
+            source: edge.sourceId,
+            target: edge.targetId,
+            layoutOptions: this.configurator.apply(edge)
+        };
+        const sourceElement = this.modelState.index.get(edge.sourceId);
+        if (sourceElement instanceof GPort) {
+            const parentNode = findParentByClass(sourceElement, GNode);
+            if (parentNode) {
+                elkEdge.source = parentNode.id;
+                elkEdge.sourcePort = sourceElement.id;
+            }
+        }
+
+        const targetElement = this.modelState.index.get(edge.targetId);
+        if (sourceElement instanceof GPort) {
+            const parentNode = findParentByClass(targetElement, GNode);
+            if (parentNode) {
+                elkEdge.target = parentNode.id;
+                elkEdge.targetPort = targetElement.id;
+            }
+        }
+
+        if (edge.children) {
+            elkEdge.labels = this.findChildren(edge, GLabel).map(child => this.transformToElk(child)) as ElkLabel[];
+        }
+        const points = edge.routingPoints;
+        if (points && points.length >= 2) {
+            elkEdge.sourcePoint = points[0];
+            elkEdge.bendPoints = points.slice(1, points.length - 1);
+            elkEdge.targetPoint = points[points.length - 1];
+        }
+        this.idToElkElement.set(edge.id, elkEdge);
+        return elkEdge;
+    }
+
+    protected transformLabel(label: GLabel): ElkLabel {
+        const elkLabel: ElkLabel = {
+            id: label.id,
+            text: label.text,
+            layoutOptions: this.configurator.apply(label)
+        };
+        this.transformShape(elkLabel, label);
+        this.idToElkElement.set(label.id, elkLabel);
+        return elkLabel;
+    }
+
+    protected transformPort(port: GPort): ElkPort {
+        const elkPort: ElkPort = {
+            id: port.id,
+            layoutOptions: this.configurator.apply(port)
+        };
+        if (port.children) {
+            elkPort.labels = this.findChildren(port, GLabel).map(child => this.transformToElk(child)) as ElkLabel[];
+        }
+        this.transformShape(elkPort, port);
+        this.idToElkElement.set(port.id, elkPort);
+        return elkPort;
+    }
+
+    protected applyLayout(elkNode: ElkNode): void {
+        const element = this.modelState.index.get(elkNode.id);
+        if (element instanceof GNode) {
+            this.applyShape(element, elkNode);
+        }
+        if (elkNode.children) {
+            for (const child of elkNode.children) {
+                this.applyLayout(child);
+            }
+        }
+        if (elkNode.edges) {
+            for (const elkEdge of elkNode.edges) {
+                const edge = this.modelState.index.get(elkEdge.id);
+                if (edge instanceof GEdge) {
+                    this.applyEdge(edge, elkEdge);
+                }
+            }
+        }
+
+        if (elkNode.ports) {
+            for (const elkPort of elkNode.ports) {
+                const port = this.modelState.index.findByClass(elkPort.id, GPort);
+                if (port) {
+                    this.applyShape(port, elkPort);
+                }
+            }
+        }
+    }
+
+    protected applyShape(shape: GShapeElement, elkShape: ElkShape): void {
+        if (elkShape.x !== undefined && elkShape.y !== undefined) {
+            shape.position = { x: elkShape.x, y: elkShape.y };
+        }
+        if (elkShape.width !== undefined && elkShape.height !== undefined) {
+            shape.size = { width: elkShape.width, height: elkShape.height };
+        }
+
+        if (elkShape.labels) {
+            for (const elkLabel of elkShape.labels) {
+                const label = this.modelState.index.findByClass(elkLabel.id, GLabel);
+                if (label) {
+                    this.applyShape(label, elkLabel);
+                }
+            }
+        }
+    }
 
-    @inject(BaseElkLayoutEngine)
-    protected elkLayoutEngine: BaseElkLayoutEngine;
+    protected applyEdge(edge: GEdge, elkEdge: ElkEdge): void {
+        const points: Point[] = [];
+        if ((elkEdge as any).sections && (elkEdge as any).sections.length > 0) {
+            const section = (elkEdge as ElkExtendedEdge).sections[0];
+            if (section.startPoint) {
+                points.push(section.startPoint);
+            }
+            if (section.bendPoints) {
+                points.push(...section.bendPoints);
+            }
+            if (section.endPoint) {
+                points.push(section.endPoint);
+            }
+        } else {
+            const section = elkEdge as ElkPrimitiveEdge;
+            if (section.sourcePoint) {
+                points.push(section.sourcePoint);
+            }
+            if (section.bendPoints) {
+                points.push(...section.bendPoints);
+            }
+            if (section.targetPoint) {
+                points.push(section.targetPoint);
+            }
+        }
+        edge.routingPoints = points;
 
-    async layout(): Promise<void> {
-        const graph = this.modelState.root;
-        await this.elkLayoutEngine.layout(graph);
+        if (elkEdge.labels) {
+            elkEdge.labels.forEach(elkLabel => {
+                const label = this.modelState.index.findByClass(elkLabel.id, GLabel);
+                if (label) {
+                    this.applyShape(label, elkLabel);
+                }
+            });
+        }
     }
 }

package/src/index.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2022 EclipseSource and others.
+ * 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
@@ -13,10 +13,8 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-export * from 'sprotty-elk';
-export { SModelIndex } from 'sprotty-protocol/lib/utils/model-utils';
-export * from './basic-type-mapper';
 export * from './di.config';
-export * from './glsp-element-filter';
+export * from './element-filter';
 export * from './glsp-elk-layout-engine';
-export * from './glsp-layout-configurator';
+export * from './layout-configurator';
+export * from './sprotty-elk';