@eclipse-glsp/client 0.9.0-next.c5944e10

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

@@ -0,0 +1,139 @@
+/********************************************************************************
+ * Copyright (c) 2019 EclipseSource and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the Eclipse
+ * Public License v. 2.0 are satisfied: GNU General Public License, version 2
+ * with the GNU Classpath Exception which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ ********************************************************************************/
+import { injectable, multiInject, optional } from 'inversify';
+import { On, VNode, VNodeData } from 'snabbdom';
+import { Action, isAction, MouseListener, MouseTool, SModelElement, SModelRoot, TYPES } from 'sprotty';
+
+import { getRank } from '../rank/model';
+
+export interface IMouseTool {
+    register(mouseListener: MouseListener): void;
+    deregister(mouseListener: MouseListener): void;
+}
+
+@injectable()
+export class RankingMouseTool extends MouseTool implements IMouseTool {
+    protected rankedMouseListeners: Map<number, MouseListener[]>;
+
+    constructor(@multiInject(TYPES.MouseListener) @optional() protected mouseListeners: MouseListener[] = []) {
+        super(mouseListeners);
+        this.rankedMouseListeners = groupBy(mouseListeners, listener => getRank(listener));
+    }
+
+    register(mouseListener: MouseListener): void {
+        super.register(mouseListener);
+        this.rankedMouseListeners = groupBy(this.mouseListeners, listener => getRank(listener));
+    }
+
+    deregister(mouseListener: MouseListener): void {
+        super.deregister(mouseListener);
+        this.rankedMouseListeners = groupBy(this.mouseListeners, listener => getRank(listener));
+    }
+
+    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), 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);
+        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);
+        if (!element) {
+            return;
+        }
+        this.notifyListenersByRank(element, methodName, model, event);
+    }
+
+    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> {
+        const actions = mouseListeners
+            .map(listener => listener[methodName].apply(listener, [element, event]))
+            .reduce((a, b) => a.concat(b));
+        if (actions.length > 0) {
+            event.preventDefault();
+            for (const actionOrPromise of actions) {
+                if (isAction(actionOrPromise)) {
+                    await this.actionDispatcher.dispatch(actionOrPromise);
+                } else {
+                    actionOrPromise.then((action: Action) => {
+                        this.actionDispatcher.dispatch(action);
+                    });
+                }
+            }
+        }
+    }
+}
+
+function groupBy<K, T>(array: Array<T>, keyFunction: (x: T) => K): Map<K, T[]> {
+    const unsortedMap = array.reduce((result: Map<K, T[]>, item: T) => {
+        const key = keyFunction(item);
+        if (!result.has(key)) {
+            result.set(key, [item]);
+        } else {
+            const entries = result.get(key);
+            if (entries) {
+                entries.push(item);
+            }
+        }
+        return result;
+    }, new 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 {
+    const val = getOn(vnode);
+    // ignore any previous val[event] registrations
+    (val as any)[event] = [listener, element];
+}
+
+function getOn(vnode: VNode): On {
+    const data = getData(vnode);
+    if (!data.on) {
+        data.on = {};
+    }
+    return data.on;
+}
+
+function getData(vnode: VNode): VNodeData {
+    if (!vnode.data) {
+        vnode.data = {};
+    }
+    return vnode.data;
+}

package/src/features/navigation/di.config.ts

@@ -0,0 +1,35 @@
+/********************************************************************************
+ * Copyright (c) 2020 EclipseSource and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the Eclipse
+ * Public License v. 2.0 are satisfied: GNU General Public License, version 2
+ * with the GNU Classpath Exception which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ ********************************************************************************/
+import { ContainerModule } from 'inversify';
+import { configureActionHandler } from 'sprotty/lib';
+
+import {
+    NavigateAction,
+    NavigateToExternalTargetAction,
+    NavigateToTargetAction,
+    NavigationActionHandler,
+    ProcessNavigationArgumentsAction
+} from './navigation-action-handler';
+import { NavigationTargetResolver } from './navigation-target-resolver';
+
+export const navigationModule = new ContainerModule((bind, _unbind, isBound) => {
+    bind(NavigationTargetResolver).toSelf().inSingletonScope();
+    bind(NavigationActionHandler).toSelf().inSingletonScope();
+    configureActionHandler({ bind, isBound }, NavigateAction.KIND, NavigationActionHandler);
+    configureActionHandler({ bind, isBound }, NavigateToTargetAction.KIND, NavigationActionHandler);
+    configureActionHandler({ bind, isBound }, ProcessNavigationArgumentsAction.KIND, NavigationActionHandler);
+    configureActionHandler({ bind, isBound }, NavigateToExternalTargetAction.KIND, NavigationActionHandler);
+});

package/src/features/navigation/navigation-action-handler.ts

@@ -0,0 +1,272 @@
+/********************************************************************************
+ * Copyright (c) 2020 EclipseSource and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the Eclipse
+ * Public License v. 2.0 are satisfied: GNU General Public License, version 2
+ * with the GNU Classpath Exception which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ ********************************************************************************/
+import { inject, injectable } from 'inversify';
+import {
+    Action,
+    ActionHandlerRegistry,
+    CenterAction,
+    generateRequestId,
+    IActionDispatcher,
+    IActionHandler,
+    ICommand,
+    ILogger,
+    RequestAction,
+    ResponseAction,
+    SelectAction,
+    SelectAllAction,
+    TYPES
+} from 'sprotty';
+
+import { Args } from '../../base/args';
+import { EditorContext, EditorContextServiceProvider } from '../../base/editor-context';
+import { GLSP_TYPES } from '../../base/types';
+import { GLSPServerStatusAction, ServerMessageAction } from '../../model-source/glsp-server-status';
+import { NavigationTarget, NavigationTargetResolver, SetResolvedNavigationTargetAction } from './navigation-target-resolver';
+
+/**
+ * Action for triggering a navigation of a certain target type.
+ *
+ * Examples for target types could be `documentation`, `implementation`, etc.
+ * but this is up to the domain-specific diagram implementation to decide.
+ * Such an action will eventually trigger a `RequestNavigationTargetsAction`
+ * (see `NavigationActionHandler`) in order to request the navigation targets
+ * from the server.
+ *
+ * This action is typically triggered by a user action.
+ */
+export class NavigateAction implements Action {
+    static readonly KIND = 'navigate';
+    readonly kind = NavigateAction.KIND;
+    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;
+}
+
+/** Action to trigger the processing of additional navigation arguments.
+ *
+ * The resolution of a `NavigationTarget` may entail additional arguments. In this case, this action is
+ * triggered allowing the client to react to those arguments. The default `NavigationActionHandler` will
+ * only process the arguments' keys `info`, `warning`, and `error` to present them to the user.
+ * Customizations, however, may add domain-specific arguments and register custom handler to also process
+ * other arguments and trigger some additional behavior (e.g. update other views, etc.).
+ */
+export class ProcessNavigationArgumentsAction implements Action {
+    static readonly KIND = 'processNavigationArguments';
+    readonly kind = ProcessNavigationArgumentsAction.KIND;
+    constructor(readonly args: Args) { }
+}
+
+export function isProcessNavigationArgumentsAction(action: Action): action is ProcessNavigationArgumentsAction {
+    return action !== undefined && (action.kind === ProcessNavigationArgumentsAction.KIND)
+        && (action as ProcessNavigationArgumentsAction).args !== undefined;
+}
+
+/**
+ * Default handler for all actions that are related to the navigation.
+ *
+ * For a `NavigateAction` this handler triggers a `RequestNavigationTargetAction` to obtain the actual
+ * navigation targets for the navigation type that is specified in the `NavigateAction`.
+ * Once the navigation targets are available, it will trigger a `NavigateToTargetAction` to actually
+ * perform the navigation.
+ *
+ * In other scenarios, clients may also trigger the `NavigateToTargetAction` directly, e.g. when opening
+ * the diagram.
+ *
+ * Depending on the URI and arguments of the navigation target we may encounter three cases:
+ *   *(a)* the navigation target already specifies element IDs, in which case this action handler navigates
+ *         to the specified elements directly, by the selecting them and centering them in the viewport.
+ *   *(b)* the arguments of the navigation targets don't contain element IDs, but other arguments, the
+ *         navigation target needs to be resolved into actual elment IDs by the `NavigationTargetResolver`.
+ *         This can for instance be useful, if the navigation deals with queries or some other more complex
+ *         logic that can't be dealt with on the client.
+ *  *(c)* the target isn't resolved by the `NavigationTargetResolver`, e.g. because the `uri` doesn't match
+ *        the URI of the current diagram. In this case, the navigation request is forwarded by dispatching
+ *        a `NavigateToExternalTargetAction`.
+ */
+@injectable()
+export class NavigationActionHandler implements IActionHandler {
+
+    readonly notificationTimeout = 5000;
+
+    @inject(TYPES.ILogger) protected logger: ILogger;
+    @inject(TYPES.IActionDispatcher) protected dispatcher: IActionDispatcher;
+    @inject(TYPES.ActionHandlerRegistryProvider) protected actionHandlerRegistryProvider: () => Promise<ActionHandlerRegistry>;
+    @inject(GLSP_TYPES.IEditorContextServiceProvider) protected editorContextService: EditorContextServiceProvider;
+    @inject(NavigationTargetResolver) protected resolver: NavigationTargetResolver;
+
+    handle(action: Action): ICommand | Action | void {
+        if (isNavigateAction(action)) {
+            this.handleNavigateAction(action);
+        } else if (isNavigateToTargetAction(action)) {
+            this.handleNavigateToTarget(action);
+        } else if (isProcessNavigationArgumentsAction(action)) {
+            this.processNavigationArguments(action.args);
+        } else if (isNavigateToExternalTargetAction(action)) {
+            this.handleNavigateToExternalTarget(action);
+        }
+    }
+
+    protected async handleNavigateAction(action: NavigateAction): Promise<void> {
+        try {
+            const editorContextService = await this.editorContextService();
+            const context = editorContextService.get(action.args);
+            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);
+                }
+                return this.dispatcher.dispatch(new NavigateToTargetAction(response.targets[0]));
+            }
+            this.warnAboutFailedNavigation('No valid navigation target found');
+        } catch (reason) {
+            this.logger.error(this, 'Failed to obtain navigation target', reason, action);
+        }
+    }
+
+    protected async handleNavigateToTarget(action: NavigateToTargetAction): Promise<void> {
+        try {
+            const resolvedElements = await this.resolveElements(action);
+            if (this.containsElementIdsOrArguments(resolvedElements)) {
+                this.navigateTo(resolvedElements);
+                this.handleResolutionArguments(resolvedElements);
+                return;
+            } else {
+                this.navigateToExternal(action.target);
+                return;
+            }
+        } catch (reason) {
+            this.logger.error(this, 'Failed to navigate', reason, action);
+        }
+    }
+
+    protected resolveElements(action: NavigateToTargetAction): Promise<SetResolvedNavigationTargetAction | undefined> {
+        return this.resolver.resolve(action.target);
+    }
+
+    protected containsElementIdsOrArguments(target: SetResolvedNavigationTargetAction | undefined): target is SetResolvedNavigationTargetAction {
+        return target !== undefined && (this.containsElementIds(target.elementIds) || this.containsArguments(target.args));
+    }
+
+    protected containsElementIds(elementIds: string[] | undefined): elementIds is string[] {
+        return elementIds !== undefined && elementIds.length > 0;
+    }
+
+    protected containsArguments(args: Args | undefined): args is Args {
+        return args !== undefined && args !== undefined && Object.keys(args).length > 0;
+    }
+
+    protected navigateTo(target: SetResolvedNavigationTargetAction): void {
+        const elementIds = target.elementIds;
+        if (!this.containsElementIds(elementIds)) {
+            return;
+        }
+        this.dispatcher.dispatchAll([new SelectAllAction(false), new SelectAction(elementIds), new CenterAction(elementIds)]);
+    }
+
+    protected handleResolutionArguments(target: SetResolvedNavigationTargetAction): void {
+        const args = target.args;
+        if (!this.containsArguments(args)) {
+            return;
+        }
+        this.dispatcher.dispatch(new ProcessNavigationArgumentsAction(args));
+    }
+
+    protected navigateToExternal(target: NavigationTarget): Promise<void> {
+        return this.dispatcher.dispatch(new NavigateToExternalTargetAction(target));
+    }
+
+    protected processNavigationArguments(args: Args): void {
+        if (args.info && args.info.toString().length > 0) {
+            this.notify('INFO', args.info.toString());
+        }
+        if (args.warning && args.warning.toString().length > 0) {
+            this.notify('WARNING', args.warning.toString());
+        }
+        if (args.error && args.error.toString().length > 0) {
+            this.notify('ERROR', args.error.toString());
+        }
+    }
+
+    protected async handleNavigateToExternalTarget(action: NavigateToExternalTargetAction): Promise<void> {
+        const registry = await this.actionHandlerRegistryProvider();
+        const handlers = registry.get(NavigateToExternalTargetAction.KIND);
+        if (handlers.length === 1) {
+            // we are the only handler so we know nobody took care of it
+            this.warnAboutFailedNavigation('Could not resolve or navigate to target', action.target);
+        }
+    }
+
+    protected warnAboutFailedNavigation(msg: string, target?: NavigationTarget): void {
+        const message = `${msg}` + (target ? `: '${target.uri}' (arguments: ${JSON.stringify(target.args)})` : '');
+        this.logger.warn(this, msg, target);
+        this.notify('WARNING', message);
+    }
+
+    private notify(severity: string, message: string): void {
+        const timeout = this.notificationTimeout;
+        this.dispatcher.dispatchAll([
+            { kind: GLSPServerStatusAction.KIND, severity, timeout, message } as GLSPServerStatusAction,
+            { kind: ServerMessageAction.KIND, severity, timeout, message } as ServerMessageAction
+        ]);
+    }
+}

