@eclipse-glsp/client 0.9.0-next.d2f88f00 → 0.9.0-next.d3c64530

package/src/features/layout/vbox-layout.ts

@@ -0,0 +1,256 @@
+/********************************************************************************
+ * 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 { injectable } from 'inversify';
+import {
+    Bounds,
+    BoundsData,
+    Dimension,
+    EMPTY_BOUNDS,
+    isBoundsAware,
+    isLayoutableChild,
+    isValidDimension,
+    LayoutContainer,
+    Point,
+    SChildElement,
+    SModelElement,
+    SParentElement,
+    StatefulLayouter,
+    VBoxLayouter,
+    VBoxLayoutOptions
+} from 'sprotty';
+
+export interface VBoxLayoutOptionsExt extends VBoxLayoutOptions {
+    hGrab: boolean;
+    vGrab: boolean;
+    prefWidth: number | null;
+    prefHeight: number | null;
+}
+
+/**
+ * Extends VBoxLayouter to support additional layout options
+ */
+@injectable()
+export class VBoxLayouterExt extends VBoxLayouter {
+    static KIND = VBoxLayouter.KIND;
+
+    layout(container: SParentElement & LayoutContainer, layouter: StatefulLayouter): void {
+        const boundsData = layouter.getBoundsData(container);
+        const options = this.getLayoutOptions(container);
+        const childrenSize = this.getChildrenSize(container, options, layouter);
+
+        const fixedSize = this.getFixedContainerBounds(container, options, layouter);
+
+        const maxWidth =
+            options.paddingFactor *
+            (options.resizeContainer
+                ? Math.max(fixedSize.width - options.paddingLeft - options.paddingRight, childrenSize.width)
+                : Math.max(0, fixedSize.width - options.paddingLeft - options.paddingRight));
+        const maxHeight =
+            options.paddingFactor *
+            (options.resizeContainer
+                ? Math.max(fixedSize.height - options.paddingTop - options.paddingBottom, childrenSize.height)
+                : Math.max(0, fixedSize.height - options.paddingTop - options.paddingBottom));
+
+        // Remaining size that can be grabbed by children with the vGrab option
+        const grabHeight: number = maxHeight - childrenSize.height;
+        // Number of children that request vGrab
+        // FIXME: This approach works fine when only 1 child uses VGrab, but may cause rounding issues
+        // when the grabHeight can't be equally shared by all children.
+        const grabbingChildren = container.children
+            .map(child => this.getChildLayoutOptions(child, options))
+            .filter(opt => opt.vGrab).length;
+
+        if (maxWidth > 0 && maxHeight > 0) {
+            const offset = this.layoutChildren(container, layouter, options, maxWidth, maxHeight, grabHeight, grabbingChildren);
+            boundsData.bounds = this.getFinalContainerBounds(container, offset, options, childrenSize.width, childrenSize.height);
+            boundsData.boundsChanged = true;
+        }
+    }
+
+    protected getChildrenSize(
+        container: SParentElement & LayoutContainer,
+        containerOptions: VBoxLayoutOptionsExt,
+        layouter: StatefulLayouter
+    ): Dimension {
+        let maxWidth = -1;
+        let maxHeight = 0;
+        let isFirst = true;
+        container.children.forEach(child => {
+            if (isLayoutableChild(child)) {
+                const bounds = layouter.getBoundsData(child).bounds;
+                if (bounds !== undefined && isValidDimension(bounds)) {
+                    maxHeight += bounds.height;
+                    if (isFirst) {
+                        isFirst = false;
+                    } else {
+                        maxHeight += containerOptions.vGap;
+                    }
+                    maxWidth = Math.max(maxWidth, bounds.width);
+                }
+            }
+        });
+        const result = {
+            width: maxWidth,
+            height: maxHeight
+        };
+        return result;
+    }
+
+    protected layoutChildren(
+        container: SParentElement & LayoutContainer,
+        layouter: StatefulLayouter,
+        containerOptions: VBoxLayoutOptionsExt,
+        maxWidth: number,
+        maxHeight: number,
+        grabHeight?: number,
+        grabbingChildren?: number
+    ): Point {
+        let currentOffset: Point = {
+            x: containerOptions.paddingLeft + 0.5 * (maxWidth - maxWidth / containerOptions.paddingFactor),
+            y: containerOptions.paddingTop + 0.5 * (maxHeight - maxHeight / containerOptions.paddingFactor)
+        };
+
+        container.children.forEach(child => {
+            if (isLayoutableChild(child)) {
+                const boundsData = layouter.getBoundsData(child);
+                const bounds = boundsData.bounds;
+                const childOptions = this.getChildLayoutOptions(child, containerOptions);
+                if (bounds !== undefined && isValidDimension(bounds)) {
+                    currentOffset = this.layoutChild(
+                        child,
+                        boundsData,
+                        bounds,
+                        childOptions,
+                        containerOptions,
+                        currentOffset,
+                        maxWidth,
+                        maxHeight,
+                        grabHeight,
+                        grabbingChildren
+                    );
+                }
+            }
+        });
+        return currentOffset;
+    }
+
+    protected layoutChild(
+        child: SChildElement,
+        boundsData: BoundsData,
+        bounds: Bounds,
+        childOptions: VBoxLayoutOptionsExt,
+        containerOptions: VBoxLayoutOptionsExt,
+        currentOffset: Point,
+        maxWidth: number,
+        maxHeight: number,
+        grabHeight?: number,
+        grabbingChildren?: number
+    ): Point {
+        let offset = super.layoutChild(child, boundsData, bounds, childOptions, containerOptions, currentOffset, maxWidth, maxHeight);
+        if (childOptions.hGrab) {
+            boundsData.bounds = {
+                x: boundsData.bounds!.x,
+                y: boundsData.bounds!.y,
+                width: maxWidth,
+                height: boundsData.bounds!.height
+            };
+            boundsData.boundsChanged = true;
+        }
+        if (childOptions.vGrab && grabHeight && grabbingChildren) {
+            const height = boundsData.bounds!.height + grabHeight / grabbingChildren;
+            boundsData.bounds = {
+                x: boundsData.bounds!.x,
+                y: boundsData.bounds!.y,
+                width: boundsData.bounds!.width,
+                height: height
+            };
+            boundsData.boundsChanged = true;
+            offset = { x: currentOffset.x, y: currentOffset.y + height };
+        }
+        return offset;
+    }
+
+    protected getFixedContainerBounds(container: SModelElement, layoutOptions: VBoxLayoutOptionsExt, layouter: StatefulLayouter): Bounds {
+        const currentContainer = container;
+        // eslint-disable-next-line no-constant-condition
+        if (isBoundsAware(currentContainer)) {
+            const bounds = currentContainer.bounds;
+            const elementOptions = this.getElementLayoutOptions(currentContainer);
+            const width = elementOptions?.prefWidth ?? 0;
+            const height = elementOptions?.prefHeight ?? 0;
+            return { ...bounds, width, height };
+        }
+        return EMPTY_BOUNDS;
+    }
+
+    protected getChildLayoutOptions(child: SChildElement, containerOptions: VBoxLayoutOptionsExt): VBoxLayoutOptionsExt {
+        return super.getChildLayoutOptions(child, containerOptions) as VBoxLayoutOptionsExt;
+    }
+
+    protected getLayoutOptions(element: SModelElement): VBoxLayoutOptionsExt {
+        return super.getLayoutOptions(element) as VBoxLayoutOptionsExt;
+    }
+
+    protected getElementLayoutOptions(element: SModelElement): VBoxLayoutOptionsExt | undefined {
+        return (element as any).layoutOptions;
+    }
+
+    protected getFinalContainerBounds(
+        container: SParentElement & LayoutContainer,
+        lastOffset: Point,
+        options: VBoxLayoutOptionsExt,
+        maxWidth: number,
+        maxHeight: number
+    ): Bounds {
+        const elementOptions = this.getElementLayoutOptions(container);
+        const width = elementOptions?.prefWidth ?? options.minWidth;
+        const height = elementOptions?.prefHeight ?? options.minHeight;
+
+        const result = {
+            x: container.bounds.x,
+            y: container.bounds.y,
+            width: Math.max(width, maxWidth + options.paddingLeft + options.paddingRight),
+            height: Math.max(height, maxHeight + options.paddingTop + options.paddingBottom)
+        };
+
+        return result;
+    }
+
+    protected getDefaultLayoutOptions(): VBoxLayoutOptionsExt {
+        return {
+            resizeContainer: true,
+            paddingTop: 5,
+            paddingBottom: 5,
+            paddingLeft: 5,
+            paddingRight: 5,
+            paddingFactor: 1,
+            vGap: 1,
+            hAlign: 'center',
+            minWidth: 0,
+            minHeight: 0,
+            hGrab: false,
+            vGrab: false,
+            // eslint-disable-next-line no-null/no-null
+            prefHeight: null,
+            // eslint-disable-next-line no-null/no-null
+            prefWidth: null
+        };
+    }
+
+    protected spread(a: VBoxLayoutOptionsExt, b: VBoxLayoutOptionsExt): VBoxLayoutOptionsExt {
+        return { ...a, ...b };
+    }
+}

