@eclipse-glsp/client 1.1.0-next.35bf56e.230 → 1.1.0-next.36bcf27.277

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

package/src/base/tool-manager/tool-manager.ts

@@ -0,0 +1,183 @@
+/********************************************************************************
+ * 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 } from 'inversify';
+import {
+    Action,
+    EditMode,
+    IActionHandler,
+    ICommand,
+    KeyListener,
+    SModelElement,
+    TYPES,
+    distinctAdd,
+    matchesKeystroke
+} from '~glsp-sprotty';
+import { EditorContextService, EditorContextServiceProvider } from '../editor-context-service';
+import { EnableDefaultToolsAction, EnableToolsAction, Tool } from './tool';
+/**
+ * A tool manager coordinates the state of tools in the context of an editor.
+ *
+ * One instance of a tool manager is intended per editor, coordinating the state of all tools within
+ * this editor. A tool can be active or not. A tool manager ensures that activating a set of tools
+ * will disable all other tools, allowing them to invoke behavior when they become enabled or disabled.
+ */
+export interface IToolManager {
+    /** All tools managed by this tool manager. */
+    readonly managedTools: Tool[];
+
+    /** The tools that are enabled by default, whenever no other tool is enabled. */
+    readonly defaultTools: Tool[];
+
+    /** The currently active tools, which are either specifically enabled tools, or the default tools. */
+    readonly activeTools: Tool[];
+
+    /**
+     * Enables the tools with the specified `toolIds`.
+     * Therefore, this manager first disables currently active tools and then enable the
+     * tools indicated in `toolIds`, making them the currently active tools. If this manager
+     * doesn't manage one or more tools specified in `toolIds`, it'll do nothing. If not a
+     * single tool that shall be enabled was found in the managed tools, it'll fall back to
+     * the default tools.
+     *
+     * @param tools The tools to be enabled.
+     */
+    enable(toolIds: string[]): void;
+
+    /**
+     * Enables all default tools.
+     */
+    enableDefaultTools(): void;
+
+    /** Disables all currently active tools. After this call, no tool will be active anymore. */
+    disableActiveTools(): void;
+
+    registerDefaultTools(...tools: Tool[]): void;
+
+    registerTools(...tools: Tool[]): void;
+}
+
+/**
+ * The default {@link IToolManager} implementation. Allows
+ * registration of tools via Dependency Injection.
+ */
+@injectable()
+export class ToolManager implements IToolManager {
+    readonly actives: Tool[] = [];
+
+    protected editorContext?: EditorContextService;
+
+    constructor(
+        @multiInject(TYPES.ITool)
+        @optional()
+        readonly tools: Tool[] = [],
+        @multiInject(TYPES.IDefaultTool)
+        @optional()
+        readonly defaultTools: Tool[],
+        @inject(TYPES.IEditorContextServiceProvider) protected contextServiceProvider: EditorContextServiceProvider
+    ) {
+        this.registerTools(...this.tools);
+        this.registerDefaultTools(...this.defaultTools);
+        this.enableDefaultTools();
+        this.contextServiceProvider().then(editorContext => {
+            editorContext.onEditModeChanged(change => this.editModeChanged(change.newValue, change.oldValue));
+            this.editorContext = editorContext;
+        });
+    }
+
+    get managedTools(): Tool[] {
+        return this.defaultTools.concat(this.tools);
+    }
+
+    get activeTools(): Tool[] {
+        return this.actives;
+    }
+
+    registerDefaultTools(...tools: Tool[]): void {
+        distinctAdd(this.defaultTools, ...tools);
+    }
+
+    registerTools(...tools: Tool[]): void {
+        distinctAdd(this.tools, ...tools);
+    }
+
+    disableActiveTools(): void {
+        this.actives.forEach(tool => tool.disable());
+        this.actives.splice(0, this.actives.length);
+    }
+
+    enableDefaultTools(): void {
+        this.enable(this.defaultTools.map(tool => tool.id));
+    }
+
+    enable(toolIds: string[]): void {
+        this.disableActiveTools();
+        let tools = toolIds.map(id => this.tool(id));
+        if (this.editorContext && this.editorContext.isReadonly) {
+            tools = tools.filter(tool => !tool?.isEditTool);
+        }
+        tools.forEach(tool => {
+            if (tool !== undefined) {
+                tool.enable();
+                this.actives.push(tool);
+            }
+        });
+    }
+
+    tool(toolId: string): Tool | undefined {
+        return this.managedTools.find(tool => tool.id === toolId);
+    }
+
+    disableEditTools(): void {
+        this.disableActiveTools();
+        this.enable(this.defaultTools.filter(tool => !tool.isEditTool).map(tool => tool.id));
+    }
+
+    editModeChanged(newValue: string, oldValue: string): void {
+        if (oldValue === newValue) {
+            return;
+        }
+        if (newValue === EditMode.READONLY) {
+            this.disableEditTools();
+        } else if (newValue === EditMode.EDITABLE) {
+            this.enableDefaultTools();
+        }
+    }
+}
+
+@injectable()
+export class ToolManagerActionHandler implements IActionHandler {
+    @inject(TYPES.IToolManager)
+    readonly toolManager: IToolManager;
+
+    handle(action: Action): void | ICommand | Action {
+        if (EnableDefaultToolsAction.is(action)) {
+            this.toolManager.enableDefaultTools();
+        } else if (EnableToolsAction.is(action)) {
+            this.toolManager.enable((action as EnableToolsAction).toolIds);
+        }
+    }
+}
+
+@injectable()
+export class DefaultToolsEnablingKeyListener extends KeyListener {
+    override keyDown(element: SModelElement, event: KeyboardEvent): Action[] {
+        if (matchesKeystroke(event, 'Escape')) {
+            return [EnableDefaultToolsAction.create()];
+        }
+        return [];
+    }
+}

