@eclipse-glsp/client 0.9.0-next.c5944e10

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

@@ -0,0 +1,46 @@
+/********************************************************************************
+ * Copyright (c) 2020 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 { injectable } from 'inversify';
+import {
+    Decoration,
+    DecorationPlacer,
+    isSizeable,
+    ORIGIN_POINT,
+    Point,
+    SChildElement,
+    SModelElement,
+    SRoutableElement
+} from 'sprotty';
+
+@injectable()
+export class GlspDecorationPlacer extends DecorationPlacer {
+
+    protected static readonly DECORATION_OFFSET: Point = { x: 12, y: 10 };
+
+    protected getPosition(element: SModelElement & Decoration): Point {
+        if (element instanceof SChildElement && element.parent instanceof SRoutableElement) {
+            return super.getPosition(element);
+        }
+        if (isSizeable(element)) {
+            return {
+                x: GlspDecorationPlacer.DECORATION_OFFSET.x * element.bounds.width,
+                y: GlspDecorationPlacer.DECORATION_OFFSET.y * element.bounds.height
+            };
+        }
+        return ORIGIN_POINT;
+    }
+
+}

package/src/features/decoration/di.config.ts

@@ -0,0 +1,28 @@
+/********************************************************************************
+ * Copyright (c) 2020 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 '../../../css/decoration.css';
+
+import { ContainerModule } from 'inversify';
+import { TYPES } from 'sprotty';
+
+import { GlspDecorationPlacer } from './decoration-placer';
+
+const glspDecorationModule = new ContainerModule((bind, _unbind, isBound) => {
+    bind(GlspDecorationPlacer).toSelf().inSingletonScope();
+    bind(TYPES.IVNodePostprocessor).toService(GlspDecorationPlacer);
+});
+
+export default glspDecorationModule;

package/src/features/edit-label/di.config.ts

@@ -0,0 +1,30 @@
+/********************************************************************************
+ * Copyright (c) 2019 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 { ContainerModule } from 'inversify';
+import { ApplyLabelEditCommand, configureCommand, TYPES } from 'sprotty';
+
+import { GLSP_TYPES } from '../../base/types';
+import { DirectLabelEditTool } from './edit-label-tool';
+import { BalloonLabelValidationDecorator, ServerEditLabelValidator } from './edit-label-validator';
+
+const glspEditLabelModule = new ContainerModule((bind, _unbind, isBound, _rebind) => {
+    bind(TYPES.IEditLabelValidator).to(ServerEditLabelValidator);
+    bind(TYPES.IEditLabelValidationDecorator).to(BalloonLabelValidationDecorator);
+    bind(GLSP_TYPES.IDefaultTool).to(DirectLabelEditTool);
+    configureCommand({ bind, isBound }, ApplyLabelEditCommand);
+});
+
+export default glspEditLabelModule;

package/src/features/edit-label/edit-label-tool.ts

@@ -0,0 +1,51 @@
+/********************************************************************************
+ * Copyright (c) 2020 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 { injectable } from 'inversify';
+import { EditLabelKeyListener, EditLabelMouseListener, KeyListener, MouseListener } from 'sprotty';
+
+import { BaseGLSPTool } from '../tools/base-glsp-tool';
+
+@injectable()
+export class DirectLabelEditTool extends BaseGLSPTool {
+    static readonly ID = 'glsp.direct-label-edit-tool';
+
+    protected editLabelMouseListener: MouseListener;
+    protected editLabelKeyListener: KeyListener;
+
+    get id(): string {
+        return DirectLabelEditTool.ID;
+    }
+
+    protected createEditLabelMouseListener(): MouseListener {
+        return new EditLabelMouseListener();
+    }
+
+    protected createEditLabelKeyListener(): KeyListener {
+        return new EditLabelKeyListener();
+    }
+
+    enable(): void {
+        this.editLabelKeyListener = this.createEditLabelKeyListener();
+        this.editLabelMouseListener = this.createEditLabelMouseListener();
+        this.mouseTool.register(this.editLabelMouseListener);
+        this.keyTool.register(this.editLabelKeyListener);
+    }
+
+    disable(): void {
+        this.keyTool.deregister(this.editLabelKeyListener);
+        this.mouseTool.deregister(this.editLabelMouseListener);
+    }
+}

package/src/features/edit-label/edit-label-validator.ts

@@ -0,0 +1,104 @@
+/********************************************************************************
+ * Copyright (c) 2019 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,
+    EditableLabel,
+    EditLabelValidationResult,
+    IEditLabelValidationDecorator,
+    IEditLabelValidator,
+    Severity,
+    SModelElement,
+    TYPES
+} from 'sprotty';
+
+import { GLSPActionDispatcher } from '../../base/action-dispatcher';
+import {
+    isSetEditValidationResultAction,
+    RequestEditValidationAction,
+    ValidationStatus
+} from '../../base/actions/edit-validation-actions';
+
+export namespace LabelEditValidation {
+    export const CONTEXT_ID = 'label-edit';
+
+    export function toEditLabelValidationResult(status: ValidationStatus): EditLabelValidationResult {
+        const message = status.message;
+        let severity = 'ok' as Severity;
+        if (ValidationStatus.isError(status)) {
+            severity = 'error' as Severity;
+        } else if (ValidationStatus.isWarning(status)) {
+            severity = 'warning' as Severity;
+        }
+        return { message, severity };
+    }
+}
+
+export class ValidateLabelEditAction extends RequestEditValidationAction {
+    constructor(value: string, labelId: string) {
+        super(LabelEditValidation.CONTEXT_ID, labelId, value);
+    }
+}
+
+@injectable()
+export class ServerEditLabelValidator implements IEditLabelValidator {
+
+    @inject(TYPES.IActionDispatcher) protected actionDispatcher: GLSPActionDispatcher;
+
+    validate(value: string, label: EditableLabel & SModelElement): Promise<EditLabelValidationResult> {
+        const action = new ValidateLabelEditAction(value, label.id);
+        return this.actionDispatcher.requestUntil(action).then(response => this.getValidationResultFromResponse(response));
+    }
+
+    getValidationResultFromResponse(action: Action): EditLabelValidationResult {
+        if (isSetEditValidationResultAction(action)) {
+            return LabelEditValidation.toEditLabelValidationResult(action.status);
+        }
+        return { severity: 'ok' as Severity };
+    }
+
+}
+
+@injectable()
+export class BalloonLabelValidationDecorator implements IEditLabelValidationDecorator {
+
+    decorate(input: HTMLInputElement, result: EditLabelValidationResult): void {
+        const containerElement = input.parentElement;
+        if (!containerElement) {
+            return;
+        }
+        if (result.message) {
+            containerElement.setAttribute('data-balloon', result.message);
+            containerElement.setAttribute('data-balloon-pos', 'up-left');
+            containerElement.setAttribute('data-balloon-visible', 'true');
+        }
+        switch (result.severity) {
+            case 'ok': containerElement.classList.add('validation-ok'); break;
+            case 'warning': containerElement.classList.add('validation-warning'); break;
+            case 'error': containerElement.classList.add('validation-error'); break;
+        }
+    }
+
+    dispose(input: HTMLInputElement): void {
+        const containerElement = input.parentElement;
+        if (containerElement) {
+            containerElement.removeAttribute('data-balloon');
+            containerElement.removeAttribute('data-balloon-pos');
+            containerElement.removeAttribute('data-balloon-visible');
+            containerElement.classList.remove('validation-ok', 'validation-warning', 'validation-error');
+        }
+    }
+}

package/src/features/hints/di.config.ts

@@ -0,0 +1,30 @@
+/********************************************************************************
+ * Copyright (c) 2019 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 { ContainerModule } from 'inversify';
+import { configureActionHandler, configureCommand } from 'sprotty';
+
+import { GLSP_TYPES } from '../../base/types';
+import { SetTypeHintsAction } from './request-type-hints-action';
+import { ApplyTypeHintsCommand, TypeHintProvider } from './type-hints';
+
+const modelHintsModule = new ContainerModule((bind, _unbind, isBound) => {
+    bind(TypeHintProvider).toSelf().inSingletonScope();
+    bind(GLSP_TYPES.ITypeHintProvider).toService(TypeHintProvider);
+    configureActionHandler({ bind, isBound }, SetTypeHintsAction.KIND, TypeHintProvider);
+    configureCommand({ bind, isBound }, ApplyTypeHintsCommand);
+});
+
+export default modelHintsModule;

package/src/features/hints/model.ts

@@ -0,0 +1,34 @@
+/********************************************************************************
+ * Copyright (c) 2019 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 { SModelElement, SModelElementSchema, SModelExtension } from 'sprotty';
+
+export const containerFeature = Symbol('containable');
+
+export interface Containable extends SModelExtension {
+    isContainableElement(input: SModelElement | SModelElementSchema | string): boolean;
+}
+
+export function isContainable(element: SModelElement): element is SModelElement & Containable {
+    return element.hasFeature(containerFeature);
+}
+
+export const reparentFeature = Symbol('reparentFeature');
+
+export interface Reparentable extends SModelExtension { }
+
+export function isReparentable(element: SModelElement): element is SModelElement & Reparentable {
+    return element.hasFeature(reparentFeature);
+}

package/src/features/hints/request-type-hints-action.ts

@@ -0,0 +1,36 @@
+/********************************************************************************
+ * Copyright (c) 2019 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 { Action } from 'sprotty';
+
+import { EdgeTypeHint, ShapeTypeHint } from './type-hints';
+
+export class RequestTypeHintsAction implements Action {
+    static readonly KIND = 'requestTypeHints';
+    constructor(public readonly diagramType?: string, public readonly kind: string = RequestTypeHintsAction.KIND) { }
+}
+
+export class SetTypeHintsAction implements Action {
+    static readonly KIND = 'setTypeHints';
+    constructor(
+        public readonly shapeHints: ShapeTypeHint[],
+        public readonly edgeHints: EdgeTypeHint[],
+        public readonly kind: string = SetTypeHintsAction.KIND) { }
+}
+
+export function isSetTypeHintsAction(action: Action): action is SetTypeHintsAction {
+    return action !== undefined && (action.kind === SetTypeHintsAction.KIND)
+        && (action as SetTypeHintsAction).shapeHints !== undefined && (action as SetTypeHintsAction).edgeHints !== undefined;
+}

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

@@ -0,0 +1,257 @@
+/********************************************************************************
+ * Copyright (c) 2019 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,
+    CommandReturn,
+    Connectable,
+    connectableFeature,
+    deletableFeature,
+    editFeature,
+    FeatureSet,
+    IActionHandler,
+    ICommand,
+    moveFeature,
+    SEdge,
+    SModelElement,
+    SModelElementSchema,
+    SModelRoot,
+    SShapeElement,
+    TYPES
+} from 'sprotty';
+
+import { GLSP_TYPES } from '../../base/types';
+import { getElementTypeId, hasCompatibleType } from '../../utils/smodel-util';
+import { resizeFeature } from '../change-bounds/model';
+import { reconnectFeature } from '../reconnect/model';
+import { IFeedbackActionDispatcher } from '../tool-feedback/feedback-action-dispatcher';
+import { FeedbackCommand } from '../tool-feedback/model';
+import { Containable, containerFeature, reparentFeature } from './model';
+import { isSetTypeHintsAction } from './request-type-hints-action';
+
+export abstract class TypeHint {
+    /**
+    The id of the element.
+    */
+    readonly elementTypeId: string;
+
+    /**
+    * Specifies whether the element can be relocated.
+    */
+    readonly repositionable: boolean;
+
+    /**
+     * Specifices wheter the element can be deleted
+     */
+    readonly deletable: boolean;
+}
+
+export class ShapeTypeHint extends TypeHint {
+    /**
+     * Specifies whether the element can be resized.
+     */
+    readonly resizable: boolean;
+
+    /**
+     * Specifies whether the element can be moved to another parent
+     */
+    readonly reparentable: boolean;
+
+    /**
+     * The types of elements that can be contained by this element (if any)
+     */
+    readonly containableElementTypeIds?: string[];
+}
+
+export class EdgeTypeHint extends TypeHint {
+    /**
+     * Specifies whether the routing of this element can be changed.
+     */
+    readonly routable: boolean;
+
+    /**
+     * Allowed source element types for this edge type
+     */
+    readonly sourceElementTypeIds: string[];
+
+    /**
+    * Allowed targe element types for this edge type
+    */
+    readonly targetElementTypeIds: string[];
+
+    isAllowedSource(input: SModelElement | SModelElementSchema | string): boolean {
+        const type = getElementTypeId(input);
+        return this.sourceElementTypeIds.includes(type);
+
+    }
+    isAllowedTarget(input: SModelElement | SModelElementSchema | string): boolean {
+        const type = getElementTypeId(input);
+        return this.targetElementTypeIds.includes(type);
+    }
+}
+
+@injectable()
+export class ApplyTypeHintsAction implements Action {
+    readonly kind = ApplyTypeHintsCommand.KIND;
+}
+
+@injectable()
+export class ApplyTypeHintsCommand extends FeedbackCommand {
+
+    public static KIND = 'applyTypeHints';
+    public readonly priority = 10;
+
+    @inject(GLSP_TYPES.ITypeHintProvider) protected typeHintProvider: ITypeHintProvider;
+
+    constructor(@inject(TYPES.Action) protected action: ApplyTypeHintsAction) {
+        super();
+    }
+
+    execute(context: CommandExecutionContext): CommandReturn {
+        context.root.index.all()
+            .forEach(element => {
+                if (element instanceof SShapeElement || element instanceof SModelRoot) {
+                    this.applyShapeTypeHint(element);
+
+                } else if (element instanceof SEdge) {
+                    return this.applyEdgeTypeHint(element);
+                }
+            });
+        return context.root;
+    }
+
+    protected applyEdgeTypeHint(element: SModelElement): void {
+        const hint = this.typeHintProvider.getEdgeTypeHint(element);
+        if (hint && isModifiableFetureSet(element.features)) {
+            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 && isModifiableFetureSet(element.features)) {
+            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);
+            const containable = createContainable(hint);
+            Object.assign(element, containable);
+
+            addOrRemove(element.features, connectableFeature, true);
+            const validSourceEdges = this.typeHintProvider.getValidEdgeElementTypes(element, 'source');
+            const validTargetEdges = this.typeHintProvider.getValidEdgeElementTypes(element, 'target');
+            const connectable = createConnectable(validSourceEdges, validTargetEdges);
+            Object.assign(element, connectable);
+        }
+    }
+}
+
+function createConnectable(validSourceEdges: string[], validTargetEdges: string[]): Connectable {
+    return {
+        canConnect: (routable, role) =>
+            role === 'source' ?
+                validSourceEdges.includes(routable.type) :
+                validTargetEdges.includes(routable.type)
+    };
+}
+
+function createContainable(hint: ShapeTypeHint): Containable {
+    return {
+        isContainableElement: element =>
+            hint.containableElementTypeIds ?
+                hint.containableElementTypeIds.includes(getElementTypeId(element)) :
+                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);
+    }
+}
+
+function isModifiableFetureSet(featureSet?: FeatureSet): featureSet is FeatureSet & Set<symbol> {
+    return featureSet !== undefined && featureSet instanceof Set;
+}
+
+export interface ITypeHintProvider {
+    getShapeTypeHint(input: SModelElement | SModelElement | string): ShapeTypeHint | undefined;
+    getEdgeTypeHint(input: SModelElement | SModelElement | string): EdgeTypeHint | undefined;
+    getValidEdgeElementTypes(input: SModelElement | SModelElement | string, role: 'source' | 'target'): string[];
+}
+
+@injectable()
+export class TypeHintProvider implements IActionHandler, ITypeHintProvider {
+
+    @inject(GLSP_TYPES.IFeedbackActionDispatcher)
+    protected feedbackActionDispatcher: IFeedbackActionDispatcher;
+
+    protected shapeHints: Map<string, ShapeTypeHint> = new Map;
+    protected edgeHints: Map<string, EdgeTypeHint> = new Map;
+
+    handle(action: Action): ICommand | Action | void {
+        if (isSetTypeHintsAction(action)) {
+            action.shapeHints.forEach(hint => this.shapeHints.set(hint.elementTypeId, hint));
+            action.edgeHints.forEach(hint => this.edgeHints.set(hint.elementTypeId, hint));
+            this.feedbackActionDispatcher.registerFeedback(this, [new ApplyTypeHintsAction()]);
+        }
+    }
+
+    getValidEdgeElementTypes(input: SModelElement | SModelElement | string, role: 'source' | 'target'): string[] {
+        const elementTypeId = getElementTypeId(input);
+        if (role === 'source') {
+            return Array.from(
+                Array.from(this.edgeHints.values())
+                    .filter(hint => hint.sourceElementTypeIds.some(sourceElementTypeId => hasCompatibleType(elementTypeId, sourceElementTypeId)))
+                    .map(hint => hint.elementTypeId));
+        } else {
+            return Array.from(
+                Array.from(this.edgeHints.values())
+                    .filter(hint => hint.targetElementTypeIds.some(targetElementTypeId => hasCompatibleType(elementTypeId, targetElementTypeId)))
+                    .map(hint => hint.elementTypeId));
+        }
+    }
+
+    getShapeTypeHint(input: SModelElement | SModelElement | string): ShapeTypeHint | undefined {
+        return getTypeHint(input, this.shapeHints);
+    }
+
+    getEdgeTypeHint(input: SModelElement | SModelElement | string): EdgeTypeHint | undefined {
+        return getTypeHint(input, this.edgeHints);
+    }
+}
+
+function getTypeHint<T extends TypeHint>(input: SModelElement | SModelElement | 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(':'));
+        }
+    }
+    return hint;
+}
+