package/src/features/model-source-watcher/di.config.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,10 +13,9 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
+import { ModelSourceChangedAction } from '@eclipse-glsp/protocol';
 import { ContainerModule } from 'inversify';
-import { configureActionHandler } from 'sprotty/lib';
-
-import { ModelSourceChangedAction } from './model-source-changed-action';
+import { configureActionHandler } from 'sprotty';
 import { ModelSourceChangedActionHandler } from './model-source-changed-action-handler';
 
 const modelSourceWatcherModule = new ContainerModule((bind, _unbind, isBound) => {

package/src/features/model-source-watcher/model-source-changed-action-handler.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,11 +13,15 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
+import {
+    Action,
+    GLSPServerStatusAction,
+    isModelSourceChangedAction,
+    ModelSourceChangedAction,
+    ServerMessageAction
+} from '@eclipse-glsp/protocol';
 import { inject, injectable, optional } from 'inversify';
-import { Action, IActionDispatcher, IActionHandler, TYPES, ViewerOptions } from 'sprotty/lib';
-
-import { GLSPServerStatusAction, ServerMessageAction } from '../../model-source/glsp-server-status';
-import { isModelSourceChangedAction, ModelSourceChangedAction } from './model-source-changed-action';
+import { IActionDispatcher, IActionHandler, TYPES, ViewerOptions } from 'sprotty';
 
 /**
  * An external handler of the model source change event.
@@ -36,14 +40,14 @@ export abstract class ExternalModelSourceChangedHandler {
 
 @injectable()
 export class ModelSourceChangedActionHandler implements IActionHandler {
-
     @inject(TYPES.IActionDispatcher)
     protected dispatcher: IActionDispatcher;
 
     @inject(TYPES.ViewerOptions)
     protected options: ViewerOptions;
 
-    @inject(ExternalModelSourceChangedHandler) @optional()
+    @inject(ExternalModelSourceChangedHandler)
+    @optional()
     protected externalModelSourceChangedHandler?: ExternalModelSourceChangedHandler;
 
     handle(action: Action): void {

package/src/features/mouse-tool/mouse-tool.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,10 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
+import { Action, isAction } from '@eclipse-glsp/protocol';
 import { injectable, multiInject, optional } from 'inversify';
-import { VNode, VNodeData } from 'snabbdom/vnode';
-import { Action, isAction, MouseListener, MouseTool, SModelElement, SModelRoot, TYPES } from 'sprotty';
-
+import { On, VNode, VNodeData } from 'snabbdom';
+import { MouseListener, MouseTool, SModelElement, SModelRoot, TYPES } from 'sprotty';
 import { getRank } from '../rank/model';
 
 export interface IMouseTool {
@@ -46,25 +46,25 @@ export class RankingMouseTool extends MouseTool implements IMouseTool {
     decorate(vnode: VNode, element: SModelElement): VNode {
         // we need to overwrite the existing event handlers registered by the original mouse tool
         if (element instanceof SModelRoot) {
-            overwriteOn(vnode, 'mouseover', this.mouseOver.bind(this), element);
-            overwriteOn(vnode, 'mouseout', this.mouseOut.bind(this), element);
-            overwriteOn(vnode, 'mouseenter', this.mouseEnter.bind(this), element);
-            overwriteOn(vnode, 'mouseleave', this.mouseLeave.bind(this), element);
-            overwriteOn(vnode, 'mousedown', this.mouseDown.bind(this), element);
-            overwriteOn(vnode, 'mouseup', this.mouseUp.bind(this), element);
-            overwriteOn(vnode, 'mousemove', this.mouseMove.bind(this), element);
-            overwriteOn(vnode, 'wheel', this.wheel.bind(this), element);
-            overwriteOn(vnode, 'contextmenu', (_target: SModelElement, event: any) => {
-                event.preventDefault();
-            }, element);
-            overwriteOn(vnode, 'dblclick', this.doubleClick.bind(this), element);
+            overwriteOn(vnode, 'mouseover', this.mouseOver.bind(this, element), element);
+            overwriteOn(vnode, 'mouseout', this.mouseOut.bind(this, element), element);
+            overwriteOn(vnode, 'mouseenter', this.mouseEnter.bind(this, element), element);
+            overwriteOn(vnode, 'mouseleave', this.mouseLeave.bind(this, element), element);
+            overwriteOn(vnode, 'mousedown', this.mouseDown.bind(this, element), element);
+            overwriteOn(vnode, 'mouseup', this.mouseUp.bind(this, element), element);
+            overwriteOn(vnode, 'mousemove', this.mouseMove.bind(this, element), element);
+            overwriteOn(vnode, 'wheel', this.wheel.bind(this, element), element);
+            overwriteOn(vnode, 'contextmenu', this.contextMenu.bind(this, element), element);
+            overwriteOn(vnode, 'dblclick', this.doubleClick.bind(this, element), element);
         }
-        vnode = this.mouseListeners.reduce(
-            (n: VNode, listener: MouseListener) => listener.decorate(n, element),
-            vnode);
+        vnode = this.mouseListeners.reduce((n: VNode, listener: MouseListener) => listener.decorate(n, element), vnode);
         return vnode;
     }
 
+    contextMenu(model: SModelRoot, event: MouseEvent): void {
+        event.preventDefault();
+    }
+
     protected handleEvent<K extends keyof MouseListener>(methodName: K, model: SModelRoot, event: MouseEvent): void {
         this.focusOnMouseEvent(methodName, model);
         const element = this.getTargetElement(model, event);
@@ -74,13 +74,23 @@ export class RankingMouseTool extends MouseTool implements IMouseTool {
         this.notifyListenersByRank(element, methodName, model, event);
     }
 
-    async notifyListenersByRank<K extends keyof MouseListener>(element: SModelElement, methodName: K, model: SModelRoot, event: MouseEvent): Promise<void> {
+    async notifyListenersByRank<K extends keyof MouseListener>(
+        element: SModelElement,
+        methodName: K,
+        model: SModelRoot,
+        event: MouseEvent
+    ): Promise<void> {
         for (const rank of this.rankedMouseListeners) {
             await this.dispatchActions(rank[1], methodName, element, event);
         }
     }
 
-    async dispatchActions<K extends keyof MouseListener>(mouseListeners: MouseListener[], methodName: K, element: SModelElement, event: MouseEvent): Promise<void> {
+    async dispatchActions<K extends keyof MouseListener>(
+        mouseListeners: MouseListener[],
+        methodName: K,
+        element: SModelElement,
+        event: MouseEvent
+    ): Promise<void> {
         const actions = mouseListeners
             .map(listener => listener[methodName].apply(listener, [element, event]))
             .reduce((a, b) => a.concat(b));
@@ -115,13 +125,13 @@ function groupBy<K, T>(array: Array<T>, keyFunction: (x: T) => K): Map<K, T[]> {
     return new Map<K, T[]>([...unsortedMap.entries()].sort());
 }
 
-function overwriteOn(vnode: VNode, event: string, listener: (model: SModelElement, event: Event) => void, element: SModelElement): void {
+function overwriteOn(vnode: VNode, event: string, listener: (model: SModelElement, _event: Event) => void, element: SModelElement): void {
     const val = getOn(vnode);
     // ignore any previous val[event] registrations
     (val as any)[event] = [listener, element];
 }
 
-function getOn(vnode: VNode): any {
+function getOn(vnode: VNode): On {
     const data = getData(vnode);
     if (!data.on) {
         data.on = {};

package/src/features/navigation/di.config.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,16 +13,10 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
+import { NavigateToExternalTargetAction, NavigateToTargetAction } from '@eclipse-glsp/protocol';
 import { ContainerModule } from 'inversify';
-import { configureActionHandler } from 'sprotty/lib';
-
-import {
-    NavigateAction,
-    NavigateToExternalTargetAction,
-    NavigateToTargetAction,
-    NavigationActionHandler,
-    ProcessNavigationArgumentsAction
-} from './navigation-action-handler';
+import { configureActionHandler } from 'sprotty';
+import { NavigateAction, NavigationActionHandler, ProcessNavigationArgumentsAction } from './navigation-action-handler';
 import { NavigationTargetResolver } from './navigation-target-resolver';
 
 export const navigationModule = new ContainerModule((bind, _unbind, isBound) => {

package/src/features/navigation/navigation-action-handler.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,28 +13,29 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { inject, injectable } from 'inversify';
 import {
     Action,
-    ActionHandlerRegistry,
+    Args,
     CenterAction,
-    generateRequestId,
-    IActionDispatcher,
-    IActionHandler,
-    ICommand,
-    ILogger,
-    RequestAction,
-    ResponseAction,
+    GLSPServerStatusAction,
+    isNavigateToExternalTargetAction,
+    isNavigateToTargetAction,
+    isSetNavigationTargetsAction,
+    NavigateToExternalTargetAction,
+    NavigateToTargetAction,
+    NavigationTarget,
+    RequestNavigationTargetsAction,
     SelectAction,
     SelectAllAction,
-    TYPES
-} from 'sprotty';
+    ServerMessageAction,
+    SetResolvedNavigationTargetAction
+} from '@eclipse-glsp/protocol';
+import { inject, injectable } from 'inversify';
+import { ActionHandlerRegistry, IActionDispatcher, IActionHandler, ICommand, ILogger, TYPES } from 'sprotty';
 
-import { Args } from '../../base/args';
-import { EditorContext, EditorContextServiceProvider } from '../../base/editor-context';
+import { EditorContextServiceProvider } from '../../base/editor-context-service';
 import { GLSP_TYPES } from '../../base/types';
-import { GLSPServerStatusAction, ServerMessageAction } from '../../model-source/glsp-server-status';
-import { NavigationTarget, NavigationTargetResolver, SetResolvedNavigationTargetAction } from './navigation-target-resolver';
+import { NavigationTargetResolver } from './navigation-target-resolver';
 
 /**
  * Action for triggering a navigation of a certain target type.
@@ -50,55 +51,11 @@ import { NavigationTarget, NavigationTargetResolver, SetResolvedNavigationTarget
 export class NavigateAction implements Action {
     static readonly KIND = 'navigate';
     readonly kind = NavigateAction.KIND;
-    constructor(readonly targetTypeId: string, readonly args?: Args) { }
+    constructor(readonly targetTypeId: string, readonly args?: Args) {}
 }
 
 export function isNavigateAction(action: Action): action is NavigateAction {
-    return action !== undefined && (action.kind === NavigateAction.KIND)
-        && (action as NavigateAction).targetTypeId !== undefined;
-}
-
-/** Action that is usually sent to the server to request navigation targets for a navigation type. */
-export class RequestNavigationTargetsAction implements RequestAction<SetNavigationTargetsAction> {
-    static readonly KIND = 'requestNavigationTargets';
-    kind = RequestNavigationTargetsAction.KIND;
-    constructor(readonly targetTypeId: string, readonly editorContext: EditorContext,
-        readonly requestId: string = generateRequestId()) { }
-}
-
-/** Action that is usually sent from the server to the client as a repsonse to a `RequestNavigationTargetsAction`. */
-export class SetNavigationTargetsAction implements ResponseAction {
-    static readonly KIND = 'setNavigationTargets';
-    kind = SetNavigationTargetsAction.KIND;
-    constructor(readonly targets: NavigationTarget[], readonly responseId: string = '', readonly args?: Args) { }
-}
-
-export function isSetNavigationTargetsAction(action: Action): action is SetNavigationTargetsAction {
-    return action !== undefined && (action.kind === SetNavigationTargetsAction.KIND)
-        && (action as SetNavigationTargetsAction).targets !== undefined;
-}
-
-/** Action that triggers the navigation to a particular navigation target, such as element IDs, queries, etc.. */
-export class NavigateToTargetAction implements Action {
-    static readonly KIND = 'navigateToTarget';
-    readonly kind = NavigateToTargetAction.KIND;
-    constructor(readonly target: NavigationTarget) { }
-}
-
-export function isNavigateToTargetAction(action: Action): action is NavigateToTargetAction {
-    return action !== undefined && (action.kind === NavigateToTargetAction.KIND)
-        && (action as NavigateToTargetAction).target !== undefined;
-}
-
-export class NavigateToExternalTargetAction implements Action {
-    static readonly KIND = 'navigateToExternalTarget';
-    readonly kind = NavigateToExternalTargetAction.KIND;
-    constructor(readonly target: NavigationTarget) { }
-}
-
-export function isNavigateToExternalTargetAction(action: Action): action is NavigateToExternalTargetAction {
-    return action !== undefined && (action.kind === NavigateToExternalTargetAction.KIND)
-        && (action as NavigateToExternalTargetAction).target !== undefined;
+    return action !== undefined && action.kind === NavigateAction.KIND && (action as NavigateAction).targetTypeId !== undefined;
 }
 
 /** Action to trigger the processing of additional navigation arguments.
@@ -112,12 +69,15 @@ export function isNavigateToExternalTargetAction(action: Action): action is Navi
 export class ProcessNavigationArgumentsAction implements Action {
     static readonly KIND = 'processNavigationArguments';
     readonly kind = ProcessNavigationArgumentsAction.KIND;
-    constructor(readonly args: Args) { }
+    constructor(readonly args: Args) {}
 }
 
 export function isProcessNavigationArgumentsAction(action: Action): action is ProcessNavigationArgumentsAction {
-    return action !== undefined && (action.kind === ProcessNavigationArgumentsAction.KIND)
-        && (action as ProcessNavigationArgumentsAction).args !== undefined;
+    return (
+        action !== undefined &&
+        action.kind === ProcessNavigationArgumentsAction.KIND &&
+        (action as ProcessNavigationArgumentsAction).args !== undefined
+    );
 }
 
 /**
@@ -144,7 +104,6 @@ export function isProcessNavigationArgumentsAction(action: Action): action is Pr
  */
 @injectable()
 export class NavigationActionHandler implements IActionHandler {
-
     readonly notificationTimeout = 5000;
 
     @inject(TYPES.ILogger) protected logger: ILogger;
@@ -172,8 +131,11 @@ export class NavigationActionHandler implements IActionHandler {
             const response = await this.dispatcher.request(new RequestNavigationTargetsAction(action.targetTypeId, context));
             if (isSetNavigationTargetsAction(response) && response.targets && response.targets.length === 1) {
                 if (response.targets.length > 1) {
-                    this.logger.warn(this, 'Processing of multiple targets is not supported yet. ' +
-                        'Only the first is being processed.', response.targets);
+                    this.logger.warn(
+                        this,
+                        'Processing of multiple targets is not supported yet. ' + 'Only the first is being processed.',
+                        response.targets
+                    );
                 }
                 return this.dispatcher.dispatch(new NavigateToTargetAction(response.targets[0]));
             }
@@ -203,7 +165,9 @@ export class NavigationActionHandler implements IActionHandler {
         return this.resolver.resolve(action.target);
     }
 
-    protected containsElementIdsOrArguments(target: SetResolvedNavigationTargetAction | undefined): target is SetResolvedNavigationTargetAction {
+    protected containsElementIdsOrArguments(
+        target: SetResolvedNavigationTargetAction | undefined
+    ): target is SetResolvedNavigationTargetAction {
         return target !== undefined && (this.containsElementIds(target.elementIds) || this.containsArguments(target.args));
     }
 

package/src/features/navigation/navigation-target-resolver.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
@@ -14,15 +14,12 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 /* eslint-disable no-unused-expressions */
+import { NavigationTarget } from '@eclipse-glsp/protocol';
+import { expect } from 'chai';
 import 'mocha';
 import 'reflect-metadata';
 
-import { expect } from 'chai';
-
-import { NavigationTarget } from './navigation-target-resolver';
-
 describe('NavigationTarget', () => {
-
     it('should be able to set and get element IDs', () => {
         const navigationTarget: NavigationTarget = { uri: 'uri' };
         NavigationTarget.setElementIds(navigationTarget, ['id1', 'id2']);
@@ -57,5 +54,4 @@ describe('NavigationTarget', () => {
         NavigationTarget.setTextPosition(navigationTarget, { line: 1, character: 2 });
         expect(NavigationTarget.hasArguments(navigationTarget)).to.be.true;
     });
-
 });