@eclipse-glsp/layout-elk 0.9.0-next.397cddd.4

package/lib/glsp-layout-configurator.d.ts

@@ -0,0 +1,43 @@
+/********************************************************************************
+ * Copyright (c) 2022 STMicroelectronics and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the Eclipse
+ * Public License v. 2.0 are satisfied: GNU General Public License, version 2
+ * with the GNU Classpath Exception which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ ********************************************************************************/
+import { LayoutOptions } from 'elkjs';
+import { DefaultLayoutConfigurator } from 'sprotty-elk';
+import { SGraph, SModelElement, SModelIndex } from 'sprotty-protocol';
+import { BasicTypeMapper } from './basic-type-mapper';
+/**
+ * Configurator for ELK layout algorithms; provides mappings of layout options for each model element.
+ * For a list of all available layout options checkout the official ELK documentation.
+ * A minimal configuration should at least specify the `elk.algorithm` option as
+ * return value of {@link GlspLayoutConfigurator.graphOptions}.
+ * {@link https://www.eclipse.org/elk/reference/options.html}
+ */
+export declare class GlspLayoutConfigurator extends DefaultLayoutConfigurator {
+    protected typeMapper: BasicTypeMapper;
+    protected getBasicType(smodel: SModelElement): string;
+}
+/**
+ * A fallback configurator that is used in the `configureELKLayoutModule` utility method.
+ * If no explicit layout configurator binding is provided a new instance of the fallback configurator is
+ * bound as replacement. Basic layout options for the root graph element are derived from the
+ * configuration parameters that haven been passed to the `configureELKLayoutModule` function.
+ */
+export declare class FallbackGlspLayoutConfigurator extends GlspLayoutConfigurator {
+    protected typeMapper: BasicTypeMapper;
+    protected fallbackGraphOptions: LayoutOptions;
+    constructor(typeMapper: BasicTypeMapper, algorithms: string[], defaultLayoutOptions?: LayoutOptions);
+    protected graphOptions(sgraph: SGraph, index: SModelIndex): LayoutOptions | undefined;
+}
+//# sourceMappingURL=glsp-layout-configurator.d.ts.map

package/lib/glsp-layout-configurator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"glsp-layout-configurator.d.ts","sourceRoot":"","sources":["../src/glsp-layout-configurator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;kFAckF;AAClF,OAAO,EAAE,aAAa,EAAE,MAAM,OAAO,CAAC;AAEtC,OAAO,EAAE,yBAAyB,EAAE,MAAM,aAAa,CAAC;AACxD,OAAO,EAAE,MAAM,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AACtE,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAEtD;;;;;;GAMG;AACH,qBACa,sBAAuB,SAAQ,yBAAyB;IAEjE,SAAS,CAAC,UAAU,EAAE,eAAe,CAAC;IAEtC,SAAS,CAAC,YAAY,CAAC,MAAM,EAAE,aAAa,GAAG,MAAM;CAGxD;AAED;;;;;GAKG;AACH,qBACa,8BAA+B,SAAQ,sBAAsB;IAE1D,SAAS,CAAC,UAAU,EAAE,eAAe;IADjD,SAAS,CAAC,oBAAoB,EAAE,aAAa,CAAC;gBACxB,UAAU,EAAE,eAAe,EAAE,UAAU,EAAE,MAAM,EAAE,EAAE,oBAAoB,GAAE,aAAkB;IAQjH,SAAS,CAAC,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,WAAW,GAAG,aAAa,GAAG,SAAS;CAGxF"}

package/lib/glsp-layout-configurator.js

