@eclipse-glsp/client 0.9.0-rc-01 → 0.10.0-next.146a812.165

package/src/model-source/glsp-diagram-server.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2019-2020 EclipseSource and others.
+ * Copyright (c) 2019-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
@@ -13,26 +13,20 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { GLSPClient } from '@eclipse-glsp/protocol';
-import { injectable } from 'inversify';
 import {
     Action,
-    ActionHandlerRegistry,
-    ActionMessage,
     ComputedBoundsAction,
-    DiagramServer,
-    ICommand,
-    RequestModelAction,
-    ServerStatusAction,
-    SwitchEditModeCommand
-} from 'sprotty';
-
-import { RequestContextActions } from '../base/actions/context-actions';
-import { isSetEditModeAction, SetEditModeAction } from '../base/actions/edit-mode-action';
-import { InitializeClientSessionAction } from '../base/actions/protocol-actions';
+    ExportSvgAction,
+    GLSPClient,
+    isRequestModelAction,
+    isServerMessageAction,
+    isSetEditModeAction,
+    ServerMessageAction,
+    SetEditModeAction
+} from '@eclipse-glsp/protocol';
+import { injectable } from 'inversify';
+import { ActionHandlerRegistry, ActionMessage, DiagramServer, ICommand, ServerStatusAction, SwitchEditModeCommand } from 'sprotty';
 import { SourceUriAware } from '../base/source-uri-aware';
-import { RequestTypeHintsAction } from '../features/hints/request-type-hints-action';
-import { isServerMessageAction, ServerMessageAction } from './glsp-server-status';
 
 const receivedFromServerProperty = '__receivedFromServer';
 
@@ -61,21 +55,21 @@ export class GLSPDiagramServer extends DiagramServer implements SourceUriAware {
         }
     }
 
