@eclipse-glsp/client 0.9.0-next.c5944e10

package/src/utils/argument-utils.ts

@@ -0,0 +1,127 @@
+/********************************************************************************
+ * Copyright (c) 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
+ * 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 } from 'sprotty';
+
+import { hasArguments } from '../base/args';
+
+export namespace GArgument {
+    export function asNumber(argValue: (string | number | boolean)): number | undefined {
+        return typeof argValue === 'number' ? argValue : undefined;
+    }
+
+    export function asNumbers(argValues: (string | number | boolean)[]): (number | undefined)[] {
+        return argValues.map(asNumber);
+    }
+
+    export function asString(argValue: (string | number | boolean)): string | undefined {
+        return typeof argValue === 'string' ? argValue : undefined;
+    }
+
+    export function asStrings(argValues: (string | number | boolean)[]): (string | undefined)[] {
+        return argValues.map(asString);
+    }
+
+    export function asBoolean(argValue: (string | number | boolean)): boolean | undefined {
+        return typeof argValue === 'boolean' ? argValue : undefined;
+    }
+
+    export function asBooleans(argValues: (string | number | boolean)[]): (boolean | undefined)[] {
+        return argValues.map(asBoolean);
+    }
+
+    export function getArgument(element: SModelElement | undefined, key: string): string | number | boolean | undefined {
+        return hasArguments(element) ? element.args[key] : undefined;
+    }
+
+    export function getNumber(element: SModelElement | undefined, key: string): number | undefined {
+        return hasArguments(element) ? asNumber(element.args[key]) : undefined;
+    }
+
+    export function getString(element: SModelElement | undefined, key: string): string | undefined {
+        return hasArguments(element) ? asString(element.args[key]) : undefined;
+    }
+
+    export function getBoolean(element: SModelElement | undefined, key: string): boolean | undefined {
+        return hasArguments(element) ? asBoolean(element.args[key]) : undefined;
+    }
+
+    export function getArguments(element: SModelElement | undefined, ...keys: string[]): (number | boolean | string)[] | undefined {
+        if (!hasArguments(element)) {
+            return undefined;
+        }
+        const values = [];
+        for (const key of keys) {
+            const value = element.args[key];
+            if (value) {
+                values.push(value);
+            }
+        }
+        return values;
+    }
+
+    export function getNumbers(element: SModelElement | undefined, ...keys: string[]): (number | undefined)[] | undefined {
+        const values = getArguments(element, ...keys);
+        return values ? asNumbers(values) : undefined;
+    }
+
+    export function getStrings(element: SModelElement | undefined, ...keys: string[]): (string | undefined)[] | undefined {
+        const values = getArguments(element, ...keys);
+        return values ? asStrings(values) : undefined;
+    }
+
+    export function getBooleans(element: SModelElement | undefined, ...keys: string[]): (boolean | undefined)[] | undefined {
+        const values = getArguments(element, ...keys);
+        return values ? asBooleans(values) : undefined;
+    }
+
+    export function hasNValues<T>(values: (T | undefined)[], length: number): values is T[] {
+        return values.length === length && values.filter(e => e === undefined).length === 0;
+    }
+}
+
+export namespace EdgePadding {
+    const KEY = 'edgePadding';
+
+    export function from(element: SModelElement | undefined): number | undefined {
+        return GArgument.getNumber(element, KEY);
+    }
+}
+
+export class CornerRadius {
+    static NO_RADIUS = new CornerRadius(0);
+
+    static KEY_RADIUS_TOP_LEFT = 'radiusTopLeft';
+    static KEY_RADIUS_TOP_RIGHT = 'radiusTopRight';
+    static KEY_RADIUS_BOTTOM_RIGHT = 'radiusBottomRight';
+    static KEY_RADIUS_BOTTOM_LEFT = 'radiusBottomLeft';
+
+    constructor(
+        public readonly topLeft: number = 0,
+        public readonly topRight: number = topLeft,
+        public readonly bottomRight: number = topLeft,
+        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);
+        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]);
+    }
+}

package/src/utils/array-utils.ts

@@ -0,0 +1,55 @@
+/********************************************************************************
+ * 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
+ ********************************************************************************/
+
+export function remove<T>(array: T[], value: T): boolean {
+    const index = array.indexOf(value);
+    if (index >= 0) {
+        array.splice(index, 1);
+        return true;
+    }
+    return false;
+}
+
+export function distinctAdd<T>(array: T[], value: T): boolean {
+    if (!array.includes(value)) {
+        array.push(value);
+        return true;
+    }
+    return false;
+}
+
+interface Constructor<T> { new(...args: any[]): T }
+type PrimitiveType = 'bigint' | 'boolean' | 'function' | 'number' | 'object' | 'string' | 'symbol' | 'undefined';
+
+export function isArrayOfType<T>(object: any, typeGuard: (elem: any) => elem is T, supportEmpty = false): object is T[] {
+    return isArrayMatching(object, element => typeGuard(element), supportEmpty);
+}
+
+export function isArrayOfClass<T>(object: any, className: Constructor<T>, supportEmpty = false): object is T[] {
+    return isArrayMatching(object, element => element instanceof className, supportEmpty);
+}
+
+export function isArrayOfPrimitive<T>(object: any, primitiveType: PrimitiveType, supportEmpty = false): object is T[] {
+    return isArrayMatching(object, element => typeof element === primitiveType, supportEmpty);
+}
+
+export function isStringArray(object: any, supportEmpty = false): object is string[] {
+    return isArrayOfPrimitive(object, 'string', supportEmpty);
+}
+
+export function isArrayMatching(object: any, predicate: (elem: any) => boolean, supportEmpty = false): boolean {
+    return Array.isArray(object) && object.every(predicate) && (supportEmpty || object.length > 0);
+}