@@ -0,0 +1,57 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FallbackGlspLayoutConfigurator = exports.GlspLayoutConfigurator = void 0;
+const inversify_1 = require("inversify");
+const sprotty_elk_1 = require("sprotty-elk");
+const basic_type_mapper_1 = require("./basic-type-mapper");
+/**
+ * Configurator for ELK layout algorithms; provides mappings of layout options for each model element.
+ * For a list of all available layout options checkout the official ELK documentation.
+ * A minimal configuration should at least specify the `elk.algorithm` option as
+ * return value of {@link GlspLayoutConfigurator.graphOptions}.
+ * {@link https://www.eclipse.org/elk/reference/options.html}
+ */
+let GlspLayoutConfigurator = class GlspLayoutConfigurator extends sprotty_elk_1.DefaultLayoutConfigurator {
+    getBasicType(smodel) {
+        return this.typeMapper.getBasicType(smodel);
+    }
+};
+__decorate([
+    inversify_1.inject(basic_type_mapper_1.BasicTypeMapper),
+    __metadata("design:type", basic_type_mapper_1.BasicTypeMapper)
+], GlspLayoutConfigurator.prototype, "typeMapper", void 0);
+GlspLayoutConfigurator = __decorate([
+    inversify_1.injectable()
+], GlspLayoutConfigurator);
+exports.GlspLayoutConfigurator = GlspLayoutConfigurator;
+/**
+ * A fallback configurator that is used in the `configureELKLayoutModule` utility method.
+ * If no explicit layout configurator binding is provided a new instance of the fallback configurator is
+ * bound as replacement. Basic layout options for the root graph element are derived from the
+ * configuration parameters that haven been passed to the `configureELKLayoutModule` function.
+ */
+let FallbackGlspLayoutConfigurator = class FallbackGlspLayoutConfigurator extends GlspLayoutConfigurator {
+    constructor(typeMapper, algorithms, defaultLayoutOptions = {}) {
+        super();
+        this.typeMapper = typeMapper;
+        this.fallbackGraphOptions = Object.assign({ 'elk.algorithm': algorithms[0] }, defaultLayoutOptions);
+    }
+    graphOptions(sgraph, index) {
+        return this.fallbackGraphOptions;
+    }
+};
+FallbackGlspLayoutConfigurator = __decorate([
+    inversify_1.injectable(),
+    __metadata("design:paramtypes", [basic_type_mapper_1.BasicTypeMapper, Array, Object])
+], FallbackGlspLayoutConfigurator);
+exports.FallbackGlspLayoutConfigurator = FallbackGlspLayoutConfigurator;
+//# sourceMappingURL=glsp-layout-configurator.js.map

package/lib/glsp-layout-configurator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"glsp-layout-configurator.js","sourceRoot":"","sources":["../src/glsp-layout-configurator.ts"],"names":[],"mappings":";;;;;;;;;;;;AAgBA,yCAA+C;AAC/C,6CAAwD;AAExD,2DAAsD;AAEtD;;;;;;GAMG;AAEH,IAAa,sBAAsB,GAAnC,MAAa,sBAAuB,SAAQ,uCAAyB;IAIvD,YAAY,CAAC,MAAqB;QACxC,OAAO,IAAI,CAAC,UAAU,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC;IAChD,CAAC;CACJ,CAAA;AALG;IADC,kBAAM,CAAC,mCAAe,CAAC;8BACF,mCAAe;0DAAC;AAF7B,sBAAsB;IADlC,sBAAU,EAAE;GACA,sBAAsB,CAOlC;AAPY,wDAAsB;AASnC;;;;;GAKG;AAEH,IAAa,8BAA8B,GAA3C,MAAa,8BAA+B,SAAQ,sBAAsB;IAEtE,YAAsB,UAA2B,EAAE,UAAoB,EAAE,uBAAsC,EAAE;QAC7G,KAAK,EAAE,CAAC;QADU,eAAU,GAAV,UAAU,CAAiB;QAE7C,IAAI,CAAC,oBAAoB,mBACrB,eAAe,EAAE,UAAU,CAAC,CAAC,CAAC,IAC3B,oBAAoB,CAC1B,CAAC;IACN,CAAC;IAES,YAAY,CAAC,MAAc,EAAE,KAAkB;QACrD,OAAO,IAAI,CAAC,oBAAoB,CAAC;IACrC,CAAC;CACJ,CAAA;AAbY,8BAA8B;IAD1C,sBAAU,EAAE;qCAGyB,mCAAe;GAFxC,8BAA8B,CAa1C;AAbY,wEAA8B"}

package/lib/index.d.ts

@@ -0,0 +1,23 @@
+/********************************************************************************
+ * Copyright (c) 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
+ * 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
+ ********************************************************************************/
+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 './glsp-elk-layout-engine';
+export * from './glsp-layout-configurator';
+//# sourceMappingURL=index.d.ts.map

package/lib/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;kFAckF;AAClF,cAAc,aAAa,CAAC;AAC5B,OAAO,EAAE,WAAW,EAAE,MAAM,wCAAwC,CAAC;AACrE,cAAc,qBAAqB,CAAC;AACpC,cAAc,aAAa,CAAC;AAC5B,cAAc,uBAAuB,CAAC;AACtC,cAAc,0BAA0B,CAAC;AACzC,cAAc,4BAA4B,CAAC"}

package/lib/index.js