-    initialize(registry: ActionHandlerRegistry): void {
+    override initialize(registry: ActionHandlerRegistry): void {
         registerDefaultGLSPServerActions(registry, this);
         if (!this.clientId) {
             this.clientId = this.viewerOptions.baseDiv;
         }
     }
 
-    handle(action: Action): void | ICommand | Action {
-        if (action instanceof RequestModelAction && action.options !== undefined) {
+    override handle(action: Action): void | ICommand | Action {
+        if (isRequestModelAction(action) && action.options) {
             this._sourceUri = action.options.sourceUri as string;
         }
         return super.handle(action);
     }
 
-    handleLocally(action: Action): boolean {
+    override handleLocally(action: Action): boolean {
         if (isServerMessageAction(action)) {
             return this.handleServerMessageAction(action);
         }
@@ -90,7 +84,7 @@ export class GLSPDiagramServer extends DiagramServer implements SourceUriAware {
         return false;
     }
 
-    protected handleComputedBounds(_action: ComputedBoundsAction): boolean {
+    protected override handleComputedBounds(_action: ComputedBoundsAction): boolean {
         return true;
     }
 
@@ -108,17 +102,9 @@ export function isReceivedFromServer(action: Action): boolean {
 }
 
 export function registerDefaultGLSPServerActions(registry: ActionHandlerRegistry, diagramServer: DiagramServer): void {
-    // Register the InitializeClientSessionAction as a server action. Then, the server will
-    // notify us about all actions it handles (Via ConfigureServerHandlersAction/Handler)
-    registry.register(InitializeClientSessionAction.KIND, diagramServer);
-
-    // Register some additional early actions, that will happen before the server can tell us
-    // which actions it handles
-    registry.register(RequestTypeHintsAction.KIND, diagramServer);
-    registry.register(RequestModelAction.KIND, diagramServer);
-    registry.register(RequestContextActions.KIND, diagramServer);
-
+    registry.register(ServerMessageAction.KIND, diagramServer);
     registry.register(ServerStatusAction.KIND, diagramServer);
+    registry.register(ExportSvgAction.KIND, diagramServer);
 
     // Register an empty handler for SwitchEditMode, to avoid runtime exceptions.
     // We don't support SwitchEditMode, but Sprotty still sends those actions, so ignore them.

package/src/protocol-reexport.ts

@@ -0,0 +1,64 @@
+/********************************************************************************
+ * Copyright (c) 2021 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
+ ********************************************************************************/
+
+/**
+ * Workaround for now to solve ambiguous exports in glsp-client. This module provides all glsp-only components.
+ * i.e. typings that are not defined in sprotty
+ */
+
+export {
+    CompoundOperation,
+    isActionKind,
+    isCompoundOperation,
+    isRejectAction,
+    Operation
+} from '@eclipse-glsp/protocol/lib/action-protocol/base-protocol';
+export * from '@eclipse-glsp/protocol/lib/action-protocol/client-notification';
+export * from '@eclipse-glsp/protocol/lib/action-protocol/clipboard';
+export * from '@eclipse-glsp/protocol/lib/action-protocol/contexts';
+export * from '@eclipse-glsp/protocol/lib/action-protocol/edge-modification';
+export * from '@eclipse-glsp/protocol/lib/action-protocol/element-creation';
+export { isRequestPopupModelAction, isSetPopupModelAction } from '@eclipse-glsp/protocol/lib/action-protocol/element-hover';
+export * from '@eclipse-glsp/protocol/lib/action-protocol/element-navigation';
+export { isSelectAction, isSelectAllAction } from '@eclipse-glsp/protocol/lib/action-protocol/element-selection';
+export * from '@eclipse-glsp/protocol/lib/action-protocol/element-text-editing';
+export * from '@eclipse-glsp/protocol/lib/action-protocol/element-type-hints';
+export * from '@eclipse-glsp/protocol/lib/action-protocol/element-validation';
+export { LayoutOperation } from '@eclipse-glsp/protocol/lib/action-protocol/mode-layout';
+export {
+    isModelSourceChangedAction,
+    isRequestModelAction,
+    isSetModelAction,
+    ModelSourceChangedAction
+} from '@eclipse-glsp/protocol/lib/action-protocol/model-data';
+export * from '@eclipse-glsp/protocol/lib/action-protocol/model-edit-mode';
+export {
+    DirtyStateChangeReason,
+    isExportSvgAction,
+    isSaveModelAction,
+    isSetDirtyStateAction,
+    SaveModelAction,
+    SetDirtyStateAction
+} from '@eclipse-glsp/protocol/lib/action-protocol/model-saving';
+export * from '@eclipse-glsp/protocol/lib/action-protocol/node-modification';
+export * from '@eclipse-glsp/protocol/lib/action-protocol/tool-palette';
+export { Args, EditorContext, ElementAndRoutingPoints } from '@eclipse-glsp/protocol/lib/action-protocol/types';
+export * from '@eclipse-glsp/protocol/lib/action-protocol/undo-redo';
+export * from '@eclipse-glsp/protocol/lib/glsp-client';
+export * from '@eclipse-glsp/protocol/lib/jsonrpc/base-jsonrpc-glsp-client';
+export * from '@eclipse-glsp/protocol/lib/jsonrpc/glsp-jsonrpc-client';
+export * from '@eclipse-glsp/protocol/lib/utils/array-util';
+export * from '@eclipse-glsp/protocol/lib/utils/launch-util';

package/src/utils/argument-utils.ts

@@ -14,11 +14,10 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 import { SModelElement } from 'sprotty';
-
-import { hasArguments } from '../base/args';
+import { hasArguments } from '../base/argumentable';
 
 export namespace GArgument {
-    export function asNumber(argValue: (string | number | boolean)): number | undefined {
+    export function asNumber(argValue: string | number | boolean): number | undefined {
         return typeof argValue === 'number' ? argValue : undefined;
     }
 
@@ -26,7 +25,7 @@ export namespace GArgument {
         return argValues.map(asNumber);
     }
 
-    export function asString(argValue: (string | number | boolean)): string | undefined {
+    export function asString(argValue: string | number | boolean): string | undefined {
         return typeof argValue === 'string' ? argValue : undefined;
     }
 
@@ -34,7 +33,7 @@ export namespace GArgument {
         return argValues.map(asString);
     }
 
-    export function asBoolean(argValue: (string | number | boolean)): boolean | undefined {
+    export function asBoolean(argValue: string | number | boolean): boolean | undefined {
         return typeof argValue === 'boolean' ? argValue : undefined;
     }
 
@@ -112,16 +111,20 @@ export class CornerRadius {
         public readonly topLeft: number = 0,
         public readonly topRight: number = topLeft,
         public readonly bottomRight: number = topLeft,
-        public readonly bottomLeft: number = topRight) {
-    }
+        public readonly bottomLeft: number = topRight
+    ) {}
 
     static from(element: SModelElement | undefined): CornerRadius | undefined {
-        const radius = GArgument.getNumbers(element, this.KEY_RADIUS_TOP_LEFT, this.KEY_RADIUS_TOP_RIGHT, this.KEY_RADIUS_BOTTOM_RIGHT, this.KEY_RADIUS_BOTTOM_LEFT);
+        const radius = GArgument.getNumbers(
+            element,
+            this.KEY_RADIUS_TOP_LEFT,
+            this.KEY_RADIUS_TOP_RIGHT,
+            this.KEY_RADIUS_BOTTOM_RIGHT,
+            this.KEY_RADIUS_BOTTOM_LEFT
+        );
         if (radius === undefined || radius[0] === undefined) {
             return undefined;
         }
-        return GArgument.hasNValues(radius, 4)
-            ? new CornerRadius(radius[0], radius[1], radius[2], radius[3])
-            : new CornerRadius(radius[0]);
+        return GArgument.hasNValues(radius, 4) ? new CornerRadius(radius[0], radius[1], radius[2], radius[3]) : new CornerRadius(radius[0]);
     }
 }

package/src/utils/layout-utils.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2020 EclipseSource and others.
+ * Copyright (c) 2020-2021 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,8 +13,8 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { BoundsAware, Dimension, ElementAndBounds, ElementMove, ModelLayoutOptions, Point, SModelElement } from 'sprotty';
-
+import { Point } from '@eclipse-glsp/protocol';
+import { BoundsAware, Dimension, ElementAndBounds, ElementMove, ModelLayoutOptions, SModelElement } from 'sprotty';
 import { IMovementRestrictor } from '../features/change-bounds/movement-restrictor';
 
 export function minWidth(element: SModelElement & BoundsAware): number {
@@ -52,16 +52,22 @@ export function isValidMove(element: SModelElement & BoundsAware, newPosition: P
     return true;
 }
 
-export function toValidElementMove(element: SModelElement & BoundsAware, move: WriteableElementMove, movementRestrictor?: IMovementRestrictor): WriteableElementMove | undefined {
+export function toValidElementMove(
+    element: SModelElement & BoundsAware,
+    move: WriteableElementMove,
+    movementRestrictor?: IMovementRestrictor
+): WriteableElementMove | undefined {
     if (!isValidMove(element, move.toPosition, movementRestrictor)) {
         return;
     }
     return move;
 }
 
-export function toValidElementAndBounds(element: SModelElement & BoundsAware, bounds: WriteableElementAndBounds,
-    movementRestrictor?: IMovementRestrictor): WriteableElementAndBounds | undefined {
-
+export function toValidElementAndBounds(
+    element: SModelElement & BoundsAware,
+    bounds: WriteableElementAndBounds,
+    movementRestrictor?: IMovementRestrictor
+): WriteableElementAndBounds | undefined {
     if (!isValidMove(element, bounds.newPosition, movementRestrictor)) {
         return;
     }

package/src/utils/marker.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2019 EclipseSource and others.
+ * Copyright (c) 2019-2021 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,9 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
+import { MarkerKind } from '@eclipse-glsp/protocol';
 import { SIssueMarker, SParentElement } from 'sprotty';
 
-export namespace MarkerKind {
-    export const INFO = 'info';
-    export const WARNING = 'warning';
-    export const ERROR = 'error';
-}
-
 export namespace MarkerPredicates {
     export const ALL = (): boolean => true;
     export const ERRORS = (marker: SIssueMarker): boolean => hasIssueWithSeverity(marker, MarkerKind.ERROR);
@@ -42,22 +37,3 @@ export function collectIssueMarkers(root: SParentElement): SIssueMarker[] {
     }
     return markers;
 }
-
-export interface Marker {
-    /**
-     * Short label describing this marker message, e.g., short validation message
-     */
-    readonly label: string;
-    /**
-     * Full description of this marker, e.g., full validation message
-     */
-    readonly description: string;
-    /**
-     * Id of the model element this marker refers to
-     */
-    readonly elementId: string;
-    /**
-     * Marker kind, e.g., info, warning, error or custom kind
-     */
-    readonly kind: string;
-}

package/src/utils/smodel-util.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2019 EclipseSource and others.
+ * Copyright (c) 2019-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
@@ -13,6 +13,7 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
+import { distinctAdd, ElementAndRoutingPoints, remove, TypeGuard } from '@eclipse-glsp/protocol';
 import {
     BoundsAware,
     ElementAndBounds,
@@ -27,90 +28,179 @@ import {
     SRoutableElement,
     SRoutingHandle
 } from 'sprotty';
+import { FluentIterable } from 'sprotty/lib/utils/iterable';
 
-import { ElementAndRoutingPoints } from '../base/operations/operation';
+/**
+ * Helper type to represent a filter predicate for {@link SModelElement}s. This is used to retrieve
+ * elements from the {@link SModelIndex} that also conform to a second type `T`. Its mainly used for
+ * retrieving elements that also implement a certain model features (e.g. selectable)
+ */
+export type ModelFilterPredicate<T> = (modelElement: SModelElement) => modelElement is SModelElement & T;
 
-export function getIndex(element: SModelElement): SModelIndex<SModelElement> {
-    return element.root.index;
+/**
+ * Retrieves all elements from the given {@link SModelIndex} that match the given {@link ModelFilterPredicate}
+ * @param index The {@link SModelIndex}.
+ * @param predicate The {@link ModelFilterPredicate} that should be used.
+ * @returns A {@link FluentIterable} of all indexed element that match the predicate
+ * (correctly casted to also include the additional type of the predicate).
+ */
+export function filter<T>(index: SModelIndex<SModelElement>, predicate: ModelFilterPredicate<T>): FluentIterable<SModelElement & T> {
+    return index.all().filter(predicate) as FluentIterable<SModelElement & T>;
 }
 
-export function forEachElement<T>(element: SModelElement, predicate: (element: SModelElement) => element is SModelElement & T,
-    runnable: (element: SModelElement & T) => void): void {
-    getIndex(element).all()
-        .filter(predicate)
-        .forEach(runnable);
+/**
+ * Retrieves all elements from the given {@link SModelIndex} that match the given {@link ModelFilterPredicate} and executes
+ * the given runnable for each element of the result set.
+ * @param index The {@link SModelIndex}.
+ * @param predicate The {@link ModelFilterPredicate} that should be used.
+ * @param runnable The runnable that should be executed for each matching element.
+ */
+export function forEachElement<T>(
+    index: SModelIndex<SModelElement>,
+    predicate: ModelFilterPredicate<T>,
+    runnable: (modelElement: SModelElement & T) => void
+): void {
+    filter(index, predicate).forEach(runnable);
 }
 
-export function getMatchingElements<T>(element: SModelElement, predicate: (element: SModelElement) => element is SModelElement & T): (SModelElement & T)[] {
-    const matching: (SModelElement & T)[] = [];
-    forEachElement(element, predicate, item => matching.push(item));
-    return matching;
+/**
+ * Retrieves an array of all elements that match the given {@link ModelFilterPredicate} from the given {@link SModelIndex}.
+ * @param index The {@link SModelIndex}.
+ * @param predicate The {@link ModelFilterPredicate} that should be used.
+ * @returns An array of all indexed element that match the predicate
+ * (correctly casted to also include the additional type of the predicate).
+ */
+export function getMatchingElements<T>(index: SModelIndex<SModelElement>, predicate: ModelFilterPredicate<T>): (SModelElement & T)[] {
+    return Array.from(filter(index, predicate));
 }
 
-export function hasSelectedElements(element: SModelElement): boolean {
-    return getSelectedElementCount(element) > 0;
+/**
+ * Invokes the given model index to retrieve the corresponding model elements for the given set of ids. Ids that
+ * have no corresponding element in the index will be ignored.
+ * @param index THe model index.
+ * @param elementsIDs The element ids.
+ * @param guard Optional typeguard. If defined only elements that match the guard will be returned.
+ * @returns An array of the model elements that correspond to the given ids and filter predicate.
+ */
+export function getElements<S extends SModelElement>(index: SModelIndex<SModelElement>, elementsIDs: string[], guard?: TypeGuard<S>): S[] {
+    // Internal filter function that filters out undefined model elements and runs an optional typeguard check.
+    const filterFn = (element?: SModelElement): element is S => {
+        if (element !== undefined) {
+            return guard ? guard(element) : true;
+        }
+        return false;
+    };
+    return elementsIDs.map(id => index.getById(id)).filter(filterFn);
 }
-
-export function getSelectedElementCount(element: SModelElement): number {
+/**
+ * Retrieves the amount of currently selected elements in the given {@link SModelIndex}.
+ * @param index The {@link SModelIndex}.
+ * @returns The amount of selected elements.
+ */
+export function getSelectedElementCount(index: SModelIndex<SModelElement>): number {
     let selected = 0;
-    getIndex(element).all()
-        .filter(isSelected)
-        .forEach(e => selected = selected + 1);
+    forEachElement(index, isSelected, element => selected++);
     return selected;
 }
 
+/**
+ * Helper function to check wether an any element is selected in the given {@link SModelIndex}.
+ * @param index The {@link SModelIndex}.
+ * @returns `true` if at least one element is selected, `false` otherwise.
+ */
+export function hasSelectedElements(index: SModelIndex<SModelElement>): boolean {
+    return getSelectedElementCount(index) > 0;
+}
+
+/**
+ * Helper function to check wether an element is defined. Can be used as {@link ModelFilterPredicate}.
+ * @param element The element that should be checked.
+ * @returns the type predicate for `T`
+ */
 export function isNotUndefined<T>(element: T | undefined): element is T {
     return element !== undefined;
 }
 
-export function addCssClasses(root: SModelElement, cssClasses: string[]): void {
-    if (root.cssClasses === undefined) {
-        root.cssClasses = [];
-    }
-    for (const cssClass of cssClasses) {
-        if (root.cssClasses.indexOf(cssClass) < 0) {
-            root.cssClasses.push(cssClass);
-        }
-    }
+/**
+ * Adds a set of css classes to the given {@link SModelElement}.
+ * @param element The element to which the css classes should be added.
+ * @param cssClasses The set of css classes as string array.
+ */
+export function addCssClasses(element: SModelElement, cssClasses: string[]): void {
+    const elementCssClasses: string[] = element.cssClasses ?? [];
+    distinctAdd(elementCssClasses, ...cssClasses);
+    element.cssClasses = elementCssClasses;
 }
 
+/**
+ * Removes a set of css classes from the given {@link SModelElement}.
+ * @param element The element from which the css classes should be removed.
+ * @param cssClasses The set of css classes as string array.
+ */
 export function removeCssClasses(root: SModelElement, cssClasses: string[]): void {
-    if (root.cssClasses === undefined || root.cssClasses.length === 0) {
+    if (!root.cssClasses || root.cssClasses.length === 0) {
         return;
     }
-    for (const cssClass of cssClasses) {
-        const index = root.cssClasses.indexOf(cssClass);
-        if (index !== -1) {
-            root.cssClasses.splice(root.cssClasses.indexOf(cssClass), 1);
-        }
-    }
+    remove(root.cssClasses, ...cssClasses);
 }
 
 export function isNonRoutableSelectedMovableBoundsAware(element: SModelElement): element is SelectableBoundsAware {
     return isNonRoutableSelectedBoundsAware(element) && isMoveable(element);
 }
 
+/**
+ * A typeguard function to check wether a given {@link SModelElement} implements the {@link BoundsAware} model feature,
+ * the {@link Selectable} model feature and is actually selected. In addition, the element must not be a {@link SRoutableElement}.
+ * @param element The element to check.
+ * @returns A type predicate indicating wether the element is of type {@link SelectableBoundsAware}.
+ */
 export function isNonRoutableSelectedBoundsAware(element: SModelElement): element is SelectableBoundsAware {
     return isBoundsAware(element) && isSelected(element) && !isRoutable(element);
 }
 
+/**
+ * A type guard function to check wether a given {@link SModelElement} is a {@link SRoutableElement}.
+ * @param element The element to check.
+ * @returns A type predicate indicating wether the element is a {@link SRoutableElement}.
+ */
 export function isRoutable<T extends SModelElement>(element: T): element is T & SRoutableElement {
     return element instanceof SRoutableElement && (element as any).routingPoints !== undefined;
 }
 
+/**
+ * A typeguard function to check wether a given {@link SModelElement} is a {@link SRoutingHandle}.
+ * @param element The element to check.
+ * @returns A type predicate indicating wether the element is a {@link SRoutingHandle}
+ */
 export function isRoutingHandle(element: SModelElement | undefined): element is SRoutingHandle {
     return element !== undefined && element instanceof SRoutingHandle;
 }
 
-export function isSelectableAndBoundsAware(element: SModelElement): element is BoundsAware & Selectable & SModelElement {
+/**
+ * A typeguard function to check wether a given {@link SModelElement} implements the {@link Selectable} model feature and
+ * the {@link BoundsAware} model feature.
+ * @returns A type predicate indicating wether the element is of type {@link SelectableBoundsAware}.
+ */
+export function isSelectableAndBoundsAware(element: SModelElement): element is SelectableBoundsAware {
     return isSelectable(element) && isBoundsAware(element);
 }
 
+/**
+ * Union type to describe {@link SModelElement}s that implement the {@link Selectable} and {@link BoundsAware} feature.
+ */
 export type SelectableBoundsAware = SModelElement & BoundsAware & Selectable;
 
+/**
+ * Union type to describe {@link SModelElement}s that implement the {@link BoundsAware} feature.
+ */
 export type BoundsAwareModelElement = SModelElement & BoundsAware;
 
-export function toElementAndBounds(element: SModelElement & BoundsAware): ElementAndBounds {
+/**
+ * Helper function to translate a given {@link SModelElement} into its corresponding {@link ElementAndBounds} representation.
+ * @param element The element to translate.
+ * @returns The corresponding {@link ElementAndBounds} for the given element.
+ */
+export function toElementAndBounds(element: BoundsAwareModelElement): ElementAndBounds {
     return {
         elementId: element.id,
         newPosition: {
@@ -124,6 +214,12 @@ export function toElementAndBounds(element: SModelElement & BoundsAware): Elemen
     };
 }
 
+/**
+ * Helper function to translate a given {@link SRoutableElement} into its corresponding
+ * {@ElementAndRoutingPoints ElementAndBounds} representation.
+ * @param element The element to translate.
+ * @returns The corresponding {@link ElementAndRoutingPoints} for the given element.
+ */
 export function toElementAndRoutingPoints(element: SRoutableElement): ElementAndRoutingPoints {
     return {
         elementId: element.id,
@@ -140,6 +236,12 @@ export function hasCompatibleType(input: SModelElement | SModelElementSchema | s
     return inputType === type ? true : inputType.split(':').includes(type);
 }
 
+/**
+ * Convenience function to retrieve the model element type from a given input. The input
+ * can either be a {@link SModelElement}, {@link SModelElementSchema} or a string.
+ * @param input The type input.
+ * @returns The corresponding model type as string.
+ */
 export function getElementTypeId(input: SModelElement | SModelElementSchema | string): string {
     if (typeof input === 'string') {
         return input as string;

package/src/utils/viewpoint-util.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2019 EclipseSource and others.
+ * Copyright (c) 2019-2021 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,15 +13,14 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
+import { Bounds, Point } from '@eclipse-glsp/protocol';
 import {
-    Bounds,
     BoundsAware,
     Dimension,
     findParentByFeature,
     isAlignable,
     isViewport,
     ORIGIN_POINT,
-    Point,
     SModelElement,
     translateBounds,
     Viewport
@@ -41,7 +40,8 @@ import {
  *  A mouseEvent
  */
 export function getAbsolutePosition(target: SModelElement, mouseEvent: MouseEvent): Point {
-    let xPos = mouseEvent.pageX; let yPos = mouseEvent.pageY;
+    let xPos = mouseEvent.pageX;
+    let yPos = mouseEvent.pageY;
     const canvasBounds = target.root.canvasBounds;
     xPos -= canvasBounds.x;
     yPos -= canvasBounds.y;

package/src/views/base-view-module.ts

@@ -13,6 +13,7 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
+import { DefaultTypes } from '@eclipse-glsp/protocol';
 import { ContainerModule, interfaces } from 'inversify';
 import {
     CircularNode,
@@ -45,9 +46,7 @@ import {
     SvgViewportView,
     ViewportRootElement
 } from 'sprotty';
-
 import { GLSPGraph } from '../lib/model';
-import { DefaultTypes } from './default-types';
 import { GEdgeView } from './glsp-edge-view';
 import { GIssueMarkerView } from './issue-marker-view';
 import { RoundedCornerNodeView } from './rounded-corner-view';