@eclipse-glsp/client 0.10.0-next.4ce46ea.160 → 0.10.0-next.6bee8eb.163

package/src/features/validation/validate.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2019-2021 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
@@ -151,7 +151,7 @@ export class ApplyMarkersAction implements MarkersAction {
 @injectable()
 export class ApplyMarkersCommand extends FeedbackCommand {
     static KIND = 'applyMarkers';
-    readonly priority = 0;
+    override readonly priority = 0;
 
     constructor(@inject(TYPES.Action) protected action: ApplyMarkersAction) {
         super();
@@ -171,11 +171,11 @@ export class ApplyMarkersCommand extends FeedbackCommand {
         return context.root;
     }
 
-    undo(context: CommandExecutionContext): CommandReturn {
+    override undo(context: CommandExecutionContext): CommandReturn {
         return context.root;
     }
 
-    redo(context: CommandExecutionContext): CommandReturn {
+    override redo(context: CommandExecutionContext): CommandReturn {
         return this.execute(context);
     }
 }

package/src/features/viewport/glsp-scroll-mouse-listener.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2021 EclipseSource and others.
+ * Copyright (c) 2021-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
@@ -32,7 +32,7 @@ export class GLSPScrollMouseListener extends ScrollMouseListener implements IAct
         }
     }
 
-    mouseDown(target: SModelElement, event: MouseEvent): (Action | Promise<Action>)[] {
+    override mouseDown(target: SModelElement, event: MouseEvent): (Action | Promise<Action>)[] {
         if (this.preventScrolling) {
             return [];
         }

package/src/lib/model.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
@@ -14,12 +14,11 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 import { exportFeature, SGraph, SModelElement, SModelElementSchema, viewportFeature } from 'sprotty/lib';
-
 import { Containable, containerFeature } from '../features/hints/model';
 import { Saveable, saveFeature } from '../features/save/model';
 
 export class GLSPGraph extends SGraph implements Saveable, Containable {
-    static readonly DEFAULT_FEATURES = [viewportFeature, exportFeature, saveFeature, containerFeature];
+    static override readonly DEFAULT_FEATURES = [viewportFeature, exportFeature, saveFeature, containerFeature];
     dirty = false;
     isContainableElement(input: string | SModelElement | SModelElementSchema): boolean {
         return true;

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

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2019-2021 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
@@ -55,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 {
+    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);
         }
@@ -84,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;
     }
 

package/src/utils/smodel-util.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2019-2021 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,7 +13,7 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { ElementAndRoutingPoints } from '@eclipse-glsp/protocol';
+import { distinctAdd, ElementAndRoutingPoints, remove } from '@eclipse-glsp/protocol';
 import {
     BoundsAware,
     ElementAndBounds,
@@ -28,93 +28,161 @@ import {
     SRoutableElement,
     SRoutingHandle
 } from 'sprotty';
+import { FluentIterable } from 'sprotty/lib/utils/iterable';
 
-export function getIndex(element: SModelElement): SModelIndex<SModelElement> {
-    return element.root.index;
+/**
+ * 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;
+
+/**
+ * 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>;
 }
 
+/**
+ * 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>(
-    element: SModelElement,
-    predicate: (modelElement: SModelElement) => modelElement is SModelElement & T,
+    index: SModelIndex<SModelElement>,
+    predicate: ModelFilterPredicate<T>,
     runnable: (modelElement: SModelElement & T) => void
 ): void {
-    getIndex(element).all().filter(predicate).forEach(runnable);
-}
-
-export function getMatchingElements<T>(
-    element: SModelElement,
-    predicate: (modelElement: SModelElement) => modelElement is SModelElement & T
-): (SModelElement & T)[] {
-    const matching: (SModelElement & T)[] = [];
-    forEachElement(element, predicate, item => matching.push(item));
-    return matching;
+    filter(index, predicate).forEach(runnable);
 }
 
-export function hasSelectedElements(element: SModelElement): boolean {
-    return getSelectedElementCount(element) > 0;
+/**
+ * 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 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: {
@@ -128,6 +196,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,
@@ -144,6 +218,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/views/glsp-edge-view.tsx

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2021 EclipseSource and others.
+ * Copyright (c) 2021-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
@@ -24,7 +24,7 @@ const JSX = { createElement: svg };
 
 @injectable()
 export class GEdgeView extends PolylineEdgeView {
-    render(edge: Readonly<SEdge>, context: RenderingContext): VNode {
+    override render(edge: Readonly<SEdge>, context: RenderingContext): VNode {
         const router = this.edgeRouterRegistry.get(edge.routerKind);
         const route = router.route(edge);
         if (route.length === 0) {
@@ -44,11 +44,11 @@ export class GEdgeView extends PolylineEdgeView {
         return {};
     }
 
-    protected renderLine(_edge: SEdge, segments: Point[], _context: RenderingContext): VNode {
+    protected override renderLine(_edge: SEdge, segments: Point[], _context: RenderingContext): VNode {
         return <path d={this.createPathForSegments(segments)} />;
     }
 
-    protected renderAdditionals(edge: SEdge, segments: Point[], _context: RenderingContext): VNode[] {
+    protected override renderAdditionals(edge: SEdge, segments: Point[], _context: RenderingContext): VNode[] {
         // for additional padding we draw another transparent path with larger stroke width
         const edgePadding = EdgePadding.from(edge);
         return edgePadding ? [this.renderMouseHandle(segments, edgePadding)] : [];

package/src/views/issue-marker-view.tsx

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2020-2021 EclipseSource and others.
+ * Copyright (c) 2020-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
@@ -23,7 +23,7 @@ const JSX = { createElement: svg };
 
 @injectable()
 export class GIssueMarkerView extends IssueMarkerView {
-    render(marker: SIssueMarker, _context: RenderingContext): VNode {
+    override render(marker: SIssueMarker, _context: RenderingContext): VNode {
         const maxSeverity = super.getMaxSeverity(marker);
         const group = (
             <g class-sprotty-issue={true}>

package/src/views/rounded-corner-view.tsx

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2021 EclipseSource and others.
+ * Copyright (c) 2021-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
@@ -16,7 +16,6 @@
 import { injectable } from 'inversify';
 import { Classes, VNode } from 'snabbdom';
 import { Hoverable, RectangularNodeView, RenderingContext, Selectable, SNode, SPort, SShapeElement, svg } from 'sprotty';
-
 import { CornerRadius } from '../utils/argument-utils';
 import { RoundedCornerWrapper } from './rounded-corner';
 
@@ -25,7 +24,7 @@ const JSX = { createElement: svg };
 
 @injectable()
 export class RoundedCornerNodeView extends RectangularNodeView {
-    render(node: Readonly<SShapeElement & Hoverable & Selectable>, context: RenderingContext): VNode | undefined {
+    override render(node: Readonly<SShapeElement & Hoverable & Selectable>, context: RenderingContext): VNode | undefined {
         const cornerRadius = CornerRadius.from(node);
         if (!cornerRadius) {
             return this.renderWithoutRadius(node, context);