@@ -0,0 +1,36 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !exports.hasOwnProperty(p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/********************************************************************************
+ * Copyright (c) 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
+ * 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
+ ********************************************************************************/
+__exportStar(require("sprotty-elk"), exports);
+var model_utils_1 = require("sprotty-protocol/lib/utils/model-utils");
+Object.defineProperty(exports, "SModelIndex", { enumerable: true, get: function () { return model_utils_1.SModelIndex; } });
+__exportStar(require("./basic-type-mapper"), exports);
+__exportStar(require("./di.config"), exports);
+__exportStar(require("./glsp-element-filter"), exports);
+__exportStar(require("./glsp-elk-layout-engine"), exports);
+__exportStar(require("./glsp-layout-configurator"), exports);
+//# sourceMappingURL=index.js.map

package/lib/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;AAAA;;;;;;;;;;;;;;kFAckF;AAClF,8CAA4B;AAC5B,sEAAqE;AAA5D,0GAAA,WAAW,OAAA;AACpB,sDAAoC;AACpC,8CAA4B;AAC5B,wDAAsC;AACtC,2DAAyC;AACzC,6DAA2C"}

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "@eclipse-glsp/layout-elk",
+  "version": "0.9.0-next.397cddd.4+397cddd",
+  "description": "Integration of ELK graph layout algorithms in GLSP Node Server",
+  "license": "(EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0)",
+  "keywords": [
+    "eclipse",
+    "graphics",
+    "diagram",
+    "modeling",
+    "visualization",
+    "glsp",
+    "diagram editor"
+  ],
+  "author": {
+    "name": "Eclipse GLSP"
+  },
+  "homepage": "https://www.eclipse.org/glsp/",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/eclipse-glsp/glsp-server-node.git"
+  },
+  "bugs": "https://github.com/eclipse-glsp/glsp/issues",
+  "contributors": [
+    {
+      "name": "STMicroelectronics",
+      "url": "https://www.st.com/"
+    },
+    {
+      "name": "Eclipse GLSP Project",
+      "email": "glsp-dev@eclipse.org",
+      "url": "https://projects.eclipse.org/projects/ecd.glsp"
+    }
+  ],
+  "files": [
+    "lib",
+    "src",
+    "css"
+  ],
+  "dependencies": {
+    "@eclipse-glsp/server-node": "0.9.0-next.397cddd.4+397cddd",
+    "elkjs": "^0.7.1",
+    "inversify": "^5.0.1",
+    "sprotty-elk": "next"
+  },
+  "scripts": {
+    "clean": "rimraf lib",
+    "build": "yarn run clean && tsc",
+    "test": "mocha --config ../../.mocharc.json \"./src/**/*.spec.?(ts|tsx)\"",
+    "test:ci": "export JUNIT_REPORT_PATH=./report.xml && yarn test --reporter mocha-jenkins-reporter",
+    "lint": "eslint -c ../../.eslintrc.js --ext .ts,.tsx ./src",
+    "lint:fix": "eslint --fix -c ../../.eslintrc.js --ext .ts,.tsx ./src",
+    "watch": "tsc -w"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "lib/index",
+  "types": "lib/index",
+  "gitHead": "397cddd532e9596bbe3717d931ae5ca826d949dd"
+}

package/src/basic-type-mapper.ts

@@ -0,0 +1,73 @@
+/********************************************************************************
+ * Copyright (c) 2022 STMicroelectronics and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the Eclipse
+ * Public License v. 2.0 are satisfied: GNU General Public License, version 2
+ * with the GNU Classpath Exception which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ ********************************************************************************/
+import { DiagramConfiguration, GEdge, GGraph, GLabel, GModelElementConstructor, GNode, GPort } from '@eclipse-glsp/server-node';
+import { inject, injectable, postConstruct } from 'inversify';
+import { SModelElement } from 'sprotty-protocol';
+
+export type BasicGModelType = 'graph' | 'node' | 'edge' | 'label' | 'port' | 'unknown';
+
+@injectable()
+/**
+ * The `BasicTypeMapper` provides the means to derive the basic type from a given graph model element.
+ * The basic type information is used by the `ElkLayoutEngine` to transform graphic model elements into their corresponding ELK object
+ * representation.
+ */
+export class BasicTypeMapper {
+    @inject(DiagramConfiguration)
+    protected diagramConfiguration: DiagramConfiguration;
+
+    protected basicTypeMap: Map<string, BasicGModelType>;
+
+    @postConstruct()
+    protected postConstruct(): void {
+        this.basicTypeMap = new Map();
+        this.diagramConfiguration.typeMapping.forEach((constructor, type) => {
+            const basicType = this.toBasicType(constructor);
+            if (basicType) {
+                this.basicTypeMap.set(type, basicType);
+            }
+        });
+    }
+
+    protected toBasicType(constructor: GModelElementConstructor): BasicGModelType {
+        const element = new constructor();
+        if (element instanceof GNode) {
+            return 'node';
+        } else if (element instanceof GEdge) {
+            return 'edge';
+        } else if (element instanceof GGraph) {
+            return 'graph';
+        } else if (element instanceof GLabel) {
+            return 'label';
+        } else if (element instanceof GPort) {
+            return 'port';
+        }
+        return 'unknown';
+    }
+
+    getBasicType(input: SModelElement | string): BasicGModelType {
+        const type = typeof input === 'string' ? input : input.type;
+        const basicType = this.basicTypeMap.get(type);
+        if (basicType) {
+            return basicType;
+        }
+        const subtypeSeparator = type.lastIndexOf(':');
+        if (subtypeSeparator > 0) {
+            return this.getBasicType(type.substring(0, subtypeSeparator));
+        }
+        return 'unknown';
+    }
+}

