@eclipse-glsp/client 0.10.0-next.bb1c2fd.157 → 0.10.0-next.e5fcffe.169

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);
-    }
-}

package/src/features/select/select-mouse-listener.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,7 +14,6 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 import { SelectMouseListener } from 'sprotty';
-
 import { DEFAULT_RANK, Ranked } from '../rank/model';
 
 /**

package/src/features/select/selection-service.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
@@ -14,11 +14,11 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 /* eslint-disable import/no-deprecated,no-unused-expressions */
-import { Action } from '@eclipse-glsp/protocol';
+import { Action, SModelElementSchema } from '@eclipse-glsp/protocol';
 import { AssertionError, expect } from 'chai';
 import { Container, injectable } from 'inversify';
-import { defaultModule, SGraphFactory, SModelElementSchema, SModelRoot, TYPES } from 'sprotty';
-import { GLSP_TYPES } from '../../base/types';
+import { defaultModule, SGraphFactory, SModelRoot } from 'sprotty';
+import { TYPES } from '../../base/types';
 import { IFeedbackActionDispatcher, IFeedbackEmitter } from '../tool-feedback/feedback-action-dispatcher';
 import { SelectFeedbackAction } from './select-feedback-action';
 import { SelectionListener, SelectionService } from './selection-service';
@@ -74,14 +74,16 @@ class MockSelectionListener implements SelectionListener {
 function createContainer(): Container {
     const container = new Container();
     container.load(defaultModule);
+    // eslint-disable-next-line deprecation/deprecation
     container.rebind(TYPES.IModelFactory).to(SGraphFactory).inSingletonScope();
-    container.bind(GLSP_TYPES.IFeedbackActionDispatcher).to(MockFeedbackActionDispatcher).inSingletonScope();
+    container.bind(TYPES.IFeedbackActionDispatcher).to(MockFeedbackActionDispatcher).inSingletonScope();
     container.bind(SelectionService).toSelf().inSingletonScope();
-    container.bind(GLSP_TYPES.SelectionService).toService(SelectionService);
+    container.bind(TYPES.SelectionService).toService(SelectionService);
     return container;
 }
 
 describe('SelectionService', () => {
+    // eslint-disable-next-line deprecation/deprecation
     let graphFactory: SGraphFactory;
     let root: SModelRoot;
     let selectionService: SelectionService;
@@ -89,10 +91,11 @@ describe('SelectionService', () => {
 
     beforeEach(() => {
         const container = createContainer();
+        // eslint-disable-next-line deprecation/deprecation
         graphFactory = container.get<SGraphFactory>(TYPES.IModelFactory);
         root = createRoot('node1', 'node2', 'node3', 'node4', 'node5');
-        selectionService = container.get<SelectionService>(GLSP_TYPES.SelectionService);
-        feedbackDispatcher = container.get<MockFeedbackActionDispatcher>(GLSP_TYPES.IFeedbackActionDispatcher);
+        selectionService = container.get<SelectionService>(TYPES.SelectionService);
+        feedbackDispatcher = container.get<MockFeedbackActionDispatcher>(TYPES.IFeedbackActionDispatcher);
     });
 
     describe('Initial State', () => {

package/src/features/select/selection-service.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
@@ -20,17 +20,17 @@ import {
     CommandExecutionContext,
     ILogger,
     isSelectable,
-    isSelected,
     SChildElement,
+    Selectable,
     SelectAllCommand as SprottySelectAllCommand,
     SelectCommand as SprottySelectCommand,
     SModelElement,
     SModelRoot,
-    SParentElement,
-    TYPES
+    SParentElement
 } from 'sprotty';
 import { SModelRootListener } from '../../base/model/update-model-command';
-import { GLSP_TYPES } from '../../base/types';
+import { TYPES } from '../../base/types';
+import { getElements } from '../../utils/smodel-util';
 import { IFeedbackActionDispatcher } from '../tool-feedback/feedback-action-dispatcher';
 import { SelectFeedbackAction } from './select-feedback-action';
 
@@ -43,10 +43,10 @@ export class SelectionService implements SModelRootListener {
     private root: Readonly<SModelRoot>;
     private selectedElementIDs: Set<string> = new Set();
 
-    @inject(GLSP_TYPES.IFeedbackActionDispatcher) protected feedbackDispatcher: IFeedbackActionDispatcher;
+    @inject(TYPES.IFeedbackActionDispatcher) protected feedbackDispatcher: IFeedbackActionDispatcher;
     @inject(TYPES.ILogger) protected logger: ILogger;
 
-    constructor(@multiInject(GLSP_TYPES.SelectionListener) @optional() protected selectionListeners: SelectionListener[] = []) {}
+    constructor(@multiInject(TYPES.SelectionListener) @optional() protected selectionListeners: SelectionListener[] = []) {}
 
     register(selectionListener: SelectionListener): void {
         distinctAdd(this.selectionListeners, selectionListener);
@@ -100,7 +100,12 @@ export class SelectionService implements SModelRootListener {
             ![...prevSelectedElementIDs].every(value => this.selectedElementIDs.has(value));
         if (selectionChanged) {
             // aggregate to feedback action handling all elements as only the last feedback is restored
-            this.dispatchFeedback([new SelectFeedbackAction([...this.selectedElementIDs], [...deselectedElementIDs])]);
+            this.dispatchFeedback([
+                SelectFeedbackAction.create({
+                    selectedElementsIDs: [...this.selectedElementIDs],
+                    deselectedElementsIDs: [...deselectedElementIDs]
+                })
+            ]);
         }
 
         const rootChanged = prevRoot !== root;
@@ -122,8 +127,8 @@ export class SelectionService implements SModelRootListener {
         return this.root;
     }
 
-    getSelectedElements(): Readonly<SModelElement>[] {
-        return Array.from(this.root.index.all().filter(isSelected));
+    getSelectedElements(): Readonly<SModelElement & Selectable>[] {
+        return getElements(this.root.index, Array.from(this.selectedElementIDs), isSelectable);
     }
 
     /**
@@ -156,7 +161,7 @@ export class SelectCommand extends Command {
 
     constructor(
         @inject(TYPES.Action) public action: SelectAction,
-        @inject(GLSP_TYPES.SelectionService) public selectionService: SelectionService
+        @inject(TYPES.SelectionService) public selectionService: SelectionService
     ) {
         super();
     }
@@ -200,7 +205,7 @@ export class SelectAllCommand extends Command {
 
     constructor(
         @inject(TYPES.Action) public action: SelectAllAction,
-        @inject(GLSP_TYPES.SelectionService) public selectionService: SelectionService
+        @inject(TYPES.SelectionService) public selectionService: SelectionService
     ) {
         super();
     }