@eclipse-glsp/client 1.1.0-next.c40feb3.207 → 1.1.0-next.c5afbfa.273

package/src/base/selection-service.spec.ts

@@ -0,0 +1,297 @@
+/********************************************************************************
+ * Copyright (c) 2020-2023 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 { AssertionError, expect } from 'chai';
+import { Container, injectable } from 'inversify';
+import * as sinon from 'sinon';
+import { Action, Disposable, SGraphFactory, SModelElementSchema, SModelRoot, TYPES, initializeContainer } from '~glsp-sprotty';
+import { defaultModule } from './default.module';
+import { IFeedbackActionDispatcher, IFeedbackEmitter } from './feedback/feedback-action-dispatcher';
+import { ISelectionListener, SelectFeedbackAction, SelectionService } from './selection-service';
+
+@injectable()
+class MockFeedbackActionDispatcher implements IFeedbackActionDispatcher {
+    protected feedbackEmitters: Map<IFeedbackEmitter, Action[]> = new Map();
+
+    registerFeedback(feedbackEmitter: IFeedbackEmitter, actions: Action[]): Disposable {
+        this.feedbackEmitters.set(feedbackEmitter, actions);
+        return Disposable.create(() => this.deregisterFeedback(feedbackEmitter));
+    }
+
+    deregisterFeedback(feedbackEmitter: IFeedbackEmitter, _actions?: Action[]): void {
+        this.feedbackEmitters.delete(feedbackEmitter);
+    }
+
+    getRegisteredFeedback(): Action[] {
+        const result: Action[] = [];
+        this.feedbackEmitters.forEach((value, key) => result.push(...value));
+        return result;
+    }
+
+    getSingleFeedbackAction(): SelectFeedbackAction | undefined {
+        const actions = this.getRegisteredFeedback();
+        return actions.length === 1 ? (actions[0] as SelectFeedbackAction) : undefined;
+    }
+}
+
+class MockSelectionListener implements ISelectionListener {
+    selectionChanged(root: Readonly<SModelRoot>, selectedElements: string[], deselectedElements: string[] | undefined): void {
+        // no.op
+    }
+}
+
+function createContainer(): Container {
+    const container = initializeContainer(new Container(), defaultModule);
+    // eslint-disable-next-line deprecation/deprecation
+    container.rebind(TYPES.IModelFactory).to(SGraphFactory).inSingletonScope();
+    container.rebind(TYPES.IFeedbackActionDispatcher).to(MockFeedbackActionDispatcher).inSingletonScope();
+    return container;
+}
+
+describe('SelectionService', () => {
+    // eslint-disable-next-line deprecation/deprecation
+    let graphFactory: SGraphFactory;
+    let root: SModelRoot;
+    let selectionService: SelectionService;
+    let feedbackDispatcher: MockFeedbackActionDispatcher;
+
+    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>(SelectionService);
+        feedbackDispatcher = container.get<MockFeedbackActionDispatcher>(TYPES.IFeedbackActionDispatcher);
+    });
+
+    describe('Initial State', () => {
+        it('On creation nothing should be selected and no feedback should be dispatched.', () => {
+            assertSelectionAndFeedback([], []);
+        });
+    });
+    describe('Single Selection', () => {
+        it('Selecting a single element should be tracked correctly and trigger feedback.', () => {
+            assertSelectionAndFeedback([], []);
+            selectionService.updateSelection(root, ['node1'], []);
+            assertSelectionAndFeedback(['node1'], []);
+        });
+        it('Selecting the same element twice in one operation should not make a difference.', () => {
+            assertSelectionAndFeedback([], []);
+            selectionService.updateSelection(root, ['node1', 'node1'], []);
+            assertSelectionAndFeedback(['node1'], []);
+        });
+        it('Selecting and then deselecting the same element should result in an empty selection.', () => {
+            assertSelectionAndFeedback([], []);
+            selectionService.updateSelection(root, ['node1'], []);
+            selectionService.updateSelection(root, [], ['node1']);
+            assertSelectionAndFeedback([], ['node1']);
+        });
+        it('Selecting and deselecting the same element in the same operation should have no effect.', () => {
+            assertSelectionAndFeedback([], []);
+            selectionService.updateSelection(root, ['node1'], ['node1']);
+            assertSelectionAndFeedback([], []);
+        });
+        it('Selecting and deselecting not-existing nodes should have no effect.', () => {
+            assertSelectionAndFeedback([], []);
+            selectionService.updateSelection(root, ['not-existing'], []);
+            assertSelectionAndFeedback([], []);
+            selectionService.updateSelection(root, [], ['not-existing']);
+            assertSelectionAndFeedback([], []);
+        });
+    });
+    describe('Multi Selection', () => {
+        it('Selecting multiple elements should be tracked correctly and trigger feedback.', () => {
+            assertSelectionAndFeedback([], []);
+            selectionService.updateSelection(root, ['node1', 'node2'], []);
+            assertSelectionAndFeedback(['node1', 'node2'], []);
+        });
+        it('Selecting multiple elements should have the selection order in the dispatched feedback.', () => {
+            assertSelectionAndFeedback([], []);
+            selectionService.updateSelection(root, ['node2', 'node1'], []);
+            expect(() => assertSelectionAndFeedback(['node1', 'node2'], [])).to.throw(AssertionError, 'ordered members');
+        });
+        it('Selecting the same elements twice in one operation should not make a difference.', () => {
+            assertSelectionAndFeedback([], []);
+            selectionService.updateSelection(root, ['node1', 'node1', 'node2', 'node2'], []);
+            assertSelectionAndFeedback(['node1', 'node2'], []);
+        });
+        it('Selecting and then deselecting the same elements should result in an empty selection.', () => {
+            assertSelectionAndFeedback([], []);
+            selectionService.updateSelection(root, ['node1', 'node2'], []);
+            selectionService.updateSelection(root, [], ['node1', 'node2']);
+            assertSelectionAndFeedback([], ['node1', 'node2']);
+        });
+        it('Selecting and deselecting the same elements in one operation should have no effect.', () => {
+            assertSelectionAndFeedback([], []);
+            selectionService.updateSelection(root, ['node1', 'node2'], ['node1', 'node2']);
+            assertSelectionAndFeedback([], []);
+            selectionService.updateSelection(root, ['node1', 'node2', 'node3'], ['node1', 'node2']);
+            assertSelectionAndFeedback(['node3'], []);
+        });
+        it('Selecting three elements and deselecting one should result in two selected and one deselected element.', () => {
+            assertSelectionAndFeedback([], []);
+            selectionService.updateSelection(root, ['node1', 'node2', 'node3'], []);
+            assertSelectionAndFeedback(['node1', 'node2', 'node3'], []);
+            selectionService.updateSelection(root, [], ['node2']);
+            assertSelectionAndFeedback(['node1', 'node3'], ['node2']);
+        });
+        it('A series of selection and deselection operations should be tracked correctly.', () => {
+            assertSelectionAndFeedback([], []);
+            selectionService.updateSelection(root, ['node1', 'node2', 'node3'], []);
+            assertSelectionAndFeedback(['node1', 'node2', 'node3'], []);
+            selectionService.updateSelection(root, ['node4'], ['node2']);
+            assertSelectionAndFeedback(['node1', 'node3', 'node4'], ['node2']);
+            selectionService.updateSelection(root, ['node3', 'node1'], ['node2', 'node4']);
+            assertSelectionAndFeedback(['node1', 'node3'], ['node4']);
+            selectionService.updateSelection(root, ['node3'], ['node3']);
+            assertSelectionAndFeedback(['node1', 'node3'], ['node4']);
+        });
+    });
+    describe('Changing Root', () => {
+        it('Changing root deselects all selected elements if there are no matching elements.', () => {
+            assertSelectionAndFeedback([], []);
+            selectionService.updateSelection(root, ['node1'], []);
+            assertSelectionAndFeedback(['node1'], []);
+
+            const newRoot = createRoot('newNode1', 'newNode2', 'newNode3');
+            selectionService.modelRootChanged(newRoot);
+            assertSelectionAndFeedback([], ['node1']);
+        });
+        it('Changing root keeps selected elements if there are matching elements.', () => {
+            assertSelectionAndFeedback([], []);
+            selectionService.updateSelection(root, ['node1', 'node2'], []);
+            assertSelectionAndFeedback(['node1', 'node2'], []);
+
+            const newRoot = createRoot('node1', 'newNode2', 'newNode3');
+            selectionService.modelRootChanged(newRoot);
+            assertSelectionAndFeedback(['node1'], ['node2']);
+        });
+        it('Changing root with new selection correctly selects matching elements and deselects not matching elements.', () => {
+            assertSelectionAndFeedback([], []);
+            selectionService.updateSelection(root, ['node1', 'node2'], []);
+            assertSelectionAndFeedback(['node1', 'node2'], []);
+
+            const newRoot = createRoot('newNode1', 'newNode2', 'newNode3');
+            selectionService.updateSelection(newRoot, ['newNode1'], []);
+            assertSelectionAndFeedback(['newNode1'], ['node1', 'node2']);
+        });
+    });
+    describe('Listeners', () => {
+        const sandbox = sinon.createSandbox();
+        const listener = sandbox.createStubInstance(MockSelectionListener);
+
+        beforeEach(() => {
+            selectionService.onSelectionChanged(change =>
+                listener.selectionChanged(change.root, change.selectedElements, change.deselectedElements)
+            );
+        });
+
+        afterEach(() => {
+            selectionService.dispose();
+            sandbox.reset();
+        });
+        it('A registered listener should be notified of a single selection change.', () => {
+            selectionService.updateSelection(root, ['node1', 'node1'], []);
+            assertListener(listener, root, ['node1'], [], 1);
+        });
+        it('A registered listener should be notified of a multi-selection change.', () => {
+            selectionService.updateSelection(root, ['node1', 'node2', 'node3'], []);
+            assertListener(listener, root, ['node1', 'node2', 'node3'], [], 1);
+        });
+        it('A registered listener should be notified of series of selection changes.', () => {
+            selectionService.updateSelection(root, ['node1'], []);
+            assertListener(listener, root, ['node1'], [], 1);
+            selectionService.updateSelection(root, ['node2'], ['node1']);
+            assertListener(listener, root, ['node2'], ['node1'], 2);
+            selectionService.updateSelection(root, ['node3', 'node4'], []);
+            assertListener(listener, root, ['node2', 'node3', 'node4'], [], 3);
+            selectionService.updateSelection(root, [], ['node4']);
+            assertListener(listener, root, ['node2', 'node3'], ['node4'], 4);
+        });
+        it('A registered listener should be notified of root changes.', () => {
+            selectionService.updateSelection(root, [], []);
+            assertListener(listener, root, [], [], 1);
+
+            const newRoot = createRoot('node1', 'newNode2', 'newNode3');
+            selectionService.updateSelection(newRoot, [], []);
+            assertListener(listener, newRoot, [], [], 2);
+        });
+        it('Selecting the same elements consecutively should not trigger a listener update.', () => {
+            selectionService.updateSelection(root, ['node1'], []);
+            assertListener(listener, root, ['node1'], [], 1);
+            selectionService.updateSelection(root, ['node1'], []);
+            assertListener(listener, root, ['node1'], [], 1);
+        });
+        it('Selecting a not-existing elements should not trigger a listener update.', () => {
+            selectionService.updateSelection(root, ['node1'], []);
+            assertListener(listener, root, ['node1'], [], 1);
+            selectionService.updateSelection(root, ['not-existing'], []);
+            assertListener(listener, root, ['node1'], [], 1);
+        });
+    });
+
+    function createRoot(...nodes: string[]): SModelRoot {
+        const children: SModelElementSchema[] = [];
+        nodes.forEach(node => children.push({ id: node, type: 'node:circle' }));
+        return graphFactory.createRoot({
+            id: 'selection-service-spec',
+            type: 'graph',
+            children: children
+        });
+    }
+
+    function assertSelectionAndFeedback(expectedSelection: string[], expectedDeselection: string[]): void {
+        assertSelectionService(expectedSelection);
+        assertDispatchedFeedback(expectedSelection, expectedDeselection);
+    }
+
+    function assertSelectionService(expectedSelection: string[]): void {
+        expect(selectionService.isSingleSelection()).to.equal(expectedSelection.length === 1);
+        expect(selectionService.isMultiSelection()).to.equal(expectedSelection.length > 1);
+        expect(selectionService.hasSelectedElements()).to.equal(expectedSelection.length > 0);
+        expect(selectionService.getSelectedElementIDs()).to.have.lengthOf(expectedSelection.length);
+        if (expectedSelection.length > 0) {
+            expect(selectionService.getSelectedElementIDs()).to.have.ordered.members(expectedSelection);
+        }
+    }
+
+    function assertDispatchedFeedback(expectedSelection: string[], expectedDeselection: string[]): void {
+        // a single feedback action reflects aggregated selection/deselection
+        const hasFeedback = expectedSelection.length > 0 || expectedDeselection.length > 0;
+        if (hasFeedback) {
+            expect(feedbackDispatcher.getRegisteredFeedback()).to.have.lengthOf(1);
+            expect(feedbackDispatcher.getSingleFeedbackAction()!.selectedElementsIDs).to.have.lengthOf(expectedSelection.length);
+            expect(feedbackDispatcher.getSingleFeedbackAction()!.selectedElementsIDs).to.have.ordered.members(expectedSelection);
+            expect(feedbackDispatcher.getSingleFeedbackAction()!.deselectedElementsIDs).to.have.lengthOf(expectedDeselection.length);
+            expect(feedbackDispatcher.getSingleFeedbackAction()!.deselectedElementsIDs).to.have.ordered.members(expectedDeselection);
+        } else {
+            expect(feedbackDispatcher.getRegisteredFeedback()).to.have.lengthOf(0);
+            expect(feedbackDispatcher.getSingleFeedbackAction()).to.be.undefined;
+        }
+    }
+
+    function assertListener(
+        listener: sinon.SinonStubbedInstance<MockSelectionListener>,
+        expectedRoot: SModelRoot | undefined,
+        expectedSelection: string[],
+        expectedDeselection: string[],
+        expectedCalled: number
+    ): void {
+        expect(listener.selectionChanged.callCount).to.be.equal(expectedCalled);
+        expect(listener.selectionChanged.lastCall.args[0]).to.be.deep.equals(expectedRoot);
+        expect(listener.selectionChanged.lastCall.args[1]).to.be.deep.equals(expectedSelection);
+        expect(listener.selectionChanged.lastCall.args[2]).to.be.deep.equals(expectedDeselection);
+    }
+});

package/src/base/selection-service.ts

@@ -0,0 +1,293 @@
+/********************************************************************************
+ * Copyright (c) 2019-2023 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, multiInject, optional, postConstruct, preDestroy } from 'inversify';
+import {
+    Action,
+    Command,
+    CommandExecutionContext,
+    Disposable,
+    DisposableCollection,
+    Emitter,
+    Event,
+    ILogger,
+    SChildElement,
+    SModelElement,
+    SModelRoot,
+    SelectAction,
+    SelectAllAction,
+    Selectable,
+    SprottySelectAllCommand,
+    SprottySelectCommand,
+    TYPES,
+    hasArrayProp,
+    isSelectable,
+    pluck
+} from '~glsp-sprotty';
+import { getElements, getMatchingElements } from '../utils/smodel-util';
+import { ISModelRootListener } from './command-stack';
+import { IFeedbackActionDispatcher } from './feedback/feedback-action-dispatcher';
+
+export interface ISelectionListener {
+    selectionChanged(root: Readonly<SModelRoot>, selectedElements: string[], deselectedElements?: string[]): void;
+}
+
+export interface SelectionChange {
+    root: Readonly<SModelRoot>;
+    selectedElements: string[];
+    deselectedElements: string[];
+}
+
+@injectable()
+export class SelectionService implements ISModelRootListener, Disposable {
+    protected root: Readonly<SModelRoot>;
+    protected selectedElementIDs: Set<string> = new Set();
+
+    @inject(TYPES.IFeedbackActionDispatcher)
+    protected feedbackDispatcher: IFeedbackActionDispatcher;
+
+    @inject(TYPES.ILogger)
+    protected logger: ILogger;
+
+    @multiInject(TYPES.ISelectionListener)
+    @optional()
+    protected selectionListeners: ISelectionListener[] = [];
+
+    protected toDispose = new DisposableCollection();
+
+    @postConstruct()
+    protected initialize(): void {
+        this.toDispose.push(this.onSelectionChangedEmitter);
+        this.selectionListeners.forEach(listener =>
+            this.onSelectionChanged(change => listener.selectionChanged(change.root, change.selectedElements, change.deselectedElements))
+        );
+    }
+
+    @preDestroy()
+    dispose(): void {
+        this.toDispose.dispose();
+    }
+
+    protected onSelectionChangedEmitter = new Emitter<SelectionChange>();
+    get onSelectionChanged(): Event<SelectionChange> {
+        return this.onSelectionChangedEmitter.event;
+    }
+
+    modelRootChanged(root: Readonly<SModelRoot>): void {
+        this.updateSelection(root, [], []);
+    }
+
+    updateSelection(root: Readonly<SModelRoot>, select: string[], deselect: string[]): void {
+        if (root === undefined && select.length === 0 && deselect.length === 0) {
+            return;
+        }
+        const prevRoot = this.root;
+        const prevSelectedElementIDs = new Set(this.selectedElementIDs);
+
+        // update root
+        this.root = root;
+
+        // update selected element IDs and collect deselected elements
+        // - select all elements that are not deselected at the same time (no-op)
+        // - deselect all elements that are not selected at the same time (no-op) but was selected
+        const toSelect = [...select].filter(selectId => deselect.indexOf(selectId) === -1);
+        const toDeselect = [...deselect].filter(deselectId => select.indexOf(deselectId) === -1 && this.selectedElementIDs.has(deselectId));
+        for (const id of toDeselect) {
+            this.selectedElementIDs.delete(id);
+        }
+        for (const id of toSelect) {
+            this.selectedElementIDs.add(id);
+        }
+
+        const deselectedElementIDs = new Set(toDeselect);
+        // see if selected elements still exist in the updated root
+        for (const id of this.selectedElementIDs) {
+            const element = root.index.getById(id);
+            if (element === undefined) {
+                this.selectedElementIDs.delete(id);
+                if (prevRoot !== undefined && prevRoot.index.getById(id)) {
+                    deselectedElementIDs.add(id);
+                }
+            }
+        }
+
+        // only send out changes if there actually are changes, i.e., the root or the selected elements changed
+        const selectionChanged =
+            prevSelectedElementIDs.size !== this.selectedElementIDs.size ||
+            ![...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([
+                SelectFeedbackAction.create({
+                    selectedElementsIDs: [...this.selectedElementIDs],
+                    deselectedElementsIDs: [...deselectedElementIDs]
+                })
+            ]);
+        }
+
+        const rootChanged = prevRoot !== root;
+        if (rootChanged || selectionChanged) {
+            // notify listeners after the feedback action
+            this.notifyListeners(this.root, this.selectedElementIDs, deselectedElementIDs);
+        }
+    }
+
+    dispatchFeedback(actions: Action[]): void {
+        this.feedbackDispatcher.registerFeedback(this, actions);
+    }
+
+    notifyListeners(root: SModelRoot, selectedElementIDs: Set<string>, deselectedElementIDs: Set<string>): void {
+        this.onSelectionChangedEmitter.fire({
+            root,
+            selectedElements: Array.from(selectedElementIDs),
+            deselectedElements: Array.from(deselectedElementIDs)
+        });
+    }
+
+    getModelRoot(): Readonly<SModelRoot> {
+        return this.root;
+    }
+
+    getSelectedElements(): Readonly<SModelElement & Selectable>[] {
+        return !this.root ? [] : getElements(this.root.index, Array.from(this.selectedElementIDs), isSelectable);
+    }
+
+    /**
+     * QUERY METHODS
+     */
+
+    getSelectedElementIDs(): string[] {
+        return [...this.selectedElementIDs];
+    }
+
+    hasSelectedElements(): boolean {
+        return this.selectedElementIDs.size > 0;
+    }
+
+    isSingleSelection(): boolean {
+        return this.selectedElementIDs.size === 1;
+    }
+
+    isMultiSelection(): boolean {
+        return this.selectedElementIDs.size > 1;
+    }
+}
+
+/**
+ * Handles a {@link SelectAction} and propagates the new selection to the {@link SelectionService}.
+ * Other tools might be selection-sensitive which means {@link SelectAction}s must be processed as fast as possible.
+ * Handling the action with a command ensures that the action is processed before the next render tick.
+ */
+@injectable()
+export class SelectCommand extends Command {
+    static readonly KIND = SprottySelectCommand.KIND;
+
+    protected selected: SModelElement[] = [];
+    protected deselected: SModelElement[] = [];
+
+    constructor(@inject(TYPES.Action) public action: SelectAction, @inject(SelectionService) public selectionService: SelectionService) {
+        super();
+    }
+
+    execute(context: CommandExecutionContext): SModelRoot {
+        const model = context.root;
+        const selectionGuard = (element: any): element is SModelElement => element instanceof SChildElement && isSelectable(element);
+        const selectedElements = getElements(model.index, this.action.selectedElementsIDs, selectionGuard);
+        const deselectedElements = this.action.deselectAll
+            ? this.selectionService.getSelectedElements()
+            : getElements(model.index, this.action.deselectedElementsIDs, selectionGuard);
+
+        this.selectionService.updateSelection(model, pluck(selectedElements, 'id'), pluck(deselectedElements, 'id'));
+        return model;
+    }
+
+    // Basically no-op since client-side undo is not supported in GLSP.
+    undo(context: CommandExecutionContext): SModelRoot {
+        return context.root;
+    }
+
+    // Basically no-op since client-side redo is not supported in GLSP.
+    redo(context: CommandExecutionContext): SModelRoot {
+        return context.root;
+    }
+}
+
+/**
+ * Handles a {@link SelectAllAction} and propagates the new selection to the {@link SelectionService}.
+ * Other tools might be selection-sensitive which means {@link SelectionAllAction}s must be processed as fast as possible.
+ * Handling the action with a command ensures that the action is processed before the next render tick.
+ */
+@injectable()
+export class SelectAllCommand extends Command {
+    static readonly KIND = SprottySelectAllCommand.KIND;
+    protected previousSelection: Map<string, boolean> = new Map<string, boolean>();
+
+    constructor(@inject(TYPES.Action) public action: SelectAllAction, @inject(SelectionService) public selectionService: SelectionService) {
+        super();
+    }
+
+    execute(context: CommandExecutionContext): SModelRoot {
+        const model = context.root;
+        const selectionGuard = (element: any): element is SModelElement => element instanceof SChildElement && isSelectable(element);
+
+        const selectables = getMatchingElements(model.index, selectionGuard);
+        const selectableIds = pluck(selectables, 'id');
+        if (this.action.select) {
+            this.selectionService.updateSelection(model, selectableIds, []);
+        } else {
+            this.selectionService.updateSelection(model, [], selectableIds);
+        }
+
+        return model;
+    }
+
+    // Basically no-op since client-side undo is not supported in GLSP.
+    undo(context: CommandExecutionContext): SModelRoot {
+        return context.root;
+    }
+
+    // Basically no-op since client-side redo is not supported in GLSP.
+    redo(context: CommandExecutionContext): SModelRoot {
+        return context.root;
+    }
+}
+
+export interface SelectFeedbackAction extends Omit<SelectAction, 'kind'>, Action {
+    kind: typeof SelectFeedbackAction.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[] | boolean }): SelectFeedbackAction {
+        return { ...SelectAction.create(options), kind: KIND };
+    }
+
+    export function addSelection(selectedElementsIDs: string[]): SelectFeedbackAction {
+        return { ...SelectAction.addSelection(selectedElementsIDs), kind: KIND };
+    }
+
+    export function removeSelection(deselectedElementsIDs: string[]): SelectFeedbackAction {
+        return { ...SelectAction.removeSelection(deselectedElementsIDs), kind: KIND };
+    }
+
+    export function setSelection(selectedElementsIDs: string[]): SelectFeedbackAction {
+        return { ...SelectAction.setSelection(selectedElementsIDs), kind: KIND };
+    }
+}