package/src/di.config.spec.ts

@@ -0,0 +1,92 @@
+/********************************************************************************
+ * Copyright (c) 2022 STMicroelectronics and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the Eclipse
+ * Public License v. 2.0 are satisfied: GNU General Public License, version 2
+ * with the GNU Classpath Exception which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ ********************************************************************************/
+import { DefaultModelState, DiagramConfiguration, 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 { configureELKLayoutModule } from './di.config';
+import { GlspElementFilter } from './glsp-element-filter';
+import { FallbackGlspLayoutConfigurator } from './glsp-layout-configurator';
+
+@injectable()
+class CustomLayoutConfigurator extends GlspLayoutConfigurator {}
+
+@injectable()
+class CustomElementFilter extends GlspElementFilter {}
+
+describe('test configureELKLayoutModule', () => {
+    const sandbox = sinon.createSandbox();
+    const mockDiagramConfiguration = new StubDiagramConfiguration();
+    const typeMappings = new Map<string, GModelElementConstructor>();
+
+    typeMappings.set('graph', GGraph);
+    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', () => {
+        const algorithm = 'layered';
+        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());
+        expect(graphOptions).not.to.be.undefined;
+        expect(graphOptions!['elk.algorithm']).to.equal(algorithm);
+    });
+
+    it('configure with additional default layout options', () => {
+        const algorithm = 'layered';
+        const defaultLayoutOptions = {
+            'elk.direction': 'LEFT',
+            'elk.edgeRouting': 'POLYLINE'
+        };
+        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());
+        expect(graphOptions).not.to.be.undefined;
+        expect(graphOptions).to.include(defaultLayoutOptions);
+    });
+
+    it('configure with custom layout configurator', () => {
+        const algorithm = 'layered';
+        const elkModule = configureELKLayoutModule({ algorithms: [algorithm], layoutConfigurator: CustomLayoutConfigurator });
+        const container = new Container();
+        container.load(baseModule, elkModule);
+        const configurator = container.get<ILayoutConfigurator>(ILayoutConfigurator);
+        expect(configurator).to.be.instanceOf(CustomLayoutConfigurator);
+    });
+
+    it('configure with custom element filter', () => {
+        const algorithm = 'layered';
+        const elkModule = configureELKLayoutModule({ algorithms: [algorithm], elementFilter: CustomElementFilter });
+        const container = new Container();
+        container.load(baseModule, elkModule);
+        const filter = container.get<IElementFilter>(IElementFilter);
+        expect(filter).to.be.instanceOf(CustomElementFilter);
+    });
+});

package/src/di.config.ts

