@eclipse-glsp/client 0.10.0-next.6bee8eb.163 → 0.10.0-next.88e4725.166

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

@@ -13,26 +13,19 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { Action, ChangeBoundsOperation, ElementAndBounds } from '@eclipse-glsp/protocol';
+import { Action, ChangeBoundsOperation, ElementAndBounds, hasArrayProp, hasNumberProp, SetBoundsAction } from '@eclipse-glsp/protocol';
 import { inject, injectable, optional } from 'inversify';
-import {
-    Command,
-    CommandExecutionContext,
-    CommandReturn,
-    ElementMove,
-    IActionDispatcher,
-    MoveAction,
-    SetBoundsAction,
-    SModelElement,
-    TYPES
-} from 'sprotty';
-import { GLSP_TYPES } from '../../base/types';
+import { Command, CommandExecutionContext, CommandReturn, ElementMove, IActionDispatcher, MoveAction, SModelElement } from 'sprotty';
+import { TYPES } from '../../base/types';
 import { toValidElementAndBounds, toValidElementMove, WriteableElementAndBounds, WriteableElementMove } from '../../utils/layout-utils';
 import { BoundsAwareModelElement } from '../../utils/smodel-util';
 import { isBoundsAwareMoveable, isResizable } from '../change-bounds/model';
 import { IMovementRestrictor } from '../change-bounds/movement-restrictor';
 import { SelectionService } from '../select/selection-service';
 