package/src/features/navigation/navigation-target-resolver.spec.ts

@@ -0,0 +1,61 @@
+/********************************************************************************
+ * Copyright (c) 2020 EclipseSource and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the Eclipse
+ * Public License v. 2.0 are satisfied: GNU General Public License, version 2
+ * with the GNU Classpath Exception which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ ********************************************************************************/
+/* eslint-disable no-unused-expressions */
+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']);
+        expect(NavigationTarget.getElementIds(navigationTarget)).to.be.eql(['id1', 'id2']);
+    });
+
+    it('should be able to set and get textual positions', () => {
+        const navigationTarget: NavigationTarget = { uri: 'uri' };
+        NavigationTarget.setTextPosition(navigationTarget, { line: 1, character: 2 });
+        expect(NavigationTarget.getTextPosition(navigationTarget)).to.be.eql({ line: 1, character: 2 });
+    });
+
+    it('should be able to set and get custom query arguments', () => {
+        const navigationTarget: NavigationTarget = { uri: 'uri' };
+        NavigationTarget.addArgument(navigationTarget, 'name', 'test');
+        expect(navigationTarget.args!.name).to.be.eql('test');
+    });
+
+    it('should specify whether it has arguments', () => {
+        let navigationTarget: NavigationTarget = { uri: 'uri' };
+        expect(NavigationTarget.hasArguments(navigationTarget)).to.be.false;
+        NavigationTarget.addArgument(navigationTarget, 'name', 'test');
+        expect(NavigationTarget.hasArguments(navigationTarget)).to.be.true;
+
+        navigationTarget = { uri: 'uri' };
+        expect(NavigationTarget.hasArguments(navigationTarget)).to.be.false;
+        NavigationTarget.setElementIds(navigationTarget, ['id1', 'id2']);
+        expect(NavigationTarget.hasArguments(navigationTarget)).to.be.true;
+
+        navigationTarget = { uri: 'uri' };
+        expect(NavigationTarget.hasArguments(navigationTarget)).to.be.false;
+        NavigationTarget.setTextPosition(navigationTarget, { line: 1, character: 2 });
+        expect(NavigationTarget.hasArguments(navigationTarget)).to.be.true;
+    });
+
+});

