@eclipse-glsp/client 1.1.0-next.fdfeeeb.193 → 2.0.0

package/src/features/decoration/decoration-placer.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2020-2022 EclipseSource and others.
+ * Copyright (c) 2019-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
@@ -13,16 +13,15 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { Point } from '@eclipse-glsp/protocol';
 import { injectable } from 'inversify';
-import { Decoration, DecorationPlacer, isSizeable, SChildElement, SModelElement, SRoutableElement } from 'sprotty';
+import { Decoration, DecorationPlacer, GChildElement, Point, GModelElement, GRoutableElement, isSizeable } from '@eclipse-glsp/sprotty';
 
 @injectable()
 export class GlspDecorationPlacer extends DecorationPlacer {
     protected static readonly DECORATION_OFFSET: Point = { x: 12, y: 10 };
 
-    protected override getPosition(element: SModelElement & Decoration): Point {
-        if (element instanceof SChildElement && element.parent instanceof SRoutableElement) {
+    protected override getPosition(element: GModelElement & Decoration): Point {
+        if (element instanceof GChildElement && element.parent instanceof GRoutableElement) {
             return super.getPosition(element);
         }
         if (isSizeable(element)) {

package/src/features/export/export-modules.ts

@@ -0,0 +1,50 @@
+/********************************************************************************
+ * Copyright (c) 2019-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 {
+    bindAsService,
+    configureActionHandler,
+    configureCommand,
+    ExportSvgAction,
+    ExportSvgCommand,
+    ExportSvgKeyListener,
+    ExportSvgPostprocessor,
+    FeatureModule,
+    TYPES
+} from '@eclipse-glsp/sprotty';
+import { ExportSvgActionHandler } from './export-svg-action-handler';
+import { GLSPSvgExporter } from './glsp-svg-exporter';
+
+export const exportModule = new FeatureModule((bind, _unbind, isBound) => {
+    const context = { bind, isBound };
+    bindAsService(context, TYPES.HiddenVNodePostprocessor, ExportSvgPostprocessor);
+    configureCommand(context, ExportSvgCommand);
+    bind(TYPES.SvgExporter).to(GLSPSvgExporter).inSingletonScope();
+});
+
+/**
+ * Feature module that is intended for the standalone deployment of GLSP (i.e. plain webapp)
+ * When integrated into an application frame (e.g Theia/VS Code) this module is typically omitted and/or replaced
+ * with an application native module.
+ */
+export const standaloneExportModule = new FeatureModule(
+    (bind, _unbind, isBound) => {
+        const context = { bind, isBound };
+        bindAsService(context, TYPES.KeyListener, ExportSvgKeyListener);
+        bind(ExportSvgActionHandler).toSelf().inSingletonScope();
+        configureActionHandler(context, ExportSvgAction.KIND, ExportSvgActionHandler);
+    },
+    { requires: exportModule }
+);

package/src/features/export/export-svg-action-handler.ts

@@ -0,0 +1,32 @@
+/********************************************************************************
+ * Copyright (c) 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 { saveAs } from 'file-saver';
+import { injectable } from 'inversify';
+import { ExportSvgAction, IActionHandler } from '@eclipse-glsp/sprotty';
+
+/**
+ * The default handler for {@link ExportSvgAction}s. This generic handler can be used in
+ * any GLSP project independent of the target platform. However, platform integration modules typically
+ *  * this handler is rebound to an application specific handler in platform integration modules
+ * (e.g. the Theia integration)
+ */
+@injectable()
+export class ExportSvgActionHandler implements IActionHandler {
+    handle(action: ExportSvgAction): void {
+        const blob = new Blob([action.svg], { type: 'text/plain;charset=utf-8' });
+        saveAs(blob, 'diagram.svg');
+    }
+}

package/src/features/export/glsp-svg-exporter.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2022 EclipseSource and others.
+ * 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
@@ -13,14 +13,13 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { RequestAction } from '@eclipse-glsp/protocol';
 import { injectable } from 'inversify';
-import { ExportSvgAction, SModelRoot, SvgExporter } from 'sprotty';
 import { v4 as uuid } from 'uuid';
+import { ExportSvgAction, RequestAction, GModelRoot, SvgExporter } from '@eclipse-glsp/sprotty';
 
- @injectable()
- export class GLSPSvgExporter extends SvgExporter {
-    override export(root: SModelRoot, _request?: RequestAction<ExportSvgAction>): void {
+@injectable()
+export class GLSPSvgExporter extends SvgExporter {
+    override export(root: GModelRoot, _request?: RequestAction<ExportSvgAction>): void {
         if (typeof document !== 'undefined') {
             const svgElement = this.findSvgElement();
             if (svgElement) {
@@ -30,11 +29,12 @@ import { v4 as uuid } from 'uuid';
                     svgElement.id = originalId || uuid();
                     // provide generated svg code with respective sizing for proper viewing in browser and remove undesired border
                     const bounds = this.getBounds(root);
-                    const svg = this.createSvg(svgElement, root)
-                        .replace('style="',
-                            `style="width: ${bounds.width}px !important;height: ${bounds.height}px !important;border: none !important;`);
+                    const svg = this.createSvg(svgElement, root).replace(
+                        'style="',
+                        `style="width: ${bounds.width}px !important;height: ${bounds.height}px !important;border: none !important;`
+                    );
                     // do not give request/response id here as otherwise the action is treated as an unrequested response
-                    this.actionDispatcher.dispatch(ExportSvgAction.create(svg, ''));
+                    this.actionDispatcher.dispatch(ExportSvgAction.create(svg));
                 } finally {
                     svgElement.id = originalId;
                 }
@@ -47,4 +47,4 @@ import { v4 as uuid } from 'uuid';
         // search for first svg element as hierarchy within Sprotty might change
         return div && div.querySelector('svg');
     }
- }
+}

package/src/features/hints/model.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2019-2021 EclipseSource and others.
+ * Copyright (c) 2019-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
@@ -13,23 +13,28 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { SModelElementSchema } from '@eclipse-glsp/protocol';
-import { SModelElement, SModelExtension } from 'sprotty';
+import { GModelElement, GModelElementSchema } from '@eclipse-glsp/sprotty';
 
 export const containerFeature = Symbol('containable');
 
-export interface Containable extends SModelExtension {
-    isContainableElement(input: SModelElement | SModelElementSchema | string): boolean;
+/**
+ *  Feature extension interface for {@link containerFeature}.
+ */
+export interface Containable {
+    isContainableElement(input: GModelElement | GModelElementSchema | string): boolean;
 }
 
-export function isContainable(element: SModelElement): element is SModelElement & Containable {
+export function isContainable(element: GModelElement): element is GModelElement & Containable {
     return element.hasFeature(containerFeature);
 }
 
 export const reparentFeature = Symbol('reparentFeature');
 
-export interface Reparentable extends SModelExtension {}
+/**
+ *  Feature extension interface for {@link reparentFeature}.
+ */
+export interface Reparentable {}
 
-export function isReparentable(element: SModelElement): element is SModelElement & Reparentable {
+export function isReparentable(element: GModelElement): element is GModelElement & Reparentable {
     return element.hasFeature(reparentFeature);
 }

package/src/features/hints/type-hint-provider.spec.ts

@@ -0,0 +1,355 @@
+/********************************************************************************
+ * Copyright (c) 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 {
+    AnimationFrameSyncer,
+    CommandExecutionContext,
+    ConsoleLogger,
+    EdgeTypeHint,
+    GChildElement,
+    GModelFactory,
+    GModelRoot,
+    GNode,
+    SetTypeHintsAction,
+    ShapeTypeHint,
+    TYPES,
+    Writable,
+    bindOrRebind,
+    createFeatureSet,
+    editFeature,
+    isDeletable,
+    isMoveable
+} from '@eclipse-glsp/sprotty';
+import { expect } from 'chai';
+import { Container } from 'inversify';
+import * as sinon from 'sinon';
+import { GLSPActionDispatcher } from '../../base/action-dispatcher';
+import { FeedbackActionDispatcher } from '../../base/feedback/feedback-action-dispatcher';
+import { GEdge } from '../../model';
+import { isResizable } from '../change-bounds/model';
+import { isReconnectable } from '../reconnect/model';
+import { Containable, isContainable, isReparentable } from './model';
+import { ApplyTypeHintsAction, ApplyTypeHintsCommand, ITypeHintProvider, TypeHintProvider } from './type-hint-provider';
+describe('TypeHintProvider', () => {
+    const container = new Container();
+    container.bind(GLSPActionDispatcher).toConstantValue(sinon.createStubInstance(GLSPActionDispatcher));
+    container.bind(TYPES.IFeedbackActionDispatcher).toConstantValue(sinon.createStubInstance(FeedbackActionDispatcher));
+    const typeHintProvider = container.resolve(TypeHintProvider);
+
+    describe('getShapeTypeHint', () => {
+        const nodeHint: ShapeTypeHint = {
+            deletable: true,
+            elementTypeId: 'node',
+            reparentable: false,
+            repositionable: true,
+            resizable: true
+        };
+        const taskHint: ShapeTypeHint = {
+            deletable: true,
+            elementTypeId: 'node:task',
+            reparentable: false,
+            repositionable: true,
+            resizable: true
+        };
+
+        it('should return `undefined` if no `SetTypeHintsAction` has been handled yet', () => {
+            expect(typeHintProvider.getShapeTypeHint('some')).to.be.undefined;
+        });
+        it('should return `undefined` if no hint is registered for the given type (exact type match)', () => {
+            typeHintProvider.handle(SetTypeHintsAction.create({ shapeHints: [nodeHint], edgeHints: [] }));
+            expect(typeHintProvider.getShapeTypeHint('port')).to.be.undefined;
+        });
+        it('should return the corresponding type hint for the given type (exact type match)', () => {
+            typeHintProvider.handle(SetTypeHintsAction.create({ shapeHints: [nodeHint, taskHint], edgeHints: [] }));
+            expect(typeHintProvider.getShapeTypeHint('node')).to.equal(nodeHint);
+            expect(typeHintProvider.getShapeTypeHint('node:task')).to.equal(taskHint);
+        });
+        it('should return the corresponding type hint for the given type (sub type match)', () => {
+            typeHintProvider.handle(SetTypeHintsAction.create({ shapeHints: [nodeHint, taskHint], edgeHints: [] }));
+            expect(typeHintProvider.getShapeTypeHint('node:task:manual')).to.equal(taskHint);
+            expect(typeHintProvider.getShapeTypeHint('node:task:manual:foo')).to.equal(taskHint);
+            expect(typeHintProvider.getShapeTypeHint('node:event')).to.equal(nodeHint);
+            expect(typeHintProvider.getShapeTypeHint('node:event:initial')).to.equal(nodeHint);
+        });
+    });
+    describe('getEdgeTypeHint', () => {
+        const edgeHint: EdgeTypeHint = {
+            deletable: true,
+            elementTypeId: 'edge',
+            repositionable: true,
+            routable: true,
+            dynamic: false
+        };
+        const fooEdgeHint: EdgeTypeHint = {
+            deletable: true,
+            elementTypeId: 'edge:foo',
+            repositionable: true,
+            routable: true,
+            dynamic: true
+        };
+        it('should return `undefined` if no `SetTypeHintsAction` has been handled yet', () => {
+            expect(typeHintProvider.getEdgeTypeHint('some')).to.be.undefined;
+        });
+        it('should return `undefined` if no hint is registered for the given type (exact type match)', () => {
+            typeHintProvider.handle(SetTypeHintsAction.create({ shapeHints: [], edgeHints: [edgeHint] }));
+            expect(typeHintProvider.getEdgeTypeHint('link')).to.be.undefined;
+        });
+        it('should return the corresponding type hint for the given type (exact type match)', () => {
+            typeHintProvider.handle(SetTypeHintsAction.create({ shapeHints: [], edgeHints: [edgeHint, fooEdgeHint] }));
+            expect(typeHintProvider.getEdgeTypeHint('edge')).to.equal(edgeHint);
+            expect(typeHintProvider.getEdgeTypeHint('edge:foo')).to.equal(fooEdgeHint);
+        });
+        it('should return the corresponding type hint for the given type (sub type match)', () => {
+            typeHintProvider.handle(SetTypeHintsAction.create({ shapeHints: [], edgeHints: [edgeHint, fooEdgeHint] }));
+            expect(typeHintProvider.getEdgeTypeHint('edge:foo:bar')).to.equal(fooEdgeHint);
+            expect(typeHintProvider.getEdgeTypeHint('edge:foo:bar:baz')).to.equal(fooEdgeHint);
+            expect(typeHintProvider.getEdgeTypeHint('edge:some')).to.equal(edgeHint);
+            expect(typeHintProvider.getEdgeTypeHint('edge:some:other')).to.equal(edgeHint);
+        });
+    });
+});
+describe('ApplyTypeHintCommand', () => {
+    function createCommandExecutionContext(child: GChildElement): CommandExecutionContext {
+        const root = new GModelRoot();
+        root.id = 'root';
+        root.type = 'root';
+        root.add(child);
+        return {
+            root,
+            modelFactory,
+            duration: 0,
+            modelChanged: undefined!,
+            logger: new ConsoleLogger(),
+            syncer: new AnimationFrameSyncer()
+        };
+    }
+
+    function createNode(type?: string): GNode {
+        const node = new GNode();
+        node.type = type ?? 'node';
+        node.id = 'node';
+        node.features = createFeatureSet(GNode.DEFAULT_FEATURES);
+        return node;
+    }
+
+    function createEdge(type?: string): GEdge {
+        const edge = new GEdge();
+        edge.type = type ?? 'edge';
+        edge.id = 'edge';
+        edge.features = createFeatureSet(GEdge.DEFAULT_FEATURES);
+        return edge;
+    }
+
+    const sandbox = sinon.createSandbox();
+    const container = new Container();
+    const modelFactory = sinon.createStubInstance(GModelFactory);
+    const typeHintProviderMock = sandbox.stub<ITypeHintProvider>({
+        getEdgeTypeHint: () => undefined,
+        getShapeTypeHint: () => undefined
+    });
+    container.bind(GLSPActionDispatcher).toConstantValue(sandbox.createStubInstance(GLSPActionDispatcher));
+    container.bind(TYPES.IFeedbackActionDispatcher).toConstantValue(sandbox.createStubInstance(FeedbackActionDispatcher));
+    container.bind(TYPES.ITypeHintProvider).toConstantValue(typeHintProviderMock);
+    bindOrRebind(container, TYPES.Action).toConstantValue(ApplyTypeHintsAction.create());
+    const command = container.resolve(ApplyTypeHintsCommand);
+
+    beforeEach(() => {
+        sandbox.reset();
+    });
+
+    describe('test hints to model feature translation (after command execution)`', () => {
+        describe('ShapeTypeHint', () => {
+            const allEnabledHint: ShapeTypeHint = {
+                elementTypeId: 'node',
+                deletable: true,
+                reparentable: true,
+                repositionable: true,
+                resizable: true,
+                containableElementTypeIds: []
+            };
+            const allDisabledHint: ShapeTypeHint = {
+                elementTypeId: 'node',
+                deletable: false,
+                reparentable: false,
+                repositionable: false,
+                resizable: false,
+                containableElementTypeIds: []
+            };
+            it('should not modify feature set of model element with no applicable type hint', () => {
+                typeHintProviderMock.getShapeTypeHint.returns(undefined);
+                const result = command.execute(createCommandExecutionContext(createNode()));
+                const element = result.children[0];
+                expect(GNode.DEFAULT_FEATURES, 'Element should have default feature set').to.have.same.members([
+                    ...(element.features as Set<symbol>)
+                ]);
+            });
+            it('should add all enabled (`true`) features, derived from the applied type hint, to the model', () => {
+                typeHintProviderMock.getShapeTypeHint.returns(allEnabledHint);
+                const result = command.execute(createCommandExecutionContext(createNode()));
+                const element = result.children[0];
+                expect(isDeletable(element), 'Element should have deletable feature').to.be.true;
+                expect(isReparentable(element), 'Element should have reparentable feature').to.be.true;
+                expect(isMoveable(element), 'Element should have moveable feature').to.be.true;
+                expect(isContainable(element), 'Element should have containable feature').to.be.true;
+                expect(isResizable(element), 'Element should have resizeable feature').to.be.true;
+            });
+            it('should remove all disabled (`false`) features, derived from the applied type hint, from the model', () => {
+                typeHintProviderMock.getShapeTypeHint.returns(allDisabledHint);
+                const result = command.execute(createCommandExecutionContext(createNode()));
+                const element = result.children[0];
+                expect(isDeletable(element), 'Element should not have deletable feature').to.be.false;
+                expect(isReparentable(element), 'Element should  not have reparentable feature').to.be.false;
+                expect(isMoveable(element), 'Element should  not have moveable feature').to.be.false;
+                expect(isResizable(element), 'Element should not have resizeable feature').to.be.false;
+            });
+            describe('`isConnectable` (after hint has been applied to element)', () => {
+                const shapeHint: Writable<ShapeTypeHint> = {
+                    deletable: false,
+                    elementTypeId: 'node',
+                    reparentable: false,
+                    repositionable: false,
+                    resizable: false
+                };
+                const edgeHint: Writable<EdgeTypeHint> = {
+                    deletable: false,
+                    elementTypeId: 'edge',
+                    repositionable: false,
+                    routable: false
+                };
+                it('should return `true` if source/target elements are not defined in edge hint', () => {
+                    typeHintProviderMock.getShapeTypeHint.returns(shapeHint);
+                    typeHintProviderMock.getEdgeTypeHint.returns(edgeHint);
+                    const result = command.execute(createCommandExecutionContext(createNode()));
+                    const element = result.children[0] as GNode;
+                    const edge = createEdge();
+                    expect(element.canConnect(edge, 'source')).to.be.true;
+                    expect(element.canConnect(edge, 'target')).to.be.true;
+                });
+                it('should return `false` if element type is not in source/target elements of edge hint', () => {
+                    typeHintProviderMock.getShapeTypeHint.returns(shapeHint);
+                    typeHintProviderMock.getEdgeTypeHint.returns(edgeHint);
+                    edgeHint.sourceElementTypeIds = [];
+                    edgeHint.targetElementTypeIds = [];
+                    const result = command.execute(createCommandExecutionContext(createNode()));
+                    const element = result.children[0] as GNode;
+                    const edge = createEdge();
+                    expect(element.canConnect(edge, 'source')).to.be.false;
+                    expect(element.canConnect(edge, 'target')).to.be.false;
+                });
+                it('should return `true` if element type is in source/target elements of edge hint (exact type)', () => {
+                    typeHintProviderMock.getShapeTypeHint.returns(shapeHint);
+                    typeHintProviderMock.getEdgeTypeHint.returns(edgeHint);
+                    edgeHint.sourceElementTypeIds = ['node'];
+                    edgeHint.targetElementTypeIds = ['node'];
+                    const result = command.execute(createCommandExecutionContext(createNode()));
+                    const element = result.children[0] as GNode;
+                    const edge = createEdge();
+                    expect(element.canConnect(edge, 'source')).to.be.true;
+                    expect(element.canConnect(edge, 'target')).to.be.true;
+                });
+                it('should return `true` if element super type is in source/target elements of edge hint (super type)', () => {
+                    typeHintProviderMock.getShapeTypeHint.returns(shapeHint);
+                    typeHintProviderMock.getEdgeTypeHint.returns(edgeHint);
+                    edgeHint.sourceElementTypeIds = ['node'];
+                    edgeHint.targetElementTypeIds = ['node'];
+                    const result = command.execute(createCommandExecutionContext(createNode('node:task:automated')));
+                    const element = result.children[0] as GNode;
+                    const edge = createEdge();
+                    expect(element.canConnect(edge, 'source')).to.be.true;
+                    expect(element.canConnect(edge, 'target')).to.be.true;
+                });
+                it('should fallback to class-level `canConnect` implementation if no edge hint is applicable to routable', () => {
+                    typeHintProviderMock.getEdgeTypeHint.returns(undefined);
+                    typeHintProviderMock.getShapeTypeHint.returns(shapeHint);
+                    const node = createNode();
+                    const originalCanConnectSpy = sinon.spy(node, 'canConnect');
+                    const result = command.execute(createCommandExecutionContext(node));
+                    const element = result.children[0] as GNode;
+                    const edge = createEdge();
+                    expect(element.canConnect(edge, 'source')).to.be.true;
+                    expect(element.canConnect(edge, 'target')).to.be.true;
+                    expect(originalCanConnectSpy.called).to.be.true;
+                });
+            });
+            describe('`isContainable` (after hint has been applied to element)', () => {
+                const shapeHint: Writable<ShapeTypeHint> = {
+                    deletable: false,
+                    elementTypeId: 'node',
+                    reparentable: false,
+                    repositionable: false,
+                    resizable: false
+                };
+                it('should return `false` if corresponding hint has no containable elements defined', () => {
+                    typeHintProviderMock.getShapeTypeHint.returns(shapeHint);
+                    const result = command.execute(createCommandExecutionContext(createNode('node')));
+                    const element = result.children[0] as GNode & Containable;
+                    expect(element.isContainableElement('other')).to.be.false;
+                });
+                it('should return `true` if corresponding hint has containable element with matching type', () => {
+                    typeHintProviderMock.getShapeTypeHint.returns(shapeHint);
+                    shapeHint.containableElementTypeIds = ['node'];
+                    const result = command.execute(createCommandExecutionContext(createNode('node')));
+                    const element = result.children[0] as GNode & Containable;
+                    expect(element.isContainableElement('node')).to.be.true;
+                });
+                it('should return `true` if corresponding hint as has containable element with matching super type', () => {
+                    typeHintProviderMock.getShapeTypeHint.returns(shapeHint);
+                    shapeHint.containableElementTypeIds = ['node'];
+                    const result = command.execute(createCommandExecutionContext(createNode('node')));
+                    const element = result.children[0] as GNode & Containable;
+                    expect(element.isContainableElement('node:task:automated')).to.be.true;
+                });
+            });
+        });
+        describe('EdgeTypeHint', () => {
+            const allEnabledHint: EdgeTypeHint = {
+                elementTypeId: 'edge',
+                deletable: true,
+                repositionable: true,
+                routable: true
+            };
+            const allDisabledHint: EdgeTypeHint = {
+                elementTypeId: 'edge',
+                deletable: false,
+                repositionable: false,
+                routable: false
+            };
+            it('should not modify feature set of model element with no applicable type hint', () => {
+                typeHintProviderMock.getEdgeTypeHint.returns(undefined);
+                const result = command.execute(createCommandExecutionContext(createEdge()));
+                const element = result.children[0];
+                expect(GEdge.DEFAULT_FEATURES, 'Element should have default feature set').to.have.same.members([
+                    ...(element.features as Set<symbol>)
+                ]);
+            });
+            it('should add all enabled (`true`) features, derived from the applied type hint, to the model', () => {
+                typeHintProviderMock.getEdgeTypeHint.returns(allEnabledHint);
+                const result = command.execute(createCommandExecutionContext(createEdge()));
+                const element = result.children[0];
+                expect(isDeletable(element), 'Element should have deletable feature').to.be.true;
+                expect(element.hasFeature(editFeature), 'Element should have edit feature').to.be.true;
+                expect(isReconnectable(element), 'Element should have reconnectable feature').to.be.true;
+            });
+            it('should remove all disabled (`false`) features, derived from the applied type hint, from the model', () => {
+                typeHintProviderMock.getEdgeTypeHint.returns(allDisabledHint);
+                const result = command.execute(createCommandExecutionContext(createEdge()));
+                const element = result.children[0];
+                expect(isDeletable(element), 'Element should not have deletable feature').to.be.false;
+                expect(element.hasFeature(editFeature), 'Element should  not have edit feature').to.be.false;
+                expect(isReconnectable(element), 'Element should  not have reconnectable feature').to.be.false;
+            });
+        });
+    });
+});