@@ -0,0 +1,117 @@
+/********************************************************************************
+ * Copyright (c) 2022 STMicroelectronics and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the Eclipse
+ * Public License v. 2.0 are satisfied: GNU General Public License, version 2
+ * with the GNU Classpath Exception which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ ********************************************************************************/
+import { LayoutEngine } 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';
+
+type Constructor<T> = new (...args: any[]) => T;
+
+/**
+ * Configuration options for the {@link configureELKLayoutModule} function.
+ */
+export interface ElkModuleOptions {
+    /**
+     * The set of elk algorithms that is used by the {@link GlspElkLayoutEngine}.
+     */
+    algorithms: string[];
+    /**
+     * Additional default layout options. This options are passed to the underlying {@link ElkFactory}.
+     * In addition, they are used to configure the {@link FallbackGlspLayoutConfigurator}.
+     */
+    defaultLayoutOptions?: LayoutOptions;
+    /**
+     * The custom {@link GlspLayoutConfigurator} class that should be bound. If this option is not set
+     * the {@link FallbackGlspLayoutConfigurator} is bound instead.
+     */
+    layoutConfigurator?: Constructor<GlspLayoutConfigurator>;
+    /**
+     * The custom {@link GlspElementFilter} class that should be bound. If this option is not set, the default implementation
+     * is bound.
+     */
+    elementFilter?: Constructor<GlspElementFilter>;
+}
+
+/**
+ * Utility method to create a DI module that provides all necessary bindings to use the {@link GlspElkLayoutEngine} in a node GLSP server
+ * implementation. A set of configuration options is provided to enable easy customization. In most cases at least
+ * the custom {@link layoutConfigurator} binding should be provided (in addition to the required `algorithms' property) via these options.
+ *
+ * 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 LayoutEngine}
+ * - {@link ElkFactory}
+ *
+ * @param options The configuration options
+ * @returns A DI module that can be loaded as additional module when configuring a diagram module for a GLSP server.
+ */
+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();
+        } else {
+            bind(GlspElementFilter).toSelf().inSingletonScope();
+        }
+        bind(IElementFilter).toService(GlspElementFilter);
+
+        if (options.layoutConfigurator) {
+            bind(GlspLayoutConfigurator).to(options.layoutConfigurator);
+        } else {
+            bind(GlspLayoutConfigurator)
+                .toDynamicValue(context => {
+                    const typeMapper = context.container.get<BasicTypeMapper>(BasicTypeMapper);
+                    return new FallbackGlspLayoutConfigurator(typeMapper, options.algorithms, options.defaultLayoutOptions);
+                })
+                .inSingletonScope();
+        }
+        bind(ILayoutConfigurator).toService(GlspLayoutConfigurator);
+        bind(LayoutEngine).to(GlspElkLayoutEngine).inSingletonScope();
+
+        const elkFactory: ElkFactory = () =>
+            new ElkConstructor({
+                algorithms: options.algorithms,
+                defaultLayoutOptions: options.defaultLayoutOptions
+            });
+
+        bind(ElkFactory).toConstantValue(elkFactory);
+    });
+}

package/src/glsp-element-filter.ts

@@ -0,0 +1,38 @@
+/********************************************************************************
+ * Copyright (c) 2022 STMicroelectronics and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the Eclipse
+ * Public License v. 2.0 are satisfied: GNU General Public License, version 2
+ * with the GNU Classpath Exception which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ ********************************************************************************/
+import { inject, injectable } from 'inversify';
+import { DefaultElementFilter } from 'sprotty-elk';
+import { SModelElement } from 'sprotty-protocol';
+import { BasicTypeMapper } from './basic-type-mapper';
+
+/**
+ * The default `IElementFilter` used to determine which model elements should be included in the automatic layout.
+ * Without further configuration this filter includes all basic model elements (nodes,edges,labels,ports) that are
+ * part of the graphical model. For each 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 GlspElementFilter.filterNode})
+ *
+ */
+@injectable()
+export class GlspElementFilter extends DefaultElementFilter {
+    @inject(BasicTypeMapper)
+    protected typeMapper: BasicTypeMapper;
+
+    protected getBasicType(smodel: SModelElement): string {
+        return this.typeMapper.getBasicType(smodel);
+    }
+}

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

@@ -0,0 +1,57 @@
+/********************************************************************************
+ * Copyright (c) 2022 STMicroelectronics and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the Eclipse
+ * Public License v. 2.0 are satisfied: GNU General Public License, version 2
+ * with the GNU Classpath Exception which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ ********************************************************************************/
+import { 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';
+
+/**
+ * Layout engine that delegates to ELK by transforming the graphical model into an ELK graph.
+ */
+@injectable()
+export class BaseElkLayoutEngine extends ElkLayoutEngine {
+    constructor(
+        @inject(ElkFactory) elkFactory: ElkFactory,
+        @inject(IElementFilter) protected readonly filter: IElementFilter,
+        @inject(ILayoutConfigurator) protected readonly configurator: ILayoutConfigurator,
+        @inject(BasicTypeMapper) protected typeMapper: BasicTypeMapper
+    ) {
+        super(elkFactory, filter, configurator);
+    }
+
+    protected getBasicType(smodel: SModelElement): string {
+        return this.typeMapper.getBasicType(smodel);
+    }
+}
+
+/**
+ * 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;
+
+    @inject(BaseElkLayoutEngine)
+    protected elkLayoutEngine: BaseElkLayoutEngine;
+
+    async layout(): Promise<void> {
+        const graph = this.modelState.root;
+        await this.elkLayoutEngine.layout(graph);
+    }
+}