package/src/features/navigation/navigation-target-resolver.ts

@@ -0,0 +1,146 @@
+/********************************************************************************
+ * Copyright (c) 2020 EclipseSource and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the Eclipse
+ * Public License v. 2.0 are satisfied: GNU General Public License, version 2
+ * with the GNU Classpath Exception which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ ********************************************************************************/
+import { inject, injectable } from 'inversify';
+import { Action, generateRequestId, IActionDispatcher, ILogger, RequestAction, ResponseAction, TYPES } from 'sprotty';
+
+import { Args } from '../../base/args';
+import { EditorContextServiceProvider } from '../../base/editor-context';
+import { GLSP_TYPES } from '../../base/types';
+
+export interface NavigationTarget {
+    uri: string;
+    label?: string;
+    args?: Args;
+}
+
+export namespace NavigationTarget {
+
+    export const ELEMENT_IDS = 'elementIds';
+    export const ELEMENT_IDS_SEPARATOR = '&';
+    export const TEXT_LINE = 'line';
+    export const TEXT_COLUMN = 'column';
+
+    export function hasArguments(target: NavigationTarget): boolean {
+        return target.args !== undefined && Object.keys(target.args).length > 0;
+    }
+
+    export function addArgument(target: NavigationTarget, key: string, value: string | number | boolean): void {
+        if (target.args === undefined) {
+            target.args = {};
+        }
+        target.args[key] = value;
+    }
+
+    export function getElementIds(target: NavigationTarget): string[] {
+        if (target.args === undefined || target.args[NavigationTarget.ELEMENT_IDS] === undefined) {
+            return [];
+        }
+        const elementIdsValue = target.args[NavigationTarget.ELEMENT_IDS].toString();
+        return elementIdsValue.split(NavigationTarget.ELEMENT_IDS_SEPARATOR);
+    }
+
+    export function setElementIds(target: NavigationTarget, elementIds: string[]): string {
+        if (target.args === undefined) {
+            target.args = {};
+        }
+        return target.args[NavigationTarget.ELEMENT_IDS] = elementIds.join(NavigationTarget.ELEMENT_IDS_SEPARATOR);
+    }
+
+    export function setTextPosition(target: NavigationTarget, position: TextPosition | undefined): void {
+        if (position) {
+            if (target.args === undefined) {
+                target.args = {};
+            }
+            target.args[NavigationTarget.TEXT_LINE] = position.line;
+            target.args[NavigationTarget.TEXT_COLUMN] = position.character;
+        }
+    }
+
+    export function getTextPosition(target: NavigationTarget): TextPosition | undefined {
+        if (target.args === undefined
+            || target.args[NavigationTarget.TEXT_LINE] === undefined
+            || target.args[NavigationTarget.TEXT_COLUMN] === undefined) {
+            return undefined;
+        }
+        return {
+            line: Number(target.args[NavigationTarget.TEXT_LINE]),
+            character: Number(target.args[NavigationTarget.TEXT_COLUMN])
+        };
+    }
+}
+
+export interface TextPosition {
+    line: number;
+    character: number;
+}
+
+export class ResolveNavigationTargetAction implements RequestAction<SetResolvedNavigationTargetAction> {
+    static readonly KIND = 'resolveNavigationTarget';
+    kind = ResolveNavigationTargetAction.KIND;
+    constructor(readonly navigationTarget: NavigationTarget, public readonly requestId: string = generateRequestId()) { }
+}
+
+export class SetResolvedNavigationTargetAction implements ResponseAction {
+    static readonly KIND = 'setResolvedNavigationTarget';
+    kind = SetResolvedNavigationTargetAction.KIND;
+    constructor(readonly elementIds: string[] = [], readonly args?: Args, readonly responseId: string = '') { }
+}
+
+export function isSetResolvedNavigationTargets(action: Action): action is SetResolvedNavigationTargetAction {
+    return action !== undefined && (action.kind === SetResolvedNavigationTargetAction.KIND);
+}
+
+/**
+ * Resolves `NavigationTargets` to element ids.
+ *
+ * If the `NavigationTarget` doesn't have element ids itself, this resolver queries the server via a
+ * `ResolveNavigationTargetAction` for element ids.
+ */
+@injectable()
+export class NavigationTargetResolver {
+
+    @inject(GLSP_TYPES.IEditorContextServiceProvider) protected editorContextService: EditorContextServiceProvider;
+    @inject(TYPES.IActionDispatcher) protected dispatcher: IActionDispatcher;
+    @inject(TYPES.ILogger) protected readonly logger: ILogger;
+
+    async resolve(navigationTarget: NavigationTarget): Promise<SetResolvedNavigationTargetAction | undefined> {
+        const contextService = await this.editorContextService();
+        const sourceUri = await contextService.getSourceUri();
+        return this.resolveWithSourceUri(sourceUri, navigationTarget);
+    }
+
+    async resolveWithSourceUri(sourceUri: string | undefined, target: NavigationTarget): Promise<SetResolvedNavigationTargetAction | undefined> {
+        const targetUri = decodeURIComponent(target.uri);
+        if (sourceUri && sourceUri !== targetUri && `file://${sourceUri}` !== targetUri) {
+            // different URI, so we can't resolve it locally
+            this.logger.info("Source and Target URI are different. Can't resolve locally.", sourceUri, targetUri);
+            return undefined;
+        }
+        if (NavigationTarget.getElementIds(target).length > 0) {
+            return new SetResolvedNavigationTargetAction(NavigationTarget.getElementIds(target));
+        }
+        const response = await this.requestResolution(target);
+        if (isSetResolvedNavigationTargets(response)) {
+            return response;
+        }
+        return undefined;
+    }
+
+    protected requestResolution(target: NavigationTarget): Promise<ResponseAction> {
+        return this.dispatcher.request(new ResolveNavigationTargetAction(target));
+    }
+}
+