package/src/utils/html-utils.ts

@@ -0,0 +1,25 @@
+/********************************************************************************
+ * 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
+ ********************************************************************************/
+export function createElementFromHTML(html: string): HTMLElement | undefined {
+    const template = document.createElement('template');
+    html = html.trim(); // Never return a text node of whitespace as the result
+    template.innerHTML = html;
+    const node = template.content.firstChild;
+    if (node && node instanceof HTMLElement) {
+        return node as HTMLElement;
+    }
+    return undefined;
+}

package/src/utils/layout-utils.ts

@@ -0,0 +1,97 @@
+/********************************************************************************
+ * 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 { BoundsAware, Dimension, ElementAndBounds, ElementMove, ModelLayoutOptions, Point, SModelElement } from 'sprotty';
+
+import { IMovementRestrictor } from '../features/change-bounds/movement-restrictor';
+
+export function minWidth(element: SModelElement & BoundsAware): number {
+    const layoutOptions = getLayoutOptions(element);
+    if (layoutOptions !== undefined && typeof layoutOptions.minWidth === 'number') {
+        return layoutOptions.minWidth;
+    }
+    return 1;
+}
+
+export function minHeight(element: SModelElement & BoundsAware): number {
+    const layoutOptions = getLayoutOptions(element);
+    if (layoutOptions !== undefined && typeof layoutOptions.minHeight === 'number') {
+        return layoutOptions.minHeight;
+    }
+    return 1;
+}
+
+export function getLayoutOptions(element: SModelElement): ModelLayoutOptions | undefined {
+    const layoutOptions = (element as any).layoutOptions;
+    if (layoutOptions !== undefined) {
+        return layoutOptions as ModelLayoutOptions;
+    }
+    return undefined;
+}
+
+export function isValidSize(element: SModelElement & BoundsAware, size: Dimension): boolean {
+    return size.width >= minWidth(element) && size.height >= minHeight(element);
+}
+
+export function isValidMove(element: SModelElement & BoundsAware, newPosition: Point, movementRestrictor?: IMovementRestrictor): boolean {
+    if (movementRestrictor) {
+        return movementRestrictor.validate(newPosition, element);
+    }
+    return true;
+}
+
+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 {
+
+    if (!isValidMove(element, bounds.newPosition, movementRestrictor)) {
+        return;
+    }
+    const elementMinWidth = minWidth(element);
+    if (bounds.newSize.width < elementMinWidth) {
+        bounds.newSize.width = elementMinWidth;
+    }
+    const elementMinHeight = minHeight(element);
+    if (bounds.newSize.height < elementMinHeight) {
+        bounds.newSize.height = elementMinHeight;
+    }
+    return bounds;
+}
+
+export interface WriteablePoint extends Point {
+    x: number;
+    y: number;
+}
+
+export interface WriteableElementMove extends ElementMove {
+    fromPosition?: WriteablePoint;
+    toPosition: WriteablePoint;
+}
+
+export interface WriteableDimension extends Dimension {
+    width: number;
+    height: number;
+}
+
+export interface WriteableElementAndBounds extends ElementAndBounds {
+    newPosition: WriteablePoint;
+    newSize: WriteableDimension;
+}

package/src/utils/marker.ts

@@ -0,0 +1,63 @@
+/********************************************************************************
+ * 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 { 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);
+    export const WARNINGS = (marker: SIssueMarker): boolean => hasIssueWithSeverity(marker, MarkerKind.WARNING);
+    export const INFOS = (marker: SIssueMarker): boolean => hasIssueWithSeverity(marker, MarkerKind.INFO);
+
+    export function hasIssueWithSeverity(marker: SIssueMarker, severity: 'info' | 'warning' | 'error'): boolean {
+        return marker.issues.find(issue => issue.severity === severity) !== undefined;
+    }
+}
+
+export function collectIssueMarkers(root: SParentElement): SIssueMarker[] {
+    const markers = [];
+    for (const child of root.children) {
+        if (child instanceof SIssueMarker) {
+            markers.push(child);
+        }
+        markers.push(...collectIssueMarkers(child));
+    }
+    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

@@ -0,0 +1,149 @@
+/********************************************************************************
+ * 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 {
+    BoundsAware,
+    ElementAndBounds,
+    isBoundsAware,
+    isMoveable,
+    isSelectable,
+    isSelected,
+    Selectable,
+    SModelElement,
+    SModelElementSchema,
+    SModelIndex,
+    SRoutableElement,
+    SRoutingHandle
+} from 'sprotty';
+
+import { ElementAndRoutingPoints } from '../base/operations/operation';
+
+export function getIndex(element: SModelElement): SModelIndex<SModelElement> {
+    return element.root.index;
+}
+
+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);
+}
+
+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;
+}
+
+export function hasSelectedElements(element: SModelElement): boolean {
+    return getSelectedElementCount(element) > 0;
+}
+
+export function getSelectedElementCount(element: SModelElement): number {
+    let selected = 0;
+    getIndex(element).all()
+        .filter(isSelected)
+        .forEach(e => selected = selected + 1);
+    return selected;
+}
+
+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);
+        }
+    }
+}
+
+export function removeCssClasses(root: SModelElement, cssClasses: string[]): void {
+    if (root.cssClasses === undefined || 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);
+        }
+    }
+}
+
+export function isNonRoutableSelectedMovableBoundsAware(element: SModelElement): element is SelectableBoundsAware {
+    return isNonRoutableSelectedBoundsAware(element) && isMoveable(element);
+}
+
+export function isNonRoutableSelectedBoundsAware(element: SModelElement): element is SelectableBoundsAware {
+    return isBoundsAware(element) && isSelected(element) && !isRoutable(element);
+}
+
+export function isRoutable<T extends SModelElement>(element: T): element is T & SRoutableElement {
+    return element instanceof SRoutableElement && (element as any).routingPoints !== undefined;
+}
+
+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 {
+    return isSelectable(element) && isBoundsAware(element);
+}
+
+export type SelectableBoundsAware = SModelElement & BoundsAware & Selectable;
+
+export type BoundsAwareModelElement = SModelElement & BoundsAware;
+
+export function toElementAndBounds(element: SModelElement & BoundsAware): ElementAndBounds {
+    return {
+        elementId: element.id,
+        newPosition: {
+            x: element.bounds.x,
+            y: element.bounds.y
+        },
+        newSize: {
+            width: element.bounds.width,
+            height: element.bounds.height
+        }
+    };
+}
+
+export function toElementAndRoutingPoints(element: SRoutableElement): ElementAndRoutingPoints {
+    return {
+        elementId: element.id,
+        newRoutingPoints: element.routingPoints
+    };
+}
+
+/**
+ * Checks if the model is compatible with the passed type string.
+ * (either has the same type or a subtype of this type)
+ */
+export function hasCompatibleType(input: SModelElement | SModelElementSchema | string, type: string): boolean {
+    const inputType = getElementTypeId(input);
+    return inputType === type ? true : inputType.split(':').includes(type);
+}
+
+export function getElementTypeId(input: SModelElement | SModelElementSchema | string): string {
+    if (typeof input === 'string') {
+        return input as string;
+    } else {
+        return (input as any)['type'] as string;
+    }
+}

