@eclipse-glsp/client 0.10.0-next.ca17587.154 → 1.1.0-RC01

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
@@ -13,8 +13,21 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { SelectMouseListener } from 'sprotty';
-
+import { Action, SelectAction } from '@eclipse-glsp/protocol';
+import {
+    BringToFrontAction,
+    findParentByFeature,
+    isCtrlOrCmd,
+    isSelectable,
+    SButton,
+    SelectMouseListener,
+    SModelElement,
+    SModelRoot,
+    SRoutableElement,
+    SRoutingHandle,
+    SwitchEditModeAction
+} from 'sprotty';
+import { toArray } from 'sprotty/lib/utils/iterable';
 import { DEFAULT_RANK, Ranked } from '../rank/model';
 
 /**
@@ -23,4 +36,70 @@ import { DEFAULT_RANK, Ranked } from '../rank/model';
  */
 export class RankedSelectMouseListener extends SelectMouseListener implements Ranked {
     rank: number = DEFAULT_RANK - 1; /* we want to be executed before all default mouse listeners */
+
+    override mouseDown(target: SModelElement, event: MouseEvent): Action[] {
+        const result: Action[] = [];
+        if (this.buttonHandlerRegistry !== undefined && target instanceof SButton && target.enabled) {
+            const buttonHandler = this.buttonHandlerRegistry.get(target.type);
+            if (buttonHandler !== undefined) {
+                return buttonHandler.buttonPressed(target);
+            }
+        }
+        const selectableTarget = findParentByFeature(target, isSelectable);
+        if (selectableTarget !== undefined || target instanceof SModelRoot) {
+            this.hasDragged = false;
+            let deselect: SModelElement[] = [];
+            // multi-selection?
+            if (!isCtrlOrCmd(event)) {
+                deselect = toArray(
+                    target.root.index
+                        .all()
+                        .filter(
+                            element =>
+                                isSelectable(element) &&
+                                element.selected &&
+                                !(selectableTarget instanceof SRoutingHandle && element === (selectableTarget.parent as SModelElement))
+                        )
+                );
+            }
+            if (selectableTarget !== undefined) {
+                if (!selectableTarget.selected) {
+                    this.wasSelected = false;
+                    result.push(
+                        SelectAction.create({
+                            selectedElementsIDs: [selectableTarget.id],
+                            deselectedElementsIDs: deselect.map(e => e.id)
+                        })
+                    );
+                    result.push(BringToFrontAction.create([selectableTarget.id]));
+                    const routableDeselect = deselect.filter(e => e instanceof SRoutableElement).map(e => e.id);
+                    if (selectableTarget instanceof SRoutableElement) {
+                        result.push(
+                            SwitchEditModeAction.create({
+                                elementsToActivate: [selectableTarget.id],
+                                elementsToDeactivate: routableDeselect
+                            })
+                        );
+                    } else if (routableDeselect.length > 0) {
+                        result.push(SwitchEditModeAction.create({ elementsToDeactivate: routableDeselect }));
+                    }
+                } else if (isCtrlOrCmd(event)) {
+                    this.wasSelected = false;
+                    result.push(SelectAction.create({ deselectedElementsIDs: [selectableTarget.id] }));
+                    if (selectableTarget instanceof SRoutableElement) {
+                        result.push(SwitchEditModeAction.create({ elementsToDeactivate: [selectableTarget.id] }));
+                    }
+                } else {
+                    this.wasSelected = true;
+                }
+            } else {
+                result.push(SelectAction.create({ deselectedElementsIDs: deselect.map(e => e.id) }));
+                const routableDeselect = deselect.filter(e => e instanceof SRoutableElement).map(e => e.id);
+                if (routableDeselect.length > 0) {
+                    result.push(SwitchEditModeAction.create({ elementsToDeactivate: routableDeselect }));
+                }
+            }
+        }
+        return result;
+    }
 }

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', () => {
@@ -344,7 +347,7 @@ describe('SelectionService', () => {
         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.all.keys(...expectedSelection);
+            expect(selectionService.getSelectedElementIDs()).to.have.ordered.members(expectedSelection);
         }
     }
 

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
@@ -13,24 +13,23 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { Action, distinctAdd, remove, SelectAction, SelectAllAction } from '@eclipse-glsp/protocol';
+import { Action, distinctAdd, pluck, remove, SelectAction, SelectAllAction } from '@eclipse-glsp/protocol';
 import { inject, injectable, multiInject, optional } from 'inversify';
 import {
     Command,
     CommandExecutionContext,
     ILogger,
     isSelectable,
-    isSelected,
     SChildElement,
+    Selectable,
     SelectAllCommand as SprottySelectAllCommand,
     SelectCommand as SprottySelectCommand,
     SModelElement,
-    SModelRoot,
-    SParentElement,
-    TYPES
+    SModelRoot
 } from 'sprotty';
 import { SModelRootListener } from '../../base/model/update-model-command';
