@eclipse-glsp/client 0.9.0 → 0.10.0-next.15853de.178

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

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2019-2021 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
@@ -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 { Action } from '@eclipse-glsp/protocol';
 import { injectable, multiInject, optional } from 'inversify';
-import { On, VNode, VNodeData } from 'snabbdom';
-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 {
@@ -24,48 +24,32 @@ export interface IMouseTool {
     deregister(mouseListener: MouseListener): void;
 }
 
+/**
+ * Custom helper type to declare the explicit mouse listener methods
+ * of {@link MouseListener} i.e. omitting the `decorate` method.
+ */
+type MouseListenerMethods = keyof Omit<MouseListener, 'decorate'>;
+
 @injectable()
 export class RankingMouseTool extends MouseTool implements IMouseTool {
     protected rankedMouseListeners: Map<number, MouseListener[]>;
 
-    constructor(@multiInject(TYPES.MouseListener) @optional() protected mouseListeners: MouseListener[] = []) {
+    constructor(@multiInject(TYPES.MouseListener) @optional() protected override mouseListeners: MouseListener[] = []) {
         super(mouseListeners);
         this.rankedMouseListeners = groupBy(mouseListeners, listener => getRank(listener));
     }
 
-    register(mouseListener: MouseListener): void {
+    override register(mouseListener: MouseListener): void {
         super.register(mouseListener);
         this.rankedMouseListeners = groupBy(this.mouseListeners, listener => getRank(listener));
     }
 
-    deregister(mouseListener: MouseListener): void {
+    override 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 {
+    protected override handleEvent<K extends MouseListenerMethods>(methodName: K, model: SModelRoot, event: MouseEvent): void {
         this.focusOnMouseEvent(methodName, model);
         const element = this.getTargetElement(model, event);
         if (!element) {
@@ -74,7 +58,7 @@ export class RankingMouseTool extends MouseTool implements IMouseTool {
         this.notifyListenersByRank(element, methodName, model, event);
     }
 
-    async notifyListenersByRank<K extends keyof MouseListener>(
+    async notifyListenersByRank<K extends MouseListenerMethods>(
         element: SModelElement,
         methodName: K,
         model: SModelRoot,
@@ -85,19 +69,17 @@ export class RankingMouseTool extends MouseTool implements IMouseTool {
         }
     }
 
-    async dispatchActions<K extends keyof MouseListener>(
+    async dispatchActions<K extends MouseListenerMethods>(
         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));
+        const actions = mouseListeners.map(listener => listener[methodName](element, event as WheelEvent)).reduce((a, b) => a.concat(b));
         if (actions.length > 0) {
             event.preventDefault();
             for (const actionOrPromise of actions) {
-                if (isAction(actionOrPromise)) {
+                if (Action.is(actionOrPromise)) {
                     await this.actionDispatcher.dispatch(actionOrPromise);
                 } else {
                     actionOrPromise.then((action: Action) => {
@@ -124,24 +106,3 @@ function groupBy<K, T>(array: Array<T>, keyFunction: (x: T) => K): Map<K, T[]> {
     }, 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/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' };

package/src/features/navigation/navigation-target-resolver.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,16 +13,11 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import {
-    isSetResolvedNavigationTargets,
-    NavigationTarget,
-    ResolveNavigationTargetAction,
-    SetResolvedNavigationTargetAction
-} from '@eclipse-glsp/protocol';
+import { NavigationTarget, ResolveNavigationTargetAction, ResponseAction, SetResolvedNavigationTargetAction } from '@eclipse-glsp/protocol';
 import { inject, injectable } from 'inversify';
-import { IActionDispatcher, ILogger, ResponseAction, TYPES } from 'sprotty';
+import { IActionDispatcher, ILogger } from 'sprotty';
 import { EditorContextServiceProvider } from '../../base/editor-context-service';
-import { GLSP_TYPES } from '../../base/types';
+import { TYPES } from '../../base/types';
 
 /**
  * Resolves `NavigationTargets` to element ids.
@@ -32,7 +27,7 @@ import { GLSP_TYPES } from '../../base/types';
  */
 @injectable()
 export class NavigationTargetResolver {
-    @inject(GLSP_TYPES.IEditorContextServiceProvider) protected editorContextService: EditorContextServiceProvider;
+    @inject(TYPES.IEditorContextServiceProvider) protected editorContextService: EditorContextServiceProvider;
     @inject(TYPES.IActionDispatcher) protected dispatcher: IActionDispatcher;
     @inject(TYPES.ILogger) protected readonly logger: ILogger;
 
@@ -53,16 +48,16 @@ export class NavigationTargetResolver {
             return undefined;
         }
         if (NavigationTarget.getElementIds(target).length > 0) {
-            return new SetResolvedNavigationTargetAction(NavigationTarget.getElementIds(target));
+            return SetResolvedNavigationTargetAction.create(NavigationTarget.getElementIds(target));
         }
         const response = await this.requestResolution(target);
-        if (isSetResolvedNavigationTargets(response)) {
+        if (SetResolvedNavigationTargetAction.is(response)) {
             return response;
         }
         return undefined;
     }
 
     protected requestResolution(target: NavigationTarget): Promise<ResponseAction> {
-        return this.dispatcher.request(new ResolveNavigationTargetAction(target));
+        return this.dispatcher.request(ResolveNavigationTargetAction.create(target));
     }
 }

package/src/features/reconnect/model.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2019-2021 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
@@ -69,7 +69,7 @@ export function createReconnectHandle(edge: SRoutableElement, kind: RoutingHandl
 }
 
 export class SReconnectHandle extends SRoutingHandle {
-    hasFeature(feature: symbol): boolean {
+    override hasFeature(feature: symbol): boolean {
         return feature !== selectFeature && super.hasFeature(feature);
     }
 }

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

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2019-2021 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
@@ -14,8 +14,7 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 import { ContainerModule } from 'inversify';
-import { TYPES } from 'sprotty';
-
+import { TYPES } from '../../base/types';
 import { SaveModelKeyboardListener } from './save-keylistener';
 
 /**

package/src/features/save/save-keylistener.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2019-2021 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
@@ -18,9 +18,9 @@ import { KeyListener, SModelRoot } from 'sprotty';
 import { matchesKeystroke } from 'sprotty/lib/utils/keyboard';
 
 export class SaveModelKeyboardListener extends KeyListener {
-    keyDown(_element: SModelRoot, event: KeyboardEvent): Action[] {
+    override keyDown(_element: SModelRoot, event: KeyboardEvent): Action[] {
         if (matchesKeystroke(event, 'KeyS', 'ctrlCmd')) {
-            return [new SaveModelAction()];
+            return [SaveModelAction.create()];
         }
         return [];
     }

package/src/features/select/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
@@ -14,22 +14,20 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 import { ContainerModule } from 'inversify';
-import { configureCommand, TYPES } from 'sprotty';
-
-import { GLSP_TYPES } from '../../base/types';
-import { SelectAllFeedbackCommand, SelectFeedbackCommand } from './select-feedback-action';
+import { configureCommand } from 'sprotty';
+import { TYPES } from '../../base/types';
+import { SelectFeedbackCommand } from './select-feedback-action';
 import { RankedSelectMouseListener } from './select-mouse-listener';
 import { SelectAllCommand, SelectCommand, SelectionService } from './selection-service';
 
 const glspSelectModule = new ContainerModule((bind, _unbind, isBound) => {
     bind(SelectionService).toSelf().inSingletonScope();
-    bind(GLSP_TYPES.SelectionService).toService(SelectionService);
+    bind(TYPES.SelectionService).toService(SelectionService);
     configureCommand({ bind, isBound }, SelectCommand);
     configureCommand({ bind, isBound }, SelectAllCommand);
     configureCommand({ bind, isBound }, SelectFeedbackCommand);
-    configureCommand({ bind, isBound }, SelectAllFeedbackCommand);
     bind(TYPES.MouseListener).to(RankedSelectMouseListener);
-    bind(GLSP_TYPES.SModelRootListener).toService(SelectionService);
+    bind(TYPES.SModelRootListener).toService(SelectionService);
 });
 
 export default glspSelectModule;

package/src/features/select/select-feedback-action.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2019-2021 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
@@ -13,39 +13,34 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
+import { Action, hasArrayProp, SelectAction } from '@eclipse-glsp/protocol';
 import { inject, injectable } from 'inversify';
-import {
-    Command,
-    CommandExecutionContext,
-    SelectAllCommand as SprottySelectAllCommand,
-    SelectCommand as SprottySelectCommand,
-    SModelRoot,
-    TYPES
-} from 'sprotty';
+import { Command, CommandExecutionContext, SelectCommand as SprottySelectCommand, SModelRoot } from 'sprotty';
+import { TYPES } from '../../base/types';
 
-export class SelectFeedbackAction {
-    constructor(
-        public readonly selectedElementsIDs: string[] = [],
-        public readonly deselectedElementsIDs: string[] = [],
-        public readonly kind: string = SelectFeedbackCommand.KIND
-    ) {}
+export interface SelectFeedbackAction extends Omit<SelectAction, 'kind'>, Action {
+    kind: typeof SelectFeedbackAction.KIND;
 }
 
-export class SelectAllFeedbackAction {
-    /**
-     * If `select` is true, all elements are selected, othewise they are deselected.
-     */
-    constructor(public readonly select: boolean = true, public readonly kind: string = SelectFeedbackCommand.KIND) {}
-}
+export namespace SelectFeedbackAction {
+    export const KIND = 'selectFeedback';
+
+    export function is(object: any): object is SelectFeedbackAction {
+        return Action.hasKind(object, KIND) && hasArrayProp(object, 'selectedElementsIDs') && hasArrayProp(object, 'deselectedElementsIDs');
+    }
 
+    export function create(options?: { selectedElementsIDs?: string[]; deselectedElementsIDs?: string[] }): SelectFeedbackAction {
+        return { ...SelectAction.create(options), kind: KIND };
+    }
+}
 @injectable()
 export class SelectFeedbackCommand extends Command {
-    static readonly KIND = 'elementSelectedFeedback';
+    static readonly KIND = SelectFeedbackAction.KIND;
     private sprottySelectCommand: SprottySelectCommand;
 
     constructor(@inject(TYPES.Action) public action: SelectFeedbackAction) {
         super();
-        this.sprottySelectCommand = new SprottySelectCommand(action);
+        this.sprottySelectCommand = new SprottySelectCommand({ ...action, kind: SelectAction.KIND });
     }
 
     execute(context: CommandExecutionContext): SModelRoot {
@@ -60,26 +55,3 @@ export class SelectFeedbackCommand extends Command {
         return this.sprottySelectCommand.redo(context);
     }
 }
-
-@injectable()
-export class SelectAllFeedbackCommand extends Command {
-    static readonly KIND = 'allSelectedFeedback';
-    private sprottySelectAllCommand: SprottySelectAllCommand;
-
-    constructor(@inject(TYPES.Action) public action: SelectAllFeedbackAction) {
-        super();
-        this.sprottySelectAllCommand = new SprottySelectAllCommand(action);
-    }
-
-    execute(context: CommandExecutionContext): SModelRoot {
-        return this.sprottySelectAllCommand.execute(context);
-    }
-
-    undo(context: CommandExecutionContext): SModelRoot {
-        return this.sprottySelectAllCommand.undo(context);
-    }
-
-    redo(context: CommandExecutionContext): SModelRoot {
-        return this.sprottySelectAllCommand.redo(context);
-    }
-}