@eclipse-glsp/client 1.1.0-next.4e10035.245 → 1.1.0-next.5435240.281

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

@@ -0,0 +1,356 @@
+/********************************************************************************
+ * 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 { expect } from 'chai';
+import { Container } from 'inversify';
+import * as sinon from 'sinon';
+import {
+    AnimationFrameSyncer,
+    CommandExecutionContext,
+    ConsoleLogger,
+    EdgeTypeHint,
+    SChildElement,
+    SEdge,
+    SModelFactory,
+    SModelRoot,
+    SNode,
+    SetTypeHintsAction,
+    ShapeTypeHint,
+    TYPES,
+    Writable,
+    bindOrRebind,
+    createFeatureSet,
+    editFeature,
+    isDeletable,
+    isMoveable
+} from '~glsp-sprotty';
+import { GLSPActionDispatcher } from '../../base/action-dispatcher';
+import { FeedbackActionDispatcher } from '../../base/feedback/feedback-action-dispatcher';
+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: SChildElement): CommandExecutionContext {
+        const root = new SModelRoot();
+        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): SNode {
+        const node = new SNode();
+        node.type = type ?? 'node';
+        node.id = 'node';
+        node.features = createFeatureSet(SNode.DEFAULT_FEATURES);
+        return node;
+    }
+
+    function createEdge(type?: string): SEdge {
+        const edge = new SEdge();
+        edge.type = type ?? 'edge';
+        edge.id = 'edge';
+        edge.features = createFeatureSet(SEdge.DEFAULT_FEATURES);
+        return edge;
+    }
+
+    const sandbox = sinon.createSandbox();
+    const container = new Container();
+    const modelFactory = sinon.createStubInstance(SModelFactory);
+    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(SNode.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 SNode;
+                    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 SNode;
+                    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 SNode;
+                    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 SNode;
+                    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 SNode;
+                    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 SNode & 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 SNode & 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 SNode & 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(SEdge.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;
+            });
+        });
+    });
+});

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

@@ -0,0 +1,248 @@
+/********************************************************************************
+ * 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 { inject, injectable } from 'inversify';
+import {
+    Action,
+    CommandExecutionContext,
+    Connectable,
+    EdgeTypeHint,
+    IActionHandler,
+    RequestTypeHintsAction,
+    SEdge,
+    SModelElement,
+    SModelElementSchema,
+    SModelRoot,
+    SRoutableElement,
+    SShapeElement,
+    SetTypeHintsAction,
+    ShapeTypeHint,
+    TYPES,
+    TypeHint,
+    connectableFeature,
+    deletableFeature,
+    editFeature,
+    isConnectable,
+    moveFeature
+} from '~glsp-sprotty';
+import { GLSPActionDispatcher } from '../../base/action-dispatcher';
+import { IFeedbackActionDispatcher } from '../../base/feedback/feedback-action-dispatcher';
+import { FeedbackCommand } from '../../base/feedback/feedback-command';
+import { IDiagramStartup } from '../../base/model/diagram-loader';
+import { getElementTypeId } from '../../utils/smodel-util';
+import { resizeFeature } from '../change-bounds/model';
+import { reconnectFeature } from '../reconnect/model';
+import { containerFeature, isContainable, reparentFeature } from './model';
+
+/**
+ * Is dispatched by the {@link TypeHintProvider} to apply the type hints received from the server
+ * onto the graphical model. The action is dispatched as persistent feedback to ensure the applied type hints
+ * don't get lost after a server-side model update.
+ */
+export interface ApplyTypeHintsAction extends Action {
+    kind: typeof ApplyTypeHintsAction.KIND;
+}
+
+export namespace ApplyTypeHintsAction {
+    export const KIND = 'applyTypeHints';
+
+    export function is(object: any): object is ApplyTypeHintsAction {
+        return Action.hasKind(object, KIND);
+    }
+
+    export function create(): ApplyTypeHintsAction {
+        return { kind: KIND };
+    }
+}
+
+type CanConnectFn = Connectable['canConnect'];
+
+/**
+ * Command that processes the entire model and for each model element applies its
+ * type hints i.e. translates the type hint information into corresponding model features
+ * and adds/removes them from the model element.
+ */
+@injectable()
+export class ApplyTypeHintsCommand extends FeedbackCommand {
+    public static KIND = ApplyTypeHintsAction.KIND;
+    public override readonly priority = 10;
+
+    @inject(TYPES.ITypeHintProvider)
+    protected typeHintProvider: ITypeHintProvider;
+
+    constructor(@inject(TYPES.Action) protected action: ApplyTypeHintsAction) {
+        super();
+    }
+
+    execute(context: CommandExecutionContext): SModelRoot {
+        context.root.index.all().forEach(element => {
+            if (element instanceof SShapeElement || element instanceof SModelRoot) {
+                return this.applyShapeTypeHint(element);
+            }
+            if (element instanceof SEdge) {
+                this.applyEdgeTypeHint(element);
+            }
+        });
+        return context.root;
+    }
+
+    protected applyEdgeTypeHint(element: SModelElement): void {
+        const hint = this.typeHintProvider.getEdgeTypeHint(element);
+
+        if (hint && element.features instanceof Set) {
+            addOrRemove(element.features, deletableFeature, hint.deletable);
+            addOrRemove(element.features, editFeature, hint.routable);
+            addOrRemove(element.features, reconnectFeature, hint.repositionable);
+        }
+    }
+
+    protected applyShapeTypeHint(element: SModelElement): void {
+        const hint = this.typeHintProvider.getShapeTypeHint(element);
+        if (hint && element.features instanceof Set) {
+            addOrRemove(element.features, deletableFeature, hint.deletable);
+            addOrRemove(element.features, moveFeature, hint.repositionable);
+            addOrRemove(element.features, resizeFeature, hint.resizable);
+            addOrRemove(element.features, reparentFeature, hint.reparentable);
+
+            addOrRemove(element.features, containerFeature, true);
+            if (isContainable(element)) {
+                element.isContainableElement = input => this.isContainableElement(input, hint);
+            }
+
+            const fallbackCanConnect = isConnectable(element) ? element.canConnect.bind(element) : undefined;
+            addOrRemove(element.features, connectableFeature, true);
+            if (isConnectable(element)) {
+                element.canConnect = (routable, role) => this.canConnect(routable, role, element, fallbackCanConnect);
+            }
+        }
+    }
+
+    /**
+     * Type hints aware wrapper function for  `Connectable.canConnect`. After type hints have been applied
+     * the `canConnect` implementation of `connectable` model elements  (with a matching hint) will forward to this method.
+     */
+    protected canConnect(
+        routable: SRoutableElement,
+        role: 'source' | 'target',
+        element: SModelElement,
+        fallbackCanConnect?: CanConnectFn
+    ): boolean {
+        const edgeHint = this.typeHintProvider.getEdgeTypeHint(routable.type);
+        if (!edgeHint) {
+            return fallbackCanConnect?.(routable, role) ?? false;
+        }
+        const validElementIds = role === 'source' ? edgeHint.sourceElementTypeIds : edgeHint.targetElementTypeIds;
+        // If no source/target element ids are defined in the hint all elements are considered valid
+        if (!validElementIds) {
+            return true;
+        }
+        const elementType = element.type + ':';
+        return validElementIds.some(type => elementType.startsWith(type));
+    }
+
+    /**
+     * Type hints aware wrapper function for  `Containable.isContainableElement`. After type hints have been applied
+     * the `isContainableElement` implementation of `containable` model elements (with a matching hint) will forward to this method.
+     */
+    protected isContainableElement(input: SModelElement | SModelElementSchema | string, hint: ShapeTypeHint): boolean {
+        const elemenType = getElementTypeId(input) + ':';
+        return hint.containableElementTypeIds?.some(type => elemenType.startsWith(type)) ?? false;
+    }
+}
+
+function addOrRemove(features: Set<symbol>, feature: symbol, add: boolean): void {
+    if (add && !features.has(feature)) {
+        features.add(feature);
+    } else if (!add && features.has(feature)) {
+        features.delete(feature);
+    }
+}
+
+/**
+ * Provides query methods for retrieving the type hint that is applicable for a given model element.
+ * If there is no type hint registered for the given element type the hint of the most concrete subtype (if any)
+ * is returned instead. Subtypes are declared with a `:` delimiter.
+ * For example consider the type `node:task:manual`. Then the provider fist checks wether there is
+ * a type hint registered for `node:task:manual`. If not it checks wether there is one registered
+ * for `node:task` and finally it checks wether there is a type hint for `node`.
+ */
+export interface ITypeHintProvider {
+    /**
+     * Retrieve the most applicable {@link ShapeTypeHint} for the given model element.
+     *
+     * @param input The model element whose type hint should be retrieved
+     * @returns The most applicable hint of the given element or `undefined` if no matching hint is registered.
+     */
+    getShapeTypeHint(input: SModelElement | SModelElementSchema | string): ShapeTypeHint | undefined;
+    /**
+     * Retrieve the most applicable {@link EdgeTypeHint} for the given model element.
+     *
+     * @param input The model element whose type hint should be retrieved
+     * @returns The most applicable hint of the given element or `undefined` if no matching hint is registered.
+     */
+    getEdgeTypeHint(input: SModelElement | SModelElementSchema | string): EdgeTypeHint | undefined;
+}
+
+@injectable()
+export class TypeHintProvider implements IActionHandler, ITypeHintProvider, IDiagramStartup {
+    @inject(TYPES.IFeedbackActionDispatcher)
+    protected feedbackActionDispatcher: IFeedbackActionDispatcher;
+
+    @inject(GLSPActionDispatcher)
+    protected actionDispatcher: GLSPActionDispatcher;
+
+    protected shapeHints: Map<string, ShapeTypeHint> = new Map();
+    protected edgeHints: Map<string, EdgeTypeHint> = new Map();
+
+    handle(action: SetTypeHintsAction): void {
+        this.shapeHints.clear();
+        this.edgeHints.clear();
+        action.shapeHints.forEach(hint => this.shapeHints.set(hint.elementTypeId, hint));
+        action.edgeHints.forEach(hint => this.edgeHints.set(hint.elementTypeId, hint));
+        this.feedbackActionDispatcher.registerFeedback(this, [ApplyTypeHintsAction.create()]);
+    }
+
+    getShapeTypeHint(input: SModelElement | SModelElementSchema | string): ShapeTypeHint | undefined {
+        return this.getTypeHint(input, this.shapeHints);
+    }
+
+    getEdgeTypeHint(input: SModelElement | SModelElementSchema | string): EdgeTypeHint | undefined {
+        return this.getTypeHint(input, this.edgeHints);
+    }
+
+    protected getTypeHint<T extends TypeHint>(input: SModelElement | SModelElementSchema | string, hints: Map<string, T>): T | undefined {
+        const type = getElementTypeId(input);
+        let hint = hints.get(type);
+        // Check subtypes
+        if (hint === undefined) {
+            const subtypes = type.split(':');
+            while (hint === undefined && subtypes.length > 0) {
+                subtypes.pop();
+                hint = hints.get(subtypes.join(':'));
+                if (hint) {
+                    // add received subtype hint to map to avoid future recomputation
+                    hints.set(type, hint);
+                    break;
+                }
+            }
+        }
+        return hint;
+    }
+
+    async postRequestModel(): Promise<void> {
+        const setTypeHintsAction = await this.actionDispatcher.request(RequestTypeHintsAction.create());
+        this.handle(setTypeHintsAction);
+    }
+}

package/src/features/hints/type-hints-module.ts

@@ -0,0 +1,25 @@
+/********************************************************************************
+ * 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 { FeatureModule, SetTypeHintsAction, TYPES, bindAsService, configureActionHandler, configureCommand } from '~glsp-sprotty';
+import { ApplyTypeHintsCommand, TypeHintProvider } from './type-hint-provider';
+
+export const typeHintsModule = new FeatureModule((bind, unbind, isBound) => {
+    const context = { bind, unbind, isBound };
+    bindAsService(context, TYPES.ITypeHintProvider, TypeHintProvider);
+    bind(TYPES.IDiagramStartup).toService(TypeHintProvider);
+    configureActionHandler(context, SetTypeHintsAction.KIND, TypeHintProvider);
+    configureCommand(context, ApplyTypeHintsCommand);
+});