@eclipse-glsp/client 0.9.0-next.c5944e10 → 0.9.0-next.fd1a8bb6

package/src/features/tools/marquee-mouse-tool.ts

@@ -65,7 +65,6 @@ export class MarqueeMouseTool extends BaseGLSPTool {
 
 @injectable()
 export class MarqueeMouseListener extends DragAwareMouseListener {
-
     protected startPoint: Point;
 
     protected currentPoint: Point;
@@ -84,11 +83,14 @@ export class MarqueeMouseListener extends DragAwareMouseListener {
     mouseDown(target: SModelElement, event: MouseEvent): Action[] {
         this.isActive = true;
         this.startPoint = { x: getAbsolutePosition(target, event).x, y: getAbsolutePosition(target, event).y };
-        if(event.ctrlKey){
-            this.previouslySelected = Array.from(target.root.index.all()
-                .map(e => e as SModelElement & BoundsAware)
-                .filter(e => isSelected(e))
-                .map(e => e.id));
+        if (event.ctrlKey) {
+            this.previouslySelected = Array.from(
+                target.root.index
+                    .all()
+                    .map(e => e as SModelElement & BoundsAware)
+                    .filter(e => isSelected(e))
+                    .map(e => e.id)
+            );
         }
         return [];
     }
@@ -96,18 +98,21 @@ export class MarqueeMouseListener extends DragAwareMouseListener {
     mouseMove(target: SModelElement, event: MouseEvent): Action[] {
         this.currentPoint = { x: getAbsolutePosition(target, event).x, y: getAbsolutePosition(target, event).y };
         if (this.isActive) {
-            const nodeIdsSelected = Array.from(target.root.index.all()
-                .map(e => e as SModelElement & BoundsAware)
-                .filter(e => isSelectable(e))
-                .filter(e => e instanceof SNode)
-                .filter(e => this.isNodeMarked(e)).map(e => e.id));
+            const nodeIdsSelected = Array.from(
+                target.root.index
+                    .all()
+                    .map(e => e as SModelElement & BoundsAware)
+                    .filter(e => isSelectable(e))
+                    .filter(e => e instanceof SNode)
+                    .filter(e => this.isNodeMarked(e))
+                    .map(e => e.id)
+            );
             const edgeIdsSelected = this.getMarkedEdges(target.root);
             const selected = nodeIdsSelected.concat(edgeIdsSelected);
             return [
                 new SelectAction([], Array.from(target.root.index.all().map(e => e.id))),
                 new SelectAction(selected.concat(this.previouslySelected), []),
-                new DrawMarqueeAction(this.startPoint,
-                    { x: getAbsolutePosition(target, event).x, y: getAbsolutePosition(target, event).y })
+                new DrawMarqueeAction(this.startPoint, { x: getAbsolutePosition(target, event).x, y: getAbsolutePosition(target, event).y })
             ];
         }
         return [];
@@ -123,10 +128,17 @@ export class MarqueeMouseListener extends DragAwareMouseListener {
 
     getMarkedEdges(root: SModelElement): string[] {
         const elements = Array.from(document.querySelectorAll('g'));
-        const edges = Array.from(root.index.all().filter(e => e instanceof SEdge).
-            filter(e => isSelectable(e)).map(e => e.id));
-        return elements.filter(e => edges.includes(this.domHelper.findSModelIdByDOMElement(e)))
-            .filter(e => this.isEdgeMarked(e)).map(e => this.domHelper.findSModelIdByDOMElement(e));
+        const edges = Array.from(
+            root.index
+                .all()
+                .filter(e => e instanceof SEdge)
+                .filter(e => isSelectable(e))
+                .map(e => e.id)
+        );
+        return elements
+            .filter(e => edges.includes(this.domHelper.findSModelIdByDOMElement(e)))
+            .filter(e => this.isEdgeMarked(e))
+            .map(e => this.domHelper.findSModelIdByDOMElement(e));
     }
 
     isEdgeMarked(element: SVGElement): boolean {
@@ -170,11 +182,11 @@ export class MarqueeMouseListener extends DragAwareMouseListener {
     }
 
     linesIntersect(p1: Point, p2: Point, p3: Point, p4: Point): boolean {
-        const tCount = ((p1.x - p3.x) * (p3.y - p4.y)) - ((p1.y - p3.y) * (p3.x - p4.x));
-        const tDenom = ((p1.x - p2.x) * (p3.y - p4.y)) - ((p1.y - p2.y) * (p3.x - p4.x));
+        const tCount = (p1.x - p3.x) * (p3.y - p4.y) - (p1.y - p3.y) * (p3.x - p4.x);
+        const tDenom = (p1.x - p2.x) * (p3.y - p4.y) - (p1.y - p2.y) * (p3.x - p4.x);
         const t = tCount / tDenom;
-        const uCount = ((p2.x - p1.x) * (p1.y - p3.y)) - ((p2.y - p1.y) * (p1.x - p3.x));
-        const uDenom = ((p1.x - p2.x) * (p3.y - p4.y)) - ((p1.y - p2.y) * (p3.x - p4.x));
+        const uCount = (p2.x - p1.x) * (p1.y - p3.y) - (p2.y - p1.y) * (p1.x - p3.x);
+        const uDenom = (p1.x - p2.x) * (p3.y - p4.y) - (p1.y - p2.y) * (p3.x - p4.x);
         const u = uCount / uDenom;
         if (t >= 0.0 && t <= 1.0 && u >= 0.0 && u <= 1.0) {
             return true;
@@ -183,20 +195,26 @@ export class MarqueeMouseListener extends DragAwareMouseListener {
     }
 
     pointInRect(point: Point): boolean {
-        const boolX = this.startPoint.x <= this.currentPoint.x ?
-            this.isBetween(point.x, this.startPoint.x, this.currentPoint.x) : this.isBetween(point.x, this.currentPoint.x, this.startPoint.x);
-        const boolY = this.startPoint.y <= this.currentPoint.y ?
-            this.isBetween(point.y, this.startPoint.y, this.currentPoint.y) : this.isBetween(point.y, this.currentPoint.y, this.startPoint.y);
+        const boolX =
+            this.startPoint.x <= this.currentPoint.x
+                ? this.isBetween(point.x, this.startPoint.x, this.currentPoint.x)
+                : this.isBetween(point.x, this.currentPoint.x, this.startPoint.x);
+        const boolY =
+            this.startPoint.y <= this.currentPoint.y
+                ? this.isBetween(point.y, this.startPoint.y, this.currentPoint.y)
+                : this.isBetween(point.y, this.currentPoint.y, this.startPoint.y);
         return boolX && boolY;
     }
 
     isNodeMarked(element: SModelElement & BoundsAware): boolean {
-        const horizontallyIn = this.startPoint.x < this.currentPoint.x ?
-            this.isElementBetweenXAxis(element, this.startPoint.x, this.currentPoint.x) :
-            this.isElementBetweenXAxis(element, this.currentPoint.x, this.startPoint.x);
-        const verticallyIn = this.startPoint.y < this.currentPoint.y ?
-            this.isElementBetweenYAxis(element, this.startPoint.y, this.currentPoint.y) :
-            this.isElementBetweenYAxis(element, this.currentPoint.y, this.startPoint.y);
+        const horizontallyIn =
+            this.startPoint.x < this.currentPoint.x
+                ? this.isElementBetweenXAxis(element, this.startPoint.x, this.currentPoint.x)
+                : this.isElementBetweenXAxis(element, this.currentPoint.x, this.startPoint.x);
+        const verticallyIn =
+            this.startPoint.y < this.currentPoint.y
+                ? this.isElementBetweenYAxis(element, this.startPoint.y, this.currentPoint.y)
+                : this.isElementBetweenYAxis(element, this.currentPoint.y, this.startPoint.y);
         if (horizontallyIn && verticallyIn) {
             return true;
         }
@@ -204,8 +222,10 @@ export class MarqueeMouseListener extends DragAwareMouseListener {
     }
 
     isElementBetweenXAxis(element: SModelElement & BoundsAware, marqueeLeft: number, marqueeRight: number): boolean {
-        if (this.isBetween(marqueeLeft, toAbsoluteBounds(element).x, toAbsoluteBounds(element).x + toAbsoluteBounds(element).width)
-            || this.isBetween(marqueeRight, toAbsoluteBounds(element).x, toAbsoluteBounds(element).x + toAbsoluteBounds(element).width)) {
+        if (
+            this.isBetween(marqueeLeft, toAbsoluteBounds(element).x, toAbsoluteBounds(element).x + toAbsoluteBounds(element).width) ||
+            this.isBetween(marqueeRight, toAbsoluteBounds(element).x, toAbsoluteBounds(element).x + toAbsoluteBounds(element).width)
+        ) {
             return true;
         }
         const leftEdge = this.isBetween(toAbsoluteBounds(element).x, marqueeLeft, marqueeRight);
@@ -214,8 +234,10 @@ export class MarqueeMouseListener extends DragAwareMouseListener {
     }
 
     isElementBetweenYAxis(element: SModelElement & BoundsAware, marqueeTop: number, marqueeBottom: number): boolean {
-        if (this.isBetween(marqueeTop, toAbsoluteBounds(element).y, toAbsoluteBounds(element).y + toAbsoluteBounds(element).height)
-            || this.isBetween(marqueeBottom, toAbsoluteBounds(element).y, toAbsoluteBounds(element).y + toAbsoluteBounds(element).height)) {
+        if (
+            this.isBetween(marqueeTop, toAbsoluteBounds(element).y, toAbsoluteBounds(element).y + toAbsoluteBounds(element).height) ||
+            this.isBetween(marqueeBottom, toAbsoluteBounds(element).y, toAbsoluteBounds(element).y + toAbsoluteBounds(element).height)
+        ) {
             return true;
         }
         const topEdge = this.isBetween(toAbsoluteBounds(element).y, marqueeTop, marqueeBottom);
@@ -229,12 +251,10 @@ export class MarqueeMouseListener extends DragAwareMouseListener {
         }
         return false;
     }
-
 }
 
 @injectable()
 export class ShiftKeyListener extends KeyListener {
-
     keyUp(element: SModelElement, event: KeyboardEvent): Action[] {
         if (event.shiftKey) {
             return [];

package/src/features/tools/marquee-tool.ts

@@ -42,7 +42,6 @@ export class MarqueeTool extends BaseGLSPTool {
 
 @injectable()
 export class MarqueeKeyListener extends KeyListener {
-
     keyDown(element: SModelElement, event: KeyboardEvent): Action[] {
         if (event.shiftKey) {
             return [new EnableToolsAction([MarqueeMouseTool.ID])];

package/src/features/tools/node-creation-tool.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
@@ -28,11 +28,7 @@ import {
 } from 'sprotty';
 
 import { DragAwareMouseListener } from '../../base/drag-aware-mouse-listener';
-import {
-    CreateNodeOperation,
-    isTriggerNodeCreationAction,
-    TriggerNodeCreationAction
-} from '../../base/operations/operation';
+import { CreateNodeOperation, isTriggerNodeCreationAction, TriggerNodeCreationAction } from '../../base/operations/operation';
 import { getAbsolutePosition } from '../../utils/viewpoint-util';
 import { Containable, isContainable } from '../hints/model';
 import { CursorCSS, cursorFeedbackAction } from '../tool-feedback/css-feedback';
@@ -75,7 +71,6 @@ export class NodeCreationTool extends BaseGLSPTool implements IActionHandler {
 
 @injectable()
 export class NodeCreationToolMouseListener extends DragAwareMouseListener {
-
     protected container?: SModelElement & Containable;
 
     constructor(protected triggerAction: TriggerNodeCreationAction, protected tool: NodeCreationTool) {
@@ -114,8 +109,8 @@ export class NodeCreationToolMouseListener extends DragAwareMouseListener {
         if (!this.container || currentContainer !== this.container) {
             this.container = currentContainer;
             const feedback = this.creationAllowed(this.elementTypeId)
-                ? cursorFeedbackAction(CursorCSS.NODE_CREATION) :
-                cursorFeedbackAction(CursorCSS.OPERATION_NOT_ALLOWED);
+                ? cursorFeedbackAction(CursorCSS.NODE_CREATION)
+                : cursorFeedbackAction(CursorCSS.OPERATION_NOT_ALLOWED);
             this.tool.dispatchFeedback([feedback]);
         }
         return [];

package/src/features/tools/view.tsx

@@ -25,14 +25,20 @@ const JSX = { createElement: svg };
 @injectable()
 export class MarqueeView extends RectangularNodeView {
     render(node: MarqueeNode, context: RenderingContext): VNode {
-        const graph = <g>
-            <rect class-sprotty-node={true} class-marquee={true}
-                x={((node.startPoint.x - node.endPoint.x) <= 0) ? node.startPoint.x : node.endPoint.x}
-                y={((node.startPoint.y - node.endPoint.y) <= 0) ? node.startPoint.y : node.endPoint.y}
-                rx={0} ry={0}
-                width={Math.abs(node.startPoint.x - node.endPoint.x)}
-                height={Math.abs(node.startPoint.y - node.endPoint.y)}></rect>
-        </g>;
+        const graph = (
+            <g>
+                <rect
+                    class-sprotty-node={true}
+                    class-marquee={true}
+                    x={node.startPoint.x - node.endPoint.x <= 0 ? node.startPoint.x : node.endPoint.x}
+                    y={node.startPoint.y - node.endPoint.y <= 0 ? node.startPoint.y : node.endPoint.y}
+                    rx={0}
+                    ry={0}
+                    width={Math.abs(node.startPoint.x - node.endPoint.x)}
+                    height={Math.abs(node.startPoint.y - node.endPoint.y)}
+                ></rect>
+            </g>
+        );
         return graph;
     }
 }

package/src/features/undo-redo/model.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
@@ -17,10 +17,10 @@ import { Operation } from '../../base/operations/operation';
 
 export class UndoOperation implements Operation {
     static readonly KIND = 'glspUndo';
-    constructor(public readonly kind = UndoOperation.KIND) { }
+    constructor(public readonly kind = UndoOperation.KIND) {}
 }
 
 export class RedoOperation implements Operation {
     static readonly KIND = 'glspRedo';
-    constructor(public readonly kind = RedoOperation.KIND) { }
+    constructor(public readonly kind = RedoOperation.KIND) {}
 }

package/src/features/validation/marker-navigator.spec.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
@@ -45,7 +45,9 @@ describe('MarkerNavigator', () => {
     const markerNavigator = container.get<MarkerNavigator>(MarkerNavigator);
 
     const rootWithoutAnyMarkers = graphFactory.createRoot({
-        id: 'root', type: 'graph', children: [
+        id: 'root',
+        type: 'graph',
+        children: [
             {
                 id: '1',
                 type: 'node'
@@ -54,18 +56,24 @@ describe('MarkerNavigator', () => {
     }) as SModelRoot;
 
     const rootWithMarkers = graphFactory.createRoot({
-        id: 'root', type: 'graph', children: [
+        id: 'root',
+        type: 'graph',
+        children: [
             {
-                id: 'bottom-right', type: 'node'
+                id: 'bottom-right',
+                type: 'node'
             } as SNodeSchema,
             {
-                id: 'top-right', type: 'node'
+                id: 'top-right',
+                type: 'node'
             } as SNodeSchema,
             {
-                id: 'top-left', type: 'node'
+                id: 'top-left',
+                type: 'node'
             } as SNodeSchema,
             {
-                id: 'bottom-left', type: 'node'
+                id: 'bottom-left',
+                type: 'node'
             } as SNodeSchema
         ]
     }) as SModelRoot;
@@ -168,7 +176,6 @@ describe('MarkerNavigator', () => {
         expect(found4).to.eql(marker2);
         expect(found5).to.eql(marker1);
     });
-
 });
 
 function clearMarker(elem: SParentElement): void {
@@ -204,4 +211,3 @@ function createMarker(elem: SParentElement): SIssueMarker {
     elem.add(newMarker);
     return newMarker;
 }
-

package/src/features/validation/marker-navigator.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
@@ -51,7 +51,8 @@ export class NavigateToMarkerAction implements Action {
         public readonly direction: 'next' | 'previous' = 'next',
         public readonly selectedElementIds?: string[],
         public readonly severities: SIssueSeverity[] = MarkerNavigator.ALL_SEVERITIES,
-        public kind = NavigateToMarkerAction.KIND) { }
+        public kind = NavigateToMarkerAction.KIND
+    ) {}
 }
 
 export class SModelElementComparator {
@@ -90,7 +91,11 @@ export class MarkerNavigator {
     @inject(SModelElementComparator)
     protected markerComparator: SModelElementComparator;
 
-    next(root: SModelRoot, current?: SModelElement & BoundsAware, predicate: (marker: SIssueMarker) => boolean = MarkerPredicates.ALL): SIssueMarker | undefined {
+    next(
+        root: SModelRoot,
+        current?: SModelElement & BoundsAware,
+        predicate: (marker: SIssueMarker) => boolean = MarkerPredicates.ALL
+    ): SIssueMarker | undefined {
         const markers = this.getMarkers(root, predicate);
         if (current === undefined) {
             return markers.length > 0 ? markers[0] : undefined;
@@ -98,7 +103,11 @@ export class MarkerNavigator {
         return markers[this.getNextIndex(current, markers) % markers.length];
     }
 
-    previous(root: SModelRoot, current?: SModelElement & BoundsAware, predicate: (marker: SIssueMarker) => boolean = MarkerPredicates.ALL): SIssueMarker | undefined {
+    previous(
+        root: SModelRoot,
+        current?: SModelElement & BoundsAware,
+        predicate: (marker: SIssueMarker) => boolean = MarkerPredicates.ALL
+    ): SIssueMarker | undefined {
         const markers = this.getMarkers(root, predicate);
         if (current === undefined) {
             return markers.length > 0 ? markers[0] : undefined;
@@ -206,7 +215,6 @@ export class NavigateToMarkerCommand extends Command {
         }
         return this.centerCommand ? this.centerCommand.redo(context) : context.root;
     }
-
 }
 
 @injectable()
@@ -218,15 +226,22 @@ export class MarkerNavigatorContextMenuItemProvider implements IContextMenuItemP
         const hasMarkers = collectIssueMarkers(root).length > 0;
         return Promise.resolve([
             {
-                id: 'navigate', label: 'Go to', group: 'navigate', actions: [],
+                id: 'navigate',
+                label: 'Go to',
+                group: 'navigate',
+                actions: [],
                 children: [
                     {
-                        id: 'next-marker', label: 'Next marker', group: 'marker',
+                        id: 'next-marker',
+                        label: 'Next marker',
+                        group: 'marker',
                         actions: [new NavigateToMarkerAction('next', selectedElementIds)],
                         isEnabled: () => hasMarkers
                     },
                     {
-                        id: 'previous-marker', label: 'Previous marker', group: 'marker',
+                        id: 'previous-marker',
+                        label: 'Previous marker',
+                        group: 'marker',
                         actions: [new NavigateToMarkerAction('previous', selectedElementIds)],
                         isEnabled: () => hasMarkers
                     }

package/src/features/validation/validate.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2019-2020 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
@@ -43,7 +43,6 @@ import { createSIssue, getOrCreateSIssueMarker, getSIssueMarker } from './issue-
  */
 @injectable()
 export class ValidationFeedbackEmitter implements IFeedbackEmitter {
-
     @inject(GLSP_TYPES.IFeedbackActionDispatcher) protected feedbackActionDispatcher: IFeedbackActionDispatcher;
 
     @inject(TYPES.IActionDispatcherProvider) protected actionDispatcher: () => Promise<IActionDispatcher>;
@@ -51,7 +50,7 @@ export class ValidationFeedbackEmitter implements IFeedbackEmitter {
     private registeredAction: MarkersAction;
 
     // eslint-disable-next-line @typescript-eslint/no-empty-function
-    private constructor() { }
+    private constructor() {}
 
     /**
      * Register the action that should be emitted for visualizing validation feedback.
@@ -77,11 +76,11 @@ export class ValidationFeedbackEmitter implements IFeedbackEmitter {
  * Action to set markers for a model
  */
 export class SetMarkersAction implements MarkersAction {
-    constructor(public readonly markers: Marker[], public readonly kind = SetMarkersCommand.KIND) { }
+    constructor(public readonly markers: Marker[], public readonly kind = SetMarkersCommand.KIND) {}
 }
 
 export function isSetMarkersAction(action: Action): action is SetMarkersAction {
-    return SetMarkersCommand.KIND === action.kind && ('markers' in action);
+    return SetMarkersCommand.KIND === action.kind && 'markers' in action;
 }
 
 /**
@@ -92,7 +91,6 @@ export function isSetMarkersAction(action: Action): action is SetMarkersAction {
  */
 @injectable()
 export abstract class ExternalMarkerManager {
-
     languageLabel: string;
 
     protected actionDispatcher?: IActionDispatcher;
@@ -115,7 +113,6 @@ export abstract class ExternalMarkerManager {
  */
 @injectable()
 export class SetMarkersCommand extends Command {
-
     @inject(ValidationFeedbackEmitter) protected validationFeedbackEmitter: ValidationFeedbackEmitter;
     @inject(ExternalMarkerManager) @optional() protected externalMarkerManager?: ExternalMarkerManager;
     @inject(EditorContextService) protected editorContextService: EditorContextService;
@@ -147,11 +144,11 @@ export class SetMarkersCommand extends Command {
 }
 
 /**
-* Action to retrieve markers for a model
-*/
+ * Action to retrieve markers for a model
+ */
 export class RequestMarkersAction implements Action {
     static readonly KIND = 'requestMarkers';
-    constructor(public readonly elementsIDs: string[] = [], public readonly kind = RequestMarkersAction.KIND) { }
+    constructor(public readonly elementsIDs: string[] = [], public readonly kind = RequestMarkersAction.KIND) {}
 }
 
 /**
@@ -166,7 +163,7 @@ export interface MarkersAction extends Action {
  */
 @injectable()
 export class ApplyMarkersAction implements MarkersAction {
-    constructor(public readonly markers: Marker[], public readonly kind = ApplyMarkersCommand.KIND) { }
+    constructor(public readonly markers: Marker[], public readonly kind = ApplyMarkersCommand.KIND) {}
 }
 
 /**
@@ -224,7 +221,7 @@ function removeCSSClassFromIssueParent(modelElement: SParentElement, issueMarker
  */
 @injectable()
 export class DeleteMarkersAction implements MarkersAction {
-    constructor(public readonly markers: Marker[], public readonly kind = DeleteMarkersCommand.KIND) { }
+    constructor(public readonly markers: Marker[], public readonly kind = DeleteMarkersCommand.KIND) {}
 }
 
 /**
@@ -271,4 +268,3 @@ export class DeleteMarkersCommand extends Command {
         return this.execute(context);
     }
 }
-

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

@@ -14,21 +14,12 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 import { injectable } from 'inversify';
-import {
-    Action,
-    EnableDefaultToolsAction,
-    EnableToolsAction,
-    IActionHandler,
-    ICommand,
-    ScrollMouseListener,
-    SModelElement
-} from 'sprotty';
+import { Action, EnableDefaultToolsAction, EnableToolsAction, IActionHandler, ICommand, ScrollMouseListener, SModelElement } from 'sprotty';
 
 import { MarqueeMouseTool } from '../tools/marquee-mouse-tool';
 
 @injectable()
 export class GLSPScrollMouseListener extends ScrollMouseListener implements IActionHandler {
-
     preventScrolling = false;
 
     handle(action: Action): void | Action | ICommand {

package/src/index.ts

@@ -108,8 +108,25 @@ export * from './utils/smodel-util';
 export * from './utils/viewpoint-util';
 export * from './views';
 export {
-    validationModule, saveModule, paletteModule, toolFeedbackModule, defaultGLSPModule, modelHintsModule, glspCommandPaletteModule,
-    glspContextMenuModule, glspServerCopyPasteModule, copyPasteContextMenuModule, glspSelectModule, glspMouseToolModule, layoutCommandsModule, glspEditLabelModule,
-    glspHoverModule, toolsModule, navigationModule, markerNavigatorModule, glspDecorationModule, modelSourceWatcherModule, glspViewportModule
+    validationModule,
+    saveModule,
+    paletteModule,
+    toolFeedbackModule,
+    defaultGLSPModule,
+    modelHintsModule,
+    glspCommandPaletteModule,
+    glspContextMenuModule,
+    glspServerCopyPasteModule,
+    copyPasteContextMenuModule,
+    glspSelectModule,
+    glspMouseToolModule,
+    layoutCommandsModule,
+    glspEditLabelModule,
+    glspHoverModule,
+    toolsModule,
+    navigationModule,
+    markerNavigatorModule,
+    glspDecorationModule,
+    modelSourceWatcherModule,
+    glspViewportModule
 };
-

package/src/utils/argument-utils.ts

@@ -18,7 +18,7 @@ import { SModelElement } from 'sprotty';
 import { hasArguments } from '../base/args';
 
 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 +26,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 +34,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 +112,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/array-utils.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
@@ -31,7 +31,9 @@ export function distinctAdd<T>(array: T[], value: T): boolean {
     return false;
 }
 
-interface Constructor<T> { new(...args: any[]): T }
+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[] {

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
@@ -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;
     }