+/**
+ * Used to specify the desired resize dimension for a {@link ResizeElementsCommand}.
+ */
 // eslint-disable-next-line no-shadow
 export enum ResizeDimension {
     Width,
@@ -41,43 +34,99 @@ export enum ResizeDimension {
 }
 
 export namespace Reduce {
+    /**
+     * Returns the minimal value of the given numbers.
+     * @param values Numbers to be evaluated.
+     * @returns The reduced number.
+     */
     export function min(...values: number[]): number {
         return Math.min(...values);
     }
 
+    /**
+     * Returns the maximal value of the given numbers.
+     * @param values Numbers to be evaluated.
+     * @returns The reduced number.
+     */
     export function max(...values: number[]): number {
         return Math.max(...values);
     }
 
+    /**
+     * Computes the  average of the given numbers.
+     * @param values Numbers to be evaluated.
+     */
     export function avg(...values: number[]): number {
         return values.reduce((a, b) => a + b, 0) / values.length;
     }
 
+    /**
+     *  Returns the last value of the given numbers.
+     *  @param values Numbers to be evaluated.
+     *  @returns The reduced number.
+     */
     export function first(...values: number[]): number {
         return values[0];
     }
 
+    /**
+     *  Returns the minimal value of the given numbers.
+     *  @param values Numbers  to be evaluated.
+     *  @returns The reduced number.
+     */
     export function last(...values: number[]): number {
         return values[values.length - 1];
     }
+
+    /**
+     * Returns the reduce function that corresponds to the given {@link ReduceFunctionKind}.
+     * @param type The reduce function kind.
+     * @returns The corresponding reduce function.
+     */
 }
 
-export class ResizeElementsAction implements Action {
-    constructor(
-        /**
-         * IDs of the elements that should be resized. If no IDs are given, the selected elements will be resized.
-         */
-        public readonly elementIds: string[] = [],
-        /**
-         * Resize dimension.
-         */
-        public readonly dimension: ResizeDimension = ResizeDimension.Width,
-        /**
-         * Function to reduce the dimension to a target dimension value, see Reduce.* for potential functions.
-         */
-        public readonly reductionFunction: (...values: number[]) => number,
-        public readonly kind: string = ResizeElementsCommand.KIND
-    ) {}
+type ReduceFn = (...values: number[]) => number;
+export interface ResizeElementsAction extends Action {
+    kind: typeof ResizeElementsAction.KIND;
+
+    /**
+     * IDs of the elements that should be resized. If no IDs are given, the selected elements will be resized.
+     */
+    elementIds: string[];
+    /**
+     * Resize dimension. The default is {@link ResizeDimension.Width}.
+     */
+    dimension: ResizeDimension;
+    /**
+     * Function to reduce the dimension to a target dimension value, see Reduce.* for potential functions.
+     */
+    reductionFunction: ReduceFn;
+}
+
+export namespace ResizeElementsAction {
+    export const KIND = 'resizeElementAction';
+
+    export function is(object: any): object is ResizeElementsAction {
+        return (
+            Action.hasKind(object, KIND) &&
+            hasArrayProp(object, 'elementIds') &&
+            hasNumberProp(object, 'dimension') &&
+            'reductionFunction' in object
+        );
+    }
+
+    export function create(options: {
+        elementIds?: string[];
+        dimension?: ResizeDimension;
+        reductionFunction: ReduceFn;
+    }): ResizeElementsAction {
+        return {
+            kind: KIND,
+            dimension: ResizeDimension.Width,
+            elementIds: [],
+            ...options
+        };
+    }
 }
 
 // eslint-disable-next-line no-shadow
@@ -104,31 +153,56 @@ export namespace Select {
     }
 }
 
-export class AlignElementsAction implements Action {
-    constructor(
-        /**
-         * IDs of the elements that should be aligned. If no IDs are given, the selected elements will be aligned.
-         */
-        public readonly elementIds: string[] = [],
-        /**
-         * Alignment direction.
-         */
-        public readonly alignment: Alignment = Alignment.Left,
-        /**
-         * Function to selected elements that are considered during alignment calculation, see Select.* for potential functions.
-         */
-        public readonly selectionFunction: (elements: BoundsAwareModelElement[]) => BoundsAwareModelElement[] = Select.all,
-        public readonly kind = AlignElementsCommand.KIND
-    ) {}
+type SelectFn = (elements: BoundsAwareModelElement[]) => BoundsAwareModelElement[];
+export interface AlignElementsAction extends Action {
+    kind: typeof AlignElementsAction.KIND;
+
+    /**
+     * IDs of the elements that should be aligned. If no IDs are given, the selected elements will be aligned.
+     */
+    elementIds: string[];
+    /**
+     * Alignment direction. The default is {@link Alignment.Left}
+     */
+    alignment: Alignment;
+    /**
+     * Function to selected elements that are considered during alignment calculation, see Select.* for potential functions.
+     * The default value is {@link Select.all}.
+     */
+    selectionFunction: SelectFn;
 }
 
+export namespace AlignElementsAction {
+    export const KIND = 'alignElements';
+
+    export function is(object: any): object is AlignElementsAction {
+        return (
+            Action.hasKind(object, KIND) &&
+            hasArrayProp(object, 'elementIds') &&
+            hasNumberProp(object, 'alignment') &&
+            'selectionFunction' in object
+        );
+    }
+
+    export function create(
+        options: { elementIds?: string[]; alignment?: Alignment; selectionFunction?: SelectFn } = {}
+    ): AlignElementsAction {
+        return {
+            kind: KIND,
+            elementIds: [],
+            alignment: Alignment.Left,
+            selectionFunction: Select.all,
+            ...options
+        };
+    }
+}
 @injectable()
 abstract class LayoutElementsCommand extends Command {
     constructor(
         @inject(TYPES.Action) protected action: ResizeElementsAction | AlignElementsAction,
         @inject(TYPES.IActionDispatcher) protected actionDispatcher: IActionDispatcher,
-        @inject(GLSP_TYPES.SelectionService) protected selectionService: SelectionService,
-        @inject(GLSP_TYPES.IMovementRestrictor) @optional() readonly movementRestrictor?: IMovementRestrictor
+        @inject(TYPES.SelectionService) protected selectionService: SelectionService,
+        @inject(TYPES.IMovementRestrictor) @optional() readonly movementRestrictor?: IMovementRestrictor
     ) {
         super();
     }
@@ -163,13 +237,13 @@ abstract class LayoutElementsCommand extends Command {
 
 @injectable()
 export class ResizeElementsCommand extends LayoutElementsCommand {
-    static readonly KIND = 'layout:resize';
+    static readonly KIND = ResizeElementsAction.KIND;
 
     constructor(
         @inject(TYPES.Action) protected override action: ResizeElementsAction,
         @inject(TYPES.IActionDispatcher) protected override actionDispatcher: IActionDispatcher,
-        @inject(GLSP_TYPES.SelectionService) protected override selectionService: SelectionService,
-        @inject(GLSP_TYPES.IMovementRestrictor) @optional() override readonly movementRestrictor?: IMovementRestrictor
+        @inject(TYPES.SelectionService) protected override selectionService: SelectionService,
+        @inject(TYPES.IMovementRestrictor) @optional() override readonly movementRestrictor?: IMovementRestrictor
     ) {
         super(action, actionDispatcher, selectionService, movementRestrictor);
     }
@@ -242,7 +316,7 @@ export class ResizeElementsCommand extends LayoutElementsCommand {
                 elementAndBounds.push(elementChange);
             }
         });
-        this.dispatchActions([new SetBoundsAction(elementAndBounds), new ChangeBoundsOperation(elementAndBounds)]);
+        this.dispatchActions([SetBoundsAction.create(elementAndBounds), ChangeBoundsOperation.create(elementAndBounds)]);
     }
 
     createElementAndBounds(
@@ -277,13 +351,13 @@ export class ResizeElementsCommand extends LayoutElementsCommand {
 
 @injectable()
 export class AlignElementsCommand extends LayoutElementsCommand {
-    static readonly KIND = 'layout:align';
+    static readonly KIND = AlignElementsAction.KIND;
 
     constructor(
         @inject(TYPES.Action) protected override action: AlignElementsAction,
         @inject(TYPES.IActionDispatcher) protected override actionDispatcher: IActionDispatcher,
-        @inject(GLSP_TYPES.SelectionService) protected override selectionService: SelectionService,
-        @inject(GLSP_TYPES.IMovementRestrictor) @optional() override readonly movementRestrictor?: IMovementRestrictor
+        @inject(TYPES.SelectionService) protected override selectionService: SelectionService,
+        @inject(TYPES.IMovementRestrictor) @optional() override readonly movementRestrictor?: IMovementRestrictor
     ) {
         super(action, actionDispatcher, selectionService, movementRestrictor);
     }
@@ -376,7 +450,7 @@ export class AlignElementsCommand extends LayoutElementsCommand {
                 elementAndBounds.push(elementAndBound);
             }
         });
-        this.dispatchActions([new MoveAction(moves), new ChangeBoundsOperation(elementAndBounds)]);
+        this.dispatchActions([MoveAction.create(moves), ChangeBoundsOperation.create(elementAndBounds)]);
     }
 
     createElementMove(

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

@@ -13,17 +13,13 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
+import { Bounds, Dimension, Point } from '@eclipse-glsp/protocol';
 import { injectable } from 'inversify';
 import {
-    Bounds,
     BoundsData,
-    Dimension,
-    EMPTY_BOUNDS,
     isBoundsAware,
     isLayoutableChild,
-    isValidDimension,
     LayoutContainer,
-    Point,
     SChildElement,
     SModelElement,
     SParentElement,
@@ -91,7 +87,7 @@ export class VBoxLayouterExt extends VBoxLayouter {
         container.children.forEach(child => {
             if (isLayoutableChild(child)) {
                 const bounds = layouter.getBoundsData(child).bounds;
-                if (bounds !== undefined && isValidDimension(bounds)) {
+                if (bounds !== undefined && Dimension.isValid(bounds)) {
                     maxHeight += bounds.height;
                     if (isFirst) {
                         isFirst = false;
@@ -128,7 +124,7 @@ export class VBoxLayouterExt extends VBoxLayouter {
                 const boundsData = layouter.getBoundsData(child);
                 const bounds = boundsData.bounds;
                 const childOptions = this.getChildLayoutOptions(child, containerOptions);
-                if (bounds !== undefined && isValidDimension(bounds)) {
+                if (bounds !== undefined && Dimension.isValid(bounds)) {
                     currentOffset = this.layoutChild(
                         child,
                         boundsData,
@@ -197,7 +193,7 @@ export class VBoxLayouterExt extends VBoxLayouter {
             const height = elementOptions?.prefHeight ?? 0;
             return { ...bounds, width, height };
         }
-        return EMPTY_BOUNDS;
+        return Bounds.EMPTY;
     }
 
     protected override getChildLayoutOptions(child: SChildElement, containerOptions: VBoxLayoutOptionsExt): VBoxLayoutOptionsExt {

package/src/features/model-source-watcher/model-source-changed-action-handler.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2020-2021 EclipseSource and others.
+ * Copyright (c) 2020-2022 EclipseSource and others.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -13,15 +13,10 @@
  *
  * 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 { Action, ModelSourceChangedAction, ServerMessageAction, ServerStatusAction } from '@eclipse-glsp/protocol';
 import { inject, injectable, optional } from 'inversify';
-import { IActionDispatcher, IActionHandler, TYPES, ViewerOptions } from 'sprotty';
+import { IActionDispatcher, IActionHandler, ViewerOptions } from 'sprotty';
+import { TYPES } from '../../base/types';
 
 /**
  * An external handler of the model source change event.
@@ -51,7 +46,7 @@ export class ModelSourceChangedActionHandler implements IActionHandler {
     protected externalModelSourceChangedHandler?: ExternalModelSourceChangedHandler;
 
     handle(action: Action): void {
-        if (isModelSourceChangedAction(action)) {
+        if (ModelSourceChangedAction.is(action)) {
             if (this.externalModelSourceChangedHandler) {
                 this.externalModelSourceChangedHandler
                     .notifyModelSourceChange(action.modelSourceName, this.options)
@@ -67,8 +62,8 @@ export class ModelSourceChangedActionHandler implements IActionHandler {
         const timeout = 0;
         const severity = 'WARNING';
         this.dispatcher.dispatchAll([
-            { kind: GLSPServerStatusAction.KIND, severity, timeout, message } as GLSPServerStatusAction,
-            { kind: ServerMessageAction.KIND, severity, timeout, message } as ServerMessageAction
+            ServerStatusAction.create(message, { severity, timeout }),
+            ServerMessageAction.create(message, { severity, timeout })
         ]);
     }
 }

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

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2019 EclipseSource and others.
+ * Copyright (c) 2019-2022 EclipseSource and others.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -15,13 +15,12 @@
  ********************************************************************************/
 import { ContainerModule } from 'inversify';
 import { MouseTool } from 'sprotty';
-
-import { GLSP_TYPES } from '../../base/types';
+import { TYPES } from '../../base/types';
 import { RankingMouseTool } from './mouse-tool';
 
 const glspMouseToolModule = new ContainerModule((bind, _unbind, _isBound, rebind) => {
     bind(RankingMouseTool).toSelf().inSingletonScope();
-    bind(GLSP_TYPES.MouseTool).toService(RankingMouseTool);
+    bind(TYPES.MouseTool).toService(RankingMouseTool);
     rebind(MouseTool).toService(RankingMouseTool);
 });
 

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

@@ -13,9 +13,9 @@
  *
  * 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 { MouseListener, MouseTool, SModelElement, SModelRoot, TYPES } from 'sprotty';
+import { MouseListener, MouseTool, SModelElement, SModelRoot } from 'sprotty';
+import { TYPES } from '../../base/types';
 import { getRank } from '../rank/model';
 
 export interface IMouseTool {
@@ -82,13 +82,8 @@ export class RankingMouseTool extends MouseTool implements IMouseTool {
         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);
-                    });
-                }
+                const action = await actionOrPromise;
+                await this.actionDispatcher.dispatch(action);
             }
         }
     }

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

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2020-2021 EclipseSource and others.
+ * Copyright (c) 2020-2022 EclipseSource and others.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -17,10 +17,8 @@ import {
     Action,
     Args,
     CenterAction,
-    GLSPServerStatusAction,
-    isNavigateToExternalTargetAction,
-    isNavigateToTargetAction,
-    isSetNavigationTargetsAction,
+    hasObjectProp,
+    hasStringProp,
     NavigateToExternalTargetAction,
     NavigateToTargetAction,
     NavigationTarget,
@@ -28,13 +26,15 @@ import {
     SelectAction,
     SelectAllAction,
     ServerMessageAction,
+    ServerSeverity,
+    ServerStatusAction,
+    SetNavigationTargetsAction,
     SetResolvedNavigationTargetAction
 } from '@eclipse-glsp/protocol';
 import { inject, injectable } from 'inversify';
-import { ActionHandlerRegistry, IActionDispatcher, IActionHandler, ICommand, ILogger, TYPES } from 'sprotty';
-
+import { ActionHandlerRegistry, IActionDispatcher, IActionHandler, ICommand, ILogger } from 'sprotty';
 import { EditorContextServiceProvider } from '../../base/editor-context-service';
-import { GLSP_TYPES } from '../../base/types';
+import { TYPES } from '../../base/types';
 import { NavigationTargetResolver } from './navigation-target-resolver';
 
 /**
@@ -48,38 +48,66 @@ import { NavigationTargetResolver } from './navigation-target-resolver';
  *
  * 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 interface NavigateAction extends Action {
+    kind: typeof NavigateAction.KIND;
+    /**
+     * Navigation target type, such as `documentation`, `implementation`, etc.
+     */
+    targetTypeId: string;
+    /**
+     * Additional arguments for customization.
+     */
+    args?: Args;
 }
 
-export function isNavigateAction(action: Action): action is NavigateAction {
-    return action !== undefined && action.kind === NavigateAction.KIND && (action as NavigateAction).targetTypeId !== undefined;
+export namespace NavigateAction {
+    export const KIND = 'navigate';
+
+    export function is(object: any): object is NavigateAction {
+        return Action.hasKind(object, KIND) && hasStringProp(object, 'targetTypeId');
+    }
+
+    export function create(targetTypeId: string, options: { args?: Args } = {}): NavigateAction {
+        return {
+            kind: KIND,
+            targetTypeId,
+            ...options
+        };
+    }
 }
 
-/** Action to trigger the processing of additional navigation arguments.
- *
+/**
+ * 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
-    );
+export interface ProcessNavigationArgumentsAction extends Action {
+    kind: typeof ProcessNavigationArgumentsAction.KIND;
+    /**
+     * The navigation arguments.
+     */
+    args: Args;
 }
 
+export namespace ProcessNavigationArgumentsAction {
+    export const KIND = 'processNavigationArguments';
+
+    export function is(object: any): object is ProcessNavigationArgumentsAction {
+        return Action.hasKind(object, KIND) && hasObjectProp(object, 'args');
+    }
+
+    export function create(args: Args): ProcessNavigationArgumentsAction {
+        return {
+            kind: KIND,
+            args
+        };
+    }
+}
 /**
  * Default handler for all actions that are related to the navigation.
  *
@@ -109,17 +137,17 @@ export class NavigationActionHandler implements IActionHandler {
     @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(TYPES.IEditorContextServiceProvider) protected editorContextService: EditorContextServiceProvider;
     @inject(NavigationTargetResolver) protected resolver: NavigationTargetResolver;
 
     handle(action: Action): ICommand | Action | void {
-        if (isNavigateAction(action)) {
+        if (NavigateAction.is(action)) {
             this.handleNavigateAction(action);
-        } else if (isNavigateToTargetAction(action)) {
+        } else if (NavigateToTargetAction.is(action)) {
             this.handleNavigateToTarget(action);
-        } else if (isProcessNavigationArgumentsAction(action)) {
+        } else if (ProcessNavigationArgumentsAction.is(action)) {
             this.processNavigationArguments(action.args);
-        } else if (isNavigateToExternalTargetAction(action)) {
+        } else if (NavigateToExternalTargetAction.is(action)) {
             this.handleNavigateToExternalTarget(action);
         }
     }
@@ -127,9 +155,11 @@ export class NavigationActionHandler implements IActionHandler {
     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) {
+            const editorContext = editorContextService.get(action.args);
+            const response = await this.dispatcher.request(
+                RequestNavigationTargetsAction.create({ targetTypeId: action.targetTypeId, editorContext })
+            );
+            if (SetNavigationTargetsAction.is(response) && response.targets && response.targets.length === 1) {
                 if (response.targets.length > 1) {
                     this.logger.warn(
                         this,
@@ -137,7 +167,7 @@ export class NavigationActionHandler implements IActionHandler {
                         response.targets
                     );
                 }
-                return this.dispatcher.dispatch(new NavigateToTargetAction(response.targets[0]));
+                return this.dispatcher.dispatch(NavigateToTargetAction.create(response.targets[0]));
             }
             this.warnAboutFailedNavigation('No valid navigation target found');
         } catch (reason) {
@@ -184,7 +214,11 @@ export class NavigationActionHandler implements IActionHandler {
         if (!this.containsElementIds(elementIds)) {
             return;
         }
-        this.dispatcher.dispatchAll([new SelectAllAction(false), new SelectAction(elementIds), new CenterAction(elementIds)]);
+        this.dispatcher.dispatchAll([
+            SelectAllAction.create(false),
+            SelectAction.create({ selectedElementsIDs: elementIds }),
+            CenterAction.create(elementIds)
+        ]);
     }
 
     protected handleResolutionArguments(target: SetResolvedNavigationTargetAction): void {
@@ -192,11 +226,11 @@ export class NavigationActionHandler implements IActionHandler {
         if (!this.containsArguments(args)) {
             return;
         }
-        this.dispatcher.dispatch(new ProcessNavigationArgumentsAction(args));
+        this.dispatcher.dispatch(ProcessNavigationArgumentsAction.create(args));
     }
 
     protected navigateToExternal(target: NavigationTarget): Promise<void> {
-        return this.dispatcher.dispatch(new NavigateToExternalTargetAction(target));
+        return this.dispatcher.dispatch(NavigateToExternalTargetAction.create(target));
     }
 
     protected processNavigationArguments(args: Args): void {
@@ -226,11 +260,11 @@ export class NavigationActionHandler implements IActionHandler {
         this.notify('WARNING', message);
     }
 
-    private notify(severity: string, message: string): void {
+    private notify(severity: ServerSeverity, 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
+            ServerStatusAction.create(message, { severity, timeout }),
+            ServerMessageAction.create(message, { severity, timeout })
         ]);
     }
 }

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

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2020-2021 EclipseSource and others.
+ * Copyright (c) 2020-2022 EclipseSource and others.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -22,7 +22,7 @@ import 'reflect-metadata';
 describe('NavigationTarget', () => {
     it('should be able to set and get element IDs', () => {
         const navigationTarget: NavigationTarget = { uri: 'uri' };
-        NavigationTarget.setElementIds(navigationTarget, ['id1', 'id2']);
+        NavigationTarget.setElementIds(navigationTarget, 'id1', 'id2');
         expect(NavigationTarget.getElementIds(navigationTarget)).to.be.eql(['id1', 'id2']);
     });
 
@@ -46,7 +46,7 @@ describe('NavigationTarget', () => {
 
         navigationTarget = { uri: 'uri' };
         expect(NavigationTarget.hasArguments(navigationTarget)).to.be.false;
-        NavigationTarget.setElementIds(navigationTarget, ['id1', 'id2']);
+        NavigationTarget.setElementIds(navigationTarget, 'id1', 'id2');
         expect(NavigationTarget.hasArguments(navigationTarget)).to.be.true;
 
         navigationTarget = { uri: 'uri' };