package/src/utils/viewpoint-util.ts

@@ -0,0 +1,99 @@
+/********************************************************************************
+ * 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 {
+    Bounds,
+    BoundsAware,
+    Dimension,
+    findParentByFeature,
+    isAlignable,
+    isViewport,
+    ORIGIN_POINT,
+    Point,
+    SModelElement,
+    translateBounds,
+    Viewport
+} from 'sprotty';
+
+/**
+ * Return the position corresponding to this mouse event (Browser coordinates)
+ * in the diagram coordinates system (i.e. relative to the Diagram's 0;0 point)
+ *
+ * This functions takes into account the following transformations:
+ * - Location of the Diagram Canvas inside of the browser's page
+ * - Current viewport Scroll and Zoom
+ *
+ * @param target
+ *  An element from the diagram
+ * @param mouseEvent
+ *  A mouseEvent
+ */
+export function getAbsolutePosition(target: SModelElement, mouseEvent: MouseEvent): Point {
+    let xPos = mouseEvent.pageX; let yPos = mouseEvent.pageY;
+    const canvasBounds = target.root.canvasBounds;
+    xPos -= canvasBounds.x;
+    yPos -= canvasBounds.y;
+
+    const viewport: Viewport | undefined = findParentByFeature(target, isViewport);
+    const zoom = viewport ? viewport.zoom : 1;
+    if (viewport) {
+        const scroll: Point = { x: viewport.scroll.x, y: viewport.scroll.y };
+        xPos += scroll.x * zoom;
+        yPos += scroll.y * zoom;
+
+        xPos /= zoom;
+        yPos /= zoom;
+    }
+
+    return {
+        x: xPos,
+        y: yPos
+    };
+}
+
+/**
+ * Translates the bounds of the diagram element (local coordinates) into the diagram coordinates system
+ * (i.e. relative to the Diagram's 0;0 point)
+ *
+ * @param target  A bounds-aware element from the diagram
+ */
+export function toAbsoluteBounds(element: SModelElement & BoundsAware): Bounds {
+    const location = isAlignable(element) ? element.alignment : ORIGIN_POINT;
+    const x = location.x;
+    const y = location.y;
+    const width = element.bounds.width;
+    const height = element.bounds.height;
+    return translateBounds({ x, y, width, height }, element, element.root);
+}
+
+/**
+ * Translates the position of the diagram element (local coordinates) into the diagram coordinates system
+ * (i.e. relative to the Diagram's 0;0 point)
+ *
+ * @param target  A bounds-aware element from the diagram
+ */
+export function toAbsolutePosition(target: SModelElement & BoundsAware): Point {
+    return toAbsoluteBounds(target);
+}
+
+/**
+ * Translates the size of the diagram element (local coordinates) into the diagram coordinates system
+ * (i.e. relative to the Diagram's 0;0 point)
+ *
+ * @param target  A bounds-aware element from the diagram
+ */
+export function toAbsoluteSize(target: SModelElement & BoundsAware): Dimension {
+    return toAbsoluteBounds(target);
+}