-import { GLSP_TYPES } from '../../base/types';
+import { TYPES } from '../../base/types';
+import { getElements, getMatchingElements } from '../../utils/smodel-util';
 import { IFeedbackActionDispatcher } from '../tool-feedback/feedback-action-dispatcher';
 import { SelectFeedbackAction } from './select-feedback-action';
 
@@ -43,10 +42,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 +99,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,16 +126,16 @@ 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);
     }
 
     /**
      * QUERY METHODS
      */
 
-    getSelectedElementIDs(): Set<string> {
-        return this.selectedElementIDs;
+    getSelectedElementIDs(): string[] {
+        return [...this.selectedElementIDs];
     }
 
     hasSelectedElements(): boolean {
@@ -147,6 +151,11 @@ export class SelectionService implements SModelRootListener {
     }
 }
 
+/**
+ * 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;
@@ -156,43 +165,37 @@ 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();
     }
 
     execute(context: CommandExecutionContext): SModelRoot {
         const model = context.root;
-        this.action.selectedElementsIDs.forEach(id => {
-            const element = model.index.getById(id);
-            if (element instanceof SChildElement && isSelectable(element)) {
-                this.selected.push(element);
-            }
-        });
-        this.action.deselectedElementsIDs.forEach(id => {
-            const element = model.index.getById(id);
-            if (element instanceof SChildElement && isSelectable(element)) {
-                this.deselected.push(element);
-            }
-        });
-        return this.redo(context);
+        const selectionGuard = (element: any): element is SModelElement => element instanceof SChildElement && isSelectable(element);
+        const selectedElements = getElements(model.index, this.action.selectedElementsIDs, selectionGuard);
+        const deselectedElements = 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 {
-        const select = this.deselected.map(element => element.id);
-        const deselect = this.selected.map(element => element.id);
-        this.selectionService.updateSelection(context.root, select, deselect);
         return context.root;
     }
 
+    // Basically no-op since client-side redo is not supported in GLSP.
     redo(context: CommandExecutionContext): SModelRoot {
-        const select = this.selected.map(element => element.id);
-        const deselect = this.deselected.map(element => element.id);
-        this.selectionService.updateSelection(context.root, select, deselect);
         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;
@@ -200,44 +203,33 @@ 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();
     }
 
     execute(context: CommandExecutionContext): SModelRoot {
-        return this.redo(context);
+        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 {
-        const index = context.root.index;
-        for (const previousState of this.previousSelection) {
-            const element = index.getById(previousState[0]);
-            if (element !== undefined && isSelectable(element)) {
-                element.selected = previousState[1];
-            }
-        }
         return context.root;
     }
 
+    // Basically no-op since client-side redo is not supported in GLSP.
     redo(context: CommandExecutionContext): SModelRoot {
-        const selectables: string[] = [];
-        this.selectAll(context.root, this.action.select, selectables);
-        if (this.action.select) {
-            this.selectionService.updateSelection(context.root, selectables, []);
-        } else {
-            this.selectionService.updateSelection(context.root, [], selectables);
-        }
         return context.root;
     }
-
-    protected selectAll(element: SParentElement, newState: boolean, selected: string[]): void {
-        if (isSelectable(element)) {
-            this.previousSelection.set(element.id, element.selected);
-            selected.push(element.id);
-        }
-        for (const child of element.children) {
-            this.selectAll(child, newState, selected);
-        }
-    }
 }

package/src/features/{model-source-watcher → source-model-watcher}/di.config.ts

@@ -13,13 +13,13 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { ModelSourceChangedAction } from '@eclipse-glsp/protocol';
+import { SourceModelChangedAction } from '@eclipse-glsp/protocol';
 import { ContainerModule } from 'inversify';
 import { configureActionHandler } from 'sprotty';
-import { ModelSourceChangedActionHandler } from './model-source-changed-action-handler';
+import { SourceModelChangedActionHandler } from './source-model-changed-action-handler';
 
-const modelSourceWatcherModule = new ContainerModule((bind, _unbind, isBound) => {
-    configureActionHandler({ bind, isBound }, ModelSourceChangedAction.KIND, ModelSourceChangedActionHandler);
+const sourceModelWatcherModule = new ContainerModule((bind, _unbind, isBound) => {
+    configureActionHandler({ bind, isBound }, SourceModelChangedAction.KIND, SourceModelChangedActionHandler);
 });
 
-export default modelSourceWatcherModule;
+export default sourceModelWatcherModule;

package/src/features/{model-source-watcher/model-source-changed-action-handler.ts → source-model-watcher/source-model-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,48 +13,43 @@
  *
  * 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, ServerMessageAction, ServerStatusAction, SourceModelChangedAction } 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.
+ * An external handler of the source model change event.
  *
  * This allows external applications to react specifically to this event, e.g. by bringing up the diagram,
  * check their dirty state, show a dialog, etc.
  */
 @injectable()
-export abstract class ExternalModelSourceChangedHandler {
+export abstract class ExternalSourceModelChangedHandler {
     /**
-     * Notifies about a change of the model source.
+     * Notifies about a change of the source model.
      * @returns actions to be dispatched after the notification.
      */
-    abstract notifyModelSourceChange(modelSourceName: string, options: ViewerOptions): Promise<Action[]>;
+    abstract notifySourceModelChange(sourceModelName: string, options: ViewerOptions): Promise<Action[]>;
 }
 
 @injectable()
-export class ModelSourceChangedActionHandler implements IActionHandler {
+export class SourceModelChangedActionHandler implements IActionHandler {
     @inject(TYPES.IActionDispatcher)
     protected dispatcher: IActionDispatcher;
 
     @inject(TYPES.ViewerOptions)
     protected options: ViewerOptions;
 
-    @inject(ExternalModelSourceChangedHandler)
+    @inject(ExternalSourceModelChangedHandler)
     @optional()
-    protected externalModelSourceChangedHandler?: ExternalModelSourceChangedHandler;
+    protected externalModelSourceChangedHandler?: ExternalSourceModelChangedHandler;
 
     handle(action: Action): void {
-        if (isModelSourceChangedAction(action)) {
+        if (SourceModelChangedAction.is(action)) {
             if (this.externalModelSourceChangedHandler) {
                 this.externalModelSourceChangedHandler
-                    .notifyModelSourceChange(action.modelSourceName, this.options)
+                    .notifySourceModelChange(action.sourceModelName, this.options)
                     .then(actions => this.dispatcher.dispatchAll(actions));
                 return;
             }
@@ -62,13 +57,13 @@ export class ModelSourceChangedActionHandler implements IActionHandler {
         }
     }
 
-    protected showSimpleNotification(action: ModelSourceChangedAction): void {
-        const message = `The model source ${action.modelSourceName} has changed. You might want to consider reloading.`;
+    protected showSimpleNotification(action: SourceModelChangedAction): void {
+        const message = `The source model ${action.sourceModelName} has changed. You might want to consider reloading.`;
         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 })
         ]);
     }
 }