@eclipse-glsp/client 0.9.0-next.f54fd689 → 0.9.0

package/src/features/tool-feedback/di.config.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,25 +13,23 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { ContainerModule } from "inversify";
-import { configureCommand, configureView, LocationPostprocessor, MoveCommand, TYPES } from "sprotty";
+import { ContainerModule } from 'inversify';
+import { configureCommand, configureView, LocationPostprocessor, MoveCommand, TYPES } from 'sprotty';
 
-import { GLSP_TYPES } from "../../base/types";
-import { SResizeHandle } from "../change-bounds/model";
-import {
-    HideChangeBoundsToolResizeFeedbackCommand,
-    ShowChangeBoundsToolResizeFeedbackCommand
-} from "./change-bounds-tool-feedback";
-import { DrawFeedbackEdgeCommand, FeedbackEdgeEnd, RemoveFeedbackEdgeCommand } from "./creation-tool-feedback";
-import { ModifyCssFeedbackCommand } from "./css-feedback";
+import { GLSP_TYPES } from '../../base/types';
+import { SResizeHandle } from '../change-bounds/model';
+import { HideChangeBoundsToolResizeFeedbackCommand, ShowChangeBoundsToolResizeFeedbackCommand } from './change-bounds-tool-feedback';
+import { DrawFeedbackEdgeCommand, FeedbackEdgeEnd, RemoveFeedbackEdgeCommand } from './creation-tool-feedback';
+import { ModifyCssFeedbackCommand } from './css-feedback';
 import {
     DrawFeedbackEdgeSourceCommand,
     HideEdgeReconnectHandlesFeedbackCommand,
     ShowEdgeReconnectHandlesFeedbackCommand,
     SwitchRoutingModeCommand
-} from "./edge-edit-tool-feedback";
-import { FeedbackActionDispatcher } from "./feedback-action-dispatcher";
-import { FeedbackEdgeEndView, SResizeHandleView } from "./view";
+} from './edge-edit-tool-feedback';
+import { FeedbackActionDispatcher } from './feedback-action-dispatcher';
+import { DrawMarqueeCommand, RemoveMarqueeCommand } from './marquee-tool-feedback';
+import { FeedbackEdgeEndView, SResizeHandleView } from './view';
 
 const toolFeedbackModule = new ContainerModule((bind, _unbind, isBound) => {
     bind(GLSP_TYPES.IFeedbackActionDispatcher).to(FeedbackActionDispatcher).inSingletonScope();
@@ -42,6 +40,9 @@ const toolFeedbackModule = new ContainerModule((bind, _unbind, isBound) => {
     configureCommand({ bind, isBound }, DrawFeedbackEdgeCommand);
     configureCommand({ bind, isBound }, RemoveFeedbackEdgeCommand);
 
+    configureCommand({ bind, isBound }, DrawMarqueeCommand);
+    configureCommand({ bind, isBound }, RemoveMarqueeCommand);
+
     configureView({ bind, isBound }, FeedbackEdgeEnd.TYPE, FeedbackEdgeEndView);
     // move tool feedback: we use sprotties MoveCommand as client-side visual feedback
     configureCommand({ bind, isBound }, MoveCommand);

package/src/features/tool-feedback/edge-edit-tool-feedback.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,10 +13,11 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { inject, injectable } from "inversify";
-import { VNode } from "snabbdom/vnode";
+import { Action, Point } from '@eclipse-glsp/protocol';
+import { inject, injectable } from 'inversify';
+import { VNode } from 'snabbdom';
 import {
-    Action,
+    add,
     AnchorComputerRegistry,
     center,
     CommandExecutionContext,
@@ -32,7 +33,6 @@ import {
     isViewport,
     MouseListener,
     MoveAction,
-    Point,
     PolylineEdgeRouter,
     SConnectableElement,
     SModelElement,
@@ -41,29 +41,23 @@ import {
     SwitchEditModeAction,
     SwitchEditModeCommand,
     TYPES
-} from "sprotty";
-
-import { isNotUndefined, isRoutable, isRoutingHandle } from "../../utils/smodel-util";
-import { getAbsolutePosition } from "../../utils/viewpoint-util";
-import { addReconnectHandles, removeReconnectHandles } from "../reconnect/model";
-import {
-    FeedbackEdgeEnd,
-    feedbackEdgeEndId,
-    FeedbackEdgeEndMovingMouseListener,
-    feedbackEdgeId
-} from "./creation-tool-feedback";
-import { FeedbackCommand } from "./model";
+} from 'sprotty';
+import { isNotUndefined, isRoutable, isRoutingHandle } from '../../utils/smodel-util';
+import { getAbsolutePosition, toAbsoluteBounds } from '../../utils/viewpoint-util';
+import { addReconnectHandles, removeReconnectHandles } from '../reconnect/model';
+import { FeedbackEdgeEnd, feedbackEdgeEndId, FeedbackEdgeEndMovingMouseListener, feedbackEdgeId } from './creation-tool-feedback';
+import { FeedbackCommand } from './model';
 
 /**
  * RECONNECT HANDLES FEEDBACK
  */
 
 export class ShowEdgeReconnectHandlesFeedbackAction implements Action {
-    constructor(readonly elementId?: string, public readonly kind: string = ShowEdgeReconnectHandlesFeedbackCommand.KIND) { }
+    constructor(readonly elementId?: string, public readonly kind: string = ShowEdgeReconnectHandlesFeedbackCommand.KIND) {}
 }
 
 export class HideEdgeReconnectHandlesFeedbackAction implements Action {
-    constructor(public readonly kind: string = HideEdgeReconnectHandlesFeedbackCommand.KIND) { }
+    constructor(public readonly kind: string = HideEdgeReconnectHandlesFeedbackCommand.KIND) {}
 }
 
 @injectable()
@@ -107,17 +101,21 @@ export class HideEdgeReconnectHandlesFeedbackCommand extends FeedbackCommand {
  */
 
 export class SwitchRoutingModeAction extends SwitchEditModeAction {
-    constructor(public readonly elementsToActivate: string[] = [],
+    constructor(
+        public readonly elementsToActivate: string[] = [],
         public readonly elementsToDeactivate: string[] = [],
-        public readonly kind: string = SwitchRoutingModeCommand.KIND) {
+        public readonly kind: string = SwitchRoutingModeCommand.KIND
+    ) {
         super(elementsToActivate, elementsToDeactivate);
     }
 }
 
 @injectable()
 export class SwitchRoutingModeCommand extends SwitchEditModeCommand {
-    static KIND = "switchRoutingMode";
-    constructor(@inject(TYPES.Action) action: SwitchRoutingModeAction) { super(action); }
+    static KIND = 'switchRoutingMode';
+    constructor(@inject(TYPES.Action) action: SwitchRoutingModeAction) {
+        super(action);
+    }
 }
 
 /**
@@ -125,7 +123,11 @@ export class SwitchRoutingModeCommand extends SwitchEditModeCommand {
  */
 
 export class DrawFeedbackEdgeSourceAction implements Action {
-    constructor(readonly elementTypeId: string, readonly targetId: string, public readonly kind: string = DrawFeedbackEdgeSourceCommand.KIND) { }
+    constructor(
+        readonly elementTypeId: string,
+        readonly targetId: string,
+        public readonly kind: string = DrawFeedbackEdgeSourceCommand.KIND
+    ) {}
 }
 
 @injectable()
@@ -166,12 +168,12 @@ export class FeedbackEdgeSourceMovingMouseListener extends MouseListener {
 
         const edge = edgeEnd.feedbackEdge;
         const position = getAbsolutePosition(edgeEnd, event);
-        const endAtMousePosition = findChildrenAtPosition(target.root, position)
-            .find(e => isConnectable(e) && e.canConnect(edge, 'source'));
+        const endAtMousePosition = findChildrenAtPosition(target.root, position).find(
+            e => isConnectable(e) && e.canConnect(edge, 'source')
+        );
 
         if (endAtMousePosition instanceof SConnectableElement && edge.target && isBoundsAware(edge.target)) {
-            const anchorComputer = this.anchorRegistry.get(PolylineEdgeRouter.KIND, endAtMousePosition.anchorKind);
-            const anchor = anchorComputer.getAnchor(endAtMousePosition, center(edge.target.bounds));
+            const anchor = this.computeAbsoluteAnchor(endAtMousePosition, center(edge.target.bounds));
             if (euclideanDistance(anchor, edgeEnd.position) > 1) {
                 return [new MoveAction([{ elementId: edgeEnd.id, toPosition: anchor }], false)];
             }
@@ -181,6 +183,21 @@ export class FeedbackEdgeSourceMovingMouseListener extends MouseListener {
 
         return [];
     }
+
+    protected computeAbsoluteAnchor(element: SConnectableElement, referencePoint: Point, offset?: number): Point {
+        const anchorComputer = this.anchorRegistry.get(PolylineEdgeRouter.KIND, element.anchorKind);
+        let anchor = anchorComputer.getAnchor(element, referencePoint, offset);
+        // The anchor is computed in the local coordinate system of the element.
+        // If the element is a nested child element we have to add the absolute position of its parent to the anchor.
+        if (element.parent !== element.root) {
+            const parent = findParentByFeature(element.parent, isBoundsAware);
+            if (parent) {
+                const absoluteParentPosition = toAbsoluteBounds(parent);
+                anchor = add(absoluteParentPosition, anchor);
+            }
+        }
+        return anchor;
+    }
 }
 
 export class FeedbackEdgeRouteMovingMouseListener extends MouseListener {
@@ -208,16 +225,17 @@ export class FeedbackEdgeRouteMovingMouseListener extends MouseListener {
 
     mouseMove(target: SModelElement, event: MouseEvent): Action[] {
         const result: Action[] = [];
-        if (event.buttons === 0)
+        if (event.buttons === 0) {
             this.mouseUp(target, event);
-        else if (this.lastDragPosition) {
+        } else if (this.lastDragPosition) {
             const viewport = findParentByFeature(target, isViewport);
             this.hasDragged = true;
             const zoom = viewport ? viewport.zoom : 1;
             const dx = (event.pageX - this.lastDragPosition.x) / zoom;
             const dy = (event.pageY - this.lastDragPosition.y) / zoom;
             const handleMoves: ElementMove[] = [];
-            target.root.index.all()
+            target.root.index
+                .all()
                 .filter(element => isSelected(element))
                 .forEach(element => {
                     if (isRoutingHandle(element)) {
@@ -235,8 +253,9 @@ export class FeedbackEdgeRouteMovingMouseListener extends MouseListener {
                     }
                 });
             this.lastDragPosition = { x: event.pageX, y: event.pageY };
-            if (handleMoves.length > 0)
+            if (handleMoves.length > 0) {
                 result.push(new MoveAction(handleMoves, false));
+            }
         }
         return result;
     }
@@ -244,8 +263,9 @@ export class FeedbackEdgeRouteMovingMouseListener extends MouseListener {
     protected getHandlePosition(handle: SRoutingHandle): Point | undefined {
         if (this.edgeRouterRegistry) {
             const parent = handle.parent;
-            if (!isRoutable(parent))
+            if (!isRoutable(parent)) {
                 return undefined;
+            }
             const router = this.edgeRouterRegistry.get(parent.routerKind);
             const route = router.route(parent);
             return router.getHandlePosition(parent, route, handle);
@@ -254,8 +274,9 @@ export class FeedbackEdgeRouteMovingMouseListener extends MouseListener {
     }
 
     mouseEnter(target: SModelElement, event: MouseEvent): Action[] {
-        if (target instanceof SModelRoot && event.buttons === 0)
+        if (target instanceof SModelRoot && event.buttons === 0) {
             this.mouseUp(target, event);
+        }
         return [];
     }
 
@@ -274,7 +295,7 @@ export class FeedbackEdgeRouteMovingMouseListener extends MouseListener {
  * UTILITY FUNCTIONS
  */
 
-function drawFeedbackEdgeSource(context: CommandExecutionContext, targetId: string, elementTypeId: string) {
+function drawFeedbackEdgeSource(context: CommandExecutionContext, targetId: string, elementTypeId: string): void {
     const root = context.root;
     const targetChild = root.index.getById(targetId);
     if (!targetChild) {

package/src/features/tool-feedback/feedback-action-dispatcher.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,10 +13,11 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { inject, injectable } from "inversify";
-import { Action, IActionDispatcher, ILogger, TYPES } from "sprotty";
+import { Action } from '@eclipse-glsp/protocol';
+import { inject, injectable } from 'inversify';
+import { IActionDispatcher, ILogger, TYPES } from 'sprotty';
 
-export interface IFeedbackEmitter { }
+export interface IFeedbackEmitter {}
 
 /**
  * Dispatcher for actions that are meant to show visual feedback on
@@ -52,14 +53,14 @@ export interface IFeedbackActionDispatcher {
     deregisterFeedback(feedbackEmitter: IFeedbackEmitter, actions: Action[]): void;
 
     /**
-    * Retrieve all `actions` sent out by currently registered `feedbackEmitter`.
-    */
-    getRegisteredFeedback(): Action[]
+     * Retrieve all `actions` sent out by currently registered `feedbackEmitter`.
+     */
+    getRegisteredFeedback(): Action[];
 }
 
 @injectable()
 export class FeedbackActionDispatcher implements IFeedbackActionDispatcher {
-    protected feedbackEmitters: Map<IFeedbackEmitter, Action[]> = new Map;
+    protected feedbackEmitters: Map<IFeedbackEmitter, Action[]> = new Map();
 
     @inject(TYPES.IActionDispatcherProvider) protected actionDispatcher: () => Promise<IActionDispatcher>;
     @inject(TYPES.ILogger) protected logger: ILogger;
@@ -74,28 +75,26 @@ export class FeedbackActionDispatcher implements IFeedbackActionDispatcher {
         this.dispatch(actions, feedbackEmitter);
     }
 
-    private dispatch(actions: Action[], feedbackEmitter: IFeedbackEmitter) {
+    private dispatch(actions: Action[], feedbackEmitter: IFeedbackEmitter): void {
         this.actionDispatcher()
             .then(dispatcher => dispatcher.dispatchAll(actions))
             .then(() => this.logger.info(this, `Dispatched feedback actions for ${feedbackEmitter}`))
             .catch(reason => this.logger.error(this, 'Failed to dispatch feedback actions', reason));
     }
 
-    getRegisteredFeedback() {
+    getRegisteredFeedback(): Action[] {
         const result: Action[] = [];
         this.feedbackEmitters.forEach((value, key) => result.push(...value));
         return result;
     }
 
-    getRegisteredFeedbackEmitters(action: Action) {
+    getRegisteredFeedbackEmitters(action: Action): IFeedbackEmitter[] {
         const result: IFeedbackEmitter[] = [];
         this.feedbackEmitters.forEach((value, key) => {
             if (value.find(a => a === action)) {
                 result.push(key);
             }
-        }
-        );
+        });
         return result;
     }
-
 }

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

@@ -0,0 +1,103 @@
+/********************************************************************************
+ * 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 { Action, Point } from '@eclipse-glsp/protocol';
+import { inject, injectable } from 'inversify';
+import {
+    AnchorComputerRegistry,
+    CommandExecutionContext,
+    CommandReturn,
+    MouseListener,
+    SChildElement,
+    SModelElement,
+    SModelRoot,
+    TYPES
+} from 'sprotty';
+import { FeedbackCommand } from './model';
+
+export class DrawMarqueeAction implements Action {
+    constructor(
+        public readonly startPoint: Point,
+        public readonly endPoint: Point,
+        public readonly kind: string = DrawMarqueeCommand.KIND
+    ) {}
+}
+
+@injectable()
+export class DrawMarqueeCommand extends FeedbackCommand {
+    static readonly KIND = 'drawMarquee';
+
+    constructor(@inject(TYPES.Action) protected action: DrawMarqueeAction) {
+        super();
+    }
+
+    execute(context: CommandExecutionContext): CommandReturn {
+        drawMarquee(context, this.action.startPoint, this.action.endPoint);
+        return context.root;
+    }
+}
+
+export class RemoveMarqueeAction implements Action {
+    constructor(public readonly kind: string = RemoveMarqueeCommand.KIND) {}
+}
+
+@injectable()
+export class RemoveMarqueeCommand extends FeedbackCommand {
+    static readonly KIND = 'removeMarqueeCommand';
+
+    execute(context: CommandExecutionContext): CommandReturn {
+        removeMarquee(context.root);
+        return context.root;
+    }
+}
+
+export class MarqueeEndMovingMouseListener extends MouseListener {
+    constructor(protected anchorRegistry: AnchorComputerRegistry) {
+        super();
+    }
+
+    mouseMove(target: SModelElement, event: MouseEvent): Action[] {
+        return [];
+    }
+}
+
+export function marqueeId(root: SModelRoot): string {
+    return root.id + '_' + MARQUEE;
+}
+
+export const MARQUEE = 'marquee';
+
+export function drawMarquee(context: CommandExecutionContext, startPoint: Point, endPoint: Point): void {
+    const root = context.root;
+
+    removeMarquee(root);
+
+    const marqueeSchema = {
+        type: MARQUEE,
+        id: marqueeId(root),
+        startPoint: startPoint,
+        endPoint: endPoint
+    };
+
+    const marquee = context.modelFactory.createElement(marqueeSchema);
+    root.add(marquee);
+}
+
+export function removeMarquee(root: SModelRoot): void {
+    const marquee = root.index.getById(marqueeId(root));
+    if (marquee instanceof SChildElement) {
+        root.remove(marquee);
+    }
+}

package/src/features/tool-feedback/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
@@ -13,7 +13,7 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { Command, CommandExecutionContext, CommandReturn } from "sprotty";
+import { Command, CommandExecutionContext, CommandReturn } from 'sprotty';
 
 export abstract class FeedbackCommand extends Command {
     // used by the `FeedbackAwareUpdateModelCommand`
@@ -29,4 +29,3 @@ export abstract class FeedbackCommand extends Command {
         return context.root;
     }
 }
-

package/src/features/tool-feedback/view.tsx

@@ -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,19 +13,19 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { injectable } from "inversify";
-import * as snabbdom from "snabbdom-jsx";
-import { VNode } from "snabbdom/vnode";
-import { IView, ORIGIN_POINT, Point, RenderingContext, setAttr, SModelElement } from "sprotty";
+import { Point } from '@eclipse-glsp/protocol';
+import { injectable } from 'inversify';
+import { VNode } from 'snabbdom';
+import { IView, ORIGIN_POINT, RenderingContext, setAttr, SModelElement, svg } from 'sprotty';
+import { isResizable, ResizeHandleLocation, SResizeHandle } from '../change-bounds/model';
 
-import { isResizable, ResizeHandleLocation, SResizeHandle } from "../change-bounds/model";
-
-const JSX = { createElement: snabbdom.svg };
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const JSX = { createElement: svg };
 
 /**
-* This view is used for the invisible end of the feedback edge.
-* A feedback edge is shown as a visual feedback when creating edges.
-*/
+ * This view is used for the invisible end of the feedback edge.
+ * A feedback edge is shown as a visual feedback when creating edges.
+ */
 @injectable()
 export class FeedbackEdgeEndView implements IView {
     render(model: Readonly<SModelElement>, context: RenderingContext): VNode {
@@ -39,8 +39,15 @@ export class SResizeHandleView implements IView {
     render(handle: SResizeHandle, context: RenderingContext): VNode {
         const position = this.getPosition(handle);
         if (position !== undefined) {
-            const node = <circle class-sprotty-resize-handle={true} class-mouseover={handle.hoverFeedback}
-                cx={position.x} cy={position.y} r={this.getRadius()} />;
+            const node = (
+                <circle
+                    class-sprotty-resize-handle={true}
+                    class-mouseover={handle.hoverFeedback}
+                    cx={position.x}
+                    cy={position.y}
+                    r={this.getRadius()}
+                />
+            );
             setAttr(node, 'data-kind', handle.location);
             return node;
         }

package/src/features/tool-palette/di.config.ts

@@ -13,14 +13,12 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import "../../../css/tool-palette.css";
+import { ContainerModule } from 'inversify';
+import { configureActionHandler, EnableDefaultToolsAction, TYPES } from 'sprotty';
+import '../../../css/tool-palette.css';
+import { EnableToolPaletteAction, ToolPalette } from './tool-palette';
 
-import { ContainerModule } from "inversify";
-import { configureActionHandler, EnableDefaultToolsAction, TYPES } from "sprotty";
-
-import { EnableToolPaletteAction, ToolPalette } from "./tool-palette";
-
-const toolPaletteModule = new ContainerModule((bind, _unbind, isBound) => {
+const toolPaletteModule = new ContainerModule((bind, _unbind, isBound, rebind) => {
     bind(ToolPalette).toSelf().inSingletonScope();
     bind(TYPES.IUIExtension).toService(ToolPalette);
     configureActionHandler({ bind, isBound }, EnableToolPaletteAction.KIND, ToolPalette);

package/src/features/tool-palette/palette-item.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,9 +13,7 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { isLabeledAction, LabeledAction } from "sprotty";
-
-import { isTriggerElementTypeCreationAction, TriggerElementCreationAction } from "../../base/operations/operation";
+import { isLabeledAction, isTriggerElementTypeCreationAction, LabeledAction, TriggerElementCreationAction } from '@eclipse-glsp/protocol';
 
 export interface PaletteItem extends LabeledAction {
     readonly id: string;
@@ -24,17 +22,17 @@ export interface PaletteItem extends LabeledAction {
 }
 
 export function isPaletteItem(object?: any): object is PaletteItem {
-    return isLabeledAction(object) && "id" in object && "sortString" in object;
+    return isLabeledAction(object) && 'id' in object && 'sortString' in object;
 }
 
 export namespace PaletteItem {
     export function getTriggerAction(item?: PaletteItem): TriggerElementCreationAction | undefined {
         if (item) {
-            const initiAction = item.actions.filter(a => isTriggerElementTypeCreationAction(a))
+            const initiAction = item.actions
+                .filter(a => isTriggerElementTypeCreationAction(a))
                 .map(action => action as TriggerElementCreationAction);
             return initiAction.length > 0 ? initiAction[0] : undefined;
         }
         return undefined;
     }
 }
-