package/src/base/tool-manager/tool.ts

@@ -0,0 +1,85 @@
+/********************************************************************************
+ * Copyright (c) 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 { Action, AnyObject, hasArrayProp, hasBooleanProp, hasFunctionProp, hasStringProp } from '~glsp-sprotty';
+
+/**
+ * Action to enable the tools of the specified `toolIds`.
+ */
+export interface EnableToolsAction extends Action {
+    kind: typeof EnableToolsAction.KIND;
+    toolIds: string[];
+}
+export namespace EnableToolsAction {
+    export const KIND = 'enable-tools';
+
+    export function is(object: unknown): object is EnableToolsAction {
+        return Action.hasKind(object, KIND) && hasArrayProp(object, 'toolIds');
+    }
+
+    export function create(toolIds: string[]): EnableToolsAction {
+        return {
+            kind: KIND,
+            toolIds
+        };
+    }
+}
+
+/**
+ * Action to disable the currently active tools and enable the default tools instead.
+ */
+export interface EnableDefaultToolsAction extends Action {
+    kind: typeof EnableDefaultToolsAction.KIND;
+}
+export namespace EnableDefaultToolsAction {
+    export const KIND = 'enable-default-tools';
+
+    export function is(object: unknown): object is EnableToolsAction {
+        return Action.hasKind(object, KIND);
+    }
+
+    export function create(): EnableDefaultToolsAction {
+        return {
+            kind: KIND
+        };
+    }
+}
+
+/** A tool that can be managed by a `ToolManager`.
+ */
+export interface Tool {
+    readonly id: string;
+    /* Notifies the tool to become active. */
+    enable(): void;
+    /* Notifies the tool to become inactive. */
+    disable(): void;
+    /** Optional flag indicating wether this tool is an edit tool.
+     *  Edit tools are inactive when a diagram is in `readonly` edit mode.
+     */
+    isEditTool?: boolean;
+}
+
+export namespace Tool {
+    export function is(object: unknown): object is Tool {
+        return (
+            AnyObject.is(object) &&
+            hasStringProp(object, 'id') &&
+            hasFunctionProp(object, 'enable') &&
+            hasFunctionProp(object, 'disable') &&
+            hasBooleanProp(object, 'isEditTool', true)
+        );
+    }
+}

package/src/base/view/key-tool.ts

@@ -0,0 +1,25 @@
+/********************************************************************************
+ * Copyright (c) 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 { injectable } from 'inversify';
+import { Disposable, KeyListener, KeyTool } from '~glsp-sprotty';
+
+@injectable()
+export class GLSPKeyTool extends KeyTool {
+    registerListener(keyListener: KeyListener): Disposable {
+        super.register(keyListener);
+        return Disposable.create(() => this.deregister(keyListener));
+    }
+}

package/src/base/view/mouse-tool.ts

@@ -0,0 +1,105 @@
+/********************************************************************************
+ * 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 { injectable, multiInject, optional } from 'inversify';
+import { Action, Disposable, MouseListener, MouseTool, SModelElement, SModelRoot, TYPES } from '~glsp-sprotty';
+import { Ranked } from '../ranked';
+
+/**
+ * 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 GLSPMouseTool extends MouseTool {
+    protected rankedMouseListeners: Map<number, MouseListener[]>;
+
+    constructor(@multiInject(TYPES.MouseListener) @optional() protected override mouseListeners: MouseListener[] = []) {
+        super(mouseListeners);
+        this.rankedMouseListeners = groupBy(mouseListeners, listener => Ranked.getRank(listener));
+    }
+
+    override register(mouseListener: MouseListener): void {
+        super.register(mouseListener);
+        this.rankedMouseListeners = groupBy(this.mouseListeners, listener => Ranked.getRank(listener));
+    }
+
+    registerListener(mouseListener: MouseListener): Disposable {
+        this.register(mouseListener);
+        return Disposable.create(() => this.deregister(mouseListener));
+    }
+
+    override deregister(mouseListener: MouseListener): void {
+        super.deregister(mouseListener);
+        this.rankedMouseListeners = groupBy(this.mouseListeners, listener => Ranked.getRank(listener));
+    }
+
+    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) {
+            return;
+        }
+        this.notifyListenersByRank(element, methodName, event);
+    }
+
+    protected async notifyListenersByRank<K extends MouseListenerMethods>(
+        element: SModelElement,
+        methodName: K,
+        event: MouseEvent
+    ): Promise<void> {
+        for (const rank of this.rankedMouseListeners) {
+            await this.dispatchActions(rank[1], methodName, element, event);
+        }
+    }
+
+    protected async dispatchActions<K extends MouseListenerMethods>(
+        mouseListeners: MouseListener[],
+        methodName: K,
+        element: SModelElement,
+        event: MouseEvent
+    ): Promise<void> {
+        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 (Action.is(actionOrPromise)) {
+                    await this.actionDispatcher.dispatch(actionOrPromise);
+                } else {
+                    actionOrPromise.then((action: Action) => {
+                        this.actionDispatcher.dispatch(action);
+                    });
+                }
+            }
+        }
+    }
+}
+
+function groupBy<K, T>(array: Array<T>, keyFunction: (x: T) => K): Map<K, T[]> {
+    const unsortedMap = array.reduce((result: Map<K, T[]>, item: T) => {
+        const key = keyFunction(item);
+        if (!result.has(key)) {
+            result.set(key, [item]);
+        } else {
+            const entries = result.get(key);
+            if (entries) {
+                entries.push(item);
+            }
+        }
+        return result;
+    }, new Map<K, T[]>());
+    return new Map<K, T[]>([...unsortedMap.entries()].sort());
+}