@eclipse-glsp/client 1.1.0-next.383e4e9.264 → 1.1.0-next.3d1b3e6.280

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/default-modules.ts

@@ -14,11 +14,15 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 
-import { Container, ContainerModule } from 'inversify';
+import { Container } from 'inversify';
 import {
+    BindingContext,
     ContainerConfiguration,
     FeatureModule,
+    TYPES,
+    ViewerOptions,
     buttonModule,
+    configureViewerOptions,
     edgeIntersectionModule,
     edgeLayoutModule,
     expandModule,
@@ -29,6 +33,7 @@ import {
     zorderModule
 } from '~glsp-sprotty';
 import { defaultModule } from './base/default.module';
+import { IDiagramOptions } from './base/model/diagram-loader';
 import { boundsModule } from './features/bounds/bounds-module';
 import { commandPaletteModule } from './features/command-palette/command-palette-module';
 import { contextMenuModule } from './features/context-menu/context-menu-module';
@@ -43,6 +48,7 @@ import { navigationModule } from './features/navigation/navigation-module';
 import { routingModule } from './features/routing/routing-module';
 import { selectModule } from './features/select/select-module';
 import { sourceModelWatcherModule } from './features/source-model-watcher/source-model-wacher-module';
+import { statusModule } from './features/status/status-module';
 import { svgMetadataModule } from './features/svg-metadata/svg-metadata-module';
 import { toolPaletteModule } from './features/tool-palette/tool-palette-module';
 import { changeBoundsToolModule } from './features/tools/change-bounds/change-boounds-tool-module';
@@ -90,9 +96,38 @@ export const DEFAULT_MODULES = [
     toolFocusLossModule,
     validationModule,
     zorderModule,
-    svgMetadataModule
+    svgMetadataModule,
+    statusModule
 ] as const;
 
+/**
+ * Wraps the {@link configureDiagramOptions} utility function in a module. Adopters can either include this
+ * module into the container {@link ModuleConfiguration} or configure the container after its creation
+ * (e.g. using the {@link configureDiagramOptions} utility function).
+ * @param options The diagram instance specific configuration options
+ * @returns The corresponding {@link FeatureModule}
+ */
+export function createDiagramOptionsModule(options: IDiagramOptions): FeatureModule {
+    return new FeatureModule((bind, unbind, isBound, rebind) => configureDiagramOptions({ bind, unbind, isBound, rebind }, options));
+}
+
+/**
+ * Utility function to bind the diagram instance specific configuration options.
+ * In addition to binding the {@link IDiagramOptions} this function also overrides the
+ * {@link ViewerOptions} to match the given client id.
+ * @param context The binding context
+ * @param options The {@link IDiagramOptions} that should be bound
+ */
+export function configureDiagramOptions(context: BindingContext, options: IDiagramOptions): void {
+    const viewerOptions: Partial<ViewerOptions> = {
+        baseDiv: options.clientId,
+        hiddenDiv: options.clientId + '_hidden'
+    };
+    configureViewerOptions(context, viewerOptions);
+
+    context.bind(TYPES.IDiagramOptions).toConstantValue(options);
+}
+
 /**
  *  Initializes a GLSP Diagram container with the GLSP default modules and the specified custom `modules`.
  *  Additional modules can be passed as direct arguments or as part of a {@link ModuleConfiguration}.
@@ -134,29 +169,3 @@ export function initializeDiagramContainer(container: Container, ...containerCon
     container.load(...modules);
     return container;
 }
-
-/**
- * Creates a GLSP Client container with the GLSP default modules and the specified custom `modules`.
- *
- * You can still customize the default modules in two ways.
- *
- * First, you can unload default modules and load them again with your custom code.
- *
- * ```typescript
- * const container = createClientContainer(myModule1, myModule2);
- * container.unload(modelSourceWatcherModule);
- * container.load(myModelSourceWatcherModule);
- * ```
- *
- * Second, you can unbind or rebind implementations that are originally bound in one of the default modules.
- *
- * ```typescript
- * rebind(NavigationTargetResolver).to(MyNavigationTargetResolver);
- * ```
- * @param modules Custom modules to be loaded in addition to the default modules.
- * @returns The created container.
- * @deprecated Please use `initializeDiagramContainer` from `@eclipse-glsp/client` instead
- */
-export function createClientContainer(...modules: ContainerModule[]): Container {
-    return initializeDiagramContainer(new Container(), ...modules);
-}

package/src/features/accessibility/README.md

@@ -63,3 +63,21 @@ The resize functionality helps to set the size of the nodes, by either increasin
 3. <kbd>+</kbd> or <kbd>-</kbd> to increase or decrease the size of the element(s) gradually.
 4. <kbd>CTRL</kbd>+<kbd>0</kbd>: Set the size of the element(s) to default.
 5. <kbd>ESC</kbd>: Deactivate the resize mode.
+
+### Model Navigation
+
+#### Default Navigation (following directions of relations)
+
+1. Select element as starting point.
+2. <kbd>N</kbd>: Activate default navigation.
+3. Use arrow keys to iterate through model according to the directions of the given relations.
+
+#### Position-based Navigation (following x and y coordinates)
+
+1. Select element as starting point.
+2. <kbd>ALT</kbd>+<kbd>N</kbd>: Activate position based navigation.
+3. Use arrow keys (<kbd>←</kbd> || <kbd>↑</kbd> || <kbd>→</kbd> || <kbd>↓</kbd>) to iterate through model according to the positions of the elements, i.e. depending on the order of the elements' x and y coordinates.
+
+### Help
+
+1. <kbd>ALT</kbd>+<kbd>H</kbd>: Display list of keyboard shortcuts.

package/src/features/accessibility/accessibility-module.ts

@@ -20,7 +20,9 @@ import { configureMoveZoom } from './move-zoom/move-zoom-module';
 import { configureResizeTools } from './resize-key-tool/resize-key-module';
 import { configureSearchPaletteModule } from './search/search-palette-module';
 import { configureViewKeyTools } from './view-key-tools/view-key-tools-module';
-
+import { configureElementNavigationTool } from './element-navigation/element-navigation-module';
+import { configureFocusTrackerTool } from './focus-tracker/focus-tracker-module';
+import { configureToastTool } from './toast/toast-module';
 /**
  * Enables the accessibility tools for a keyboard-only-usage
  */
@@ -31,4 +33,7 @@ export const accessibilityModule = new FeatureModule((bind, unbind, isBound, reb
     configureMoveZoom(context);
     configureSearchPaletteModule(context);
     configureShortcutHelpTool(context);
+    configureElementNavigationTool(context);
+    configureFocusTrackerTool(context);
+    configureToastTool(context);
 });

package/src/features/accessibility/element-navigation/diagram-navigation-tool.ts

@@ -0,0 +1,307 @@
+/********************************************************************************
+ * Copyright (c) 2023 Business Informatics Group (TU Wien) 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 } from 'inversify';
+import { toArray } from 'sprotty/lib/utils/iterable';
+import { matchesKeystroke } from 'sprotty/lib/utils/keyboard';
+import {
+    Action,
+    KeyListener,
+    KeyTool,
+    SEdge,
+    SModelElement,
+    SModelRoot,
+    SelectAction,
+    Selectable,
+    TYPES,
+    findParentByFeature,
+    isBoundsAware,
+    isSelectable,
+    isSelected
+} from '~glsp-sprotty';
+import { GLSPActionDispatcher } from '../../../base/action-dispatcher';
+import { EnableDefaultToolsAction, EnableToolsAction, Tool } from '../../../base/tool-manager/tool';
+import { SelectableBoundsAware } from '../../../utils/smodel-util';
+import { RepositionAction } from '../../viewport/reposition';
+import { SetAccessibleKeyShortcutAction } from '../key-shortcut/accessible-key-shortcut';
+import { AccessibleKeyShortcutTool } from '../key-shortcut/accessible-key-shortcut-tool';
+import { SearchAutocompletePaletteTool } from '../search/search-tool';
+import * as messages from '../toast/messages.json';
+import { ShowToastMessageAction } from '../toast/toast-handler';
+import { ElementNavigator } from './element-navigator';
+
+@injectable()
+export class ElementNavigatorTool implements Tool {
+    static ID = 'glsp.diagram-navigation';
+
+    isEditTool = false;
+
+    protected elementNavigatorKeyListener: ElementNavigatorKeyListener = new ElementNavigatorKeyListener(this);
+    @inject(KeyTool) protected readonly keytool: KeyTool;
+    @inject(TYPES.IElementNavigator) readonly elementNavigator: ElementNavigator;
+    @inject(TYPES.ILocalElementNavigator) readonly localElementNavigator: ElementNavigator;
+    @inject(TYPES.IActionDispatcher) readonly actionDispatcher: GLSPActionDispatcher;
+
+    get id(): string {
+        return ElementNavigatorTool.ID;
+    }
+
+    enable(): void {
+        this.keytool.register(this.elementNavigatorKeyListener);
+        this.elementNavigatorKeyListener.registerShortcutKey();
+    }
+
+    disable(): void {
+        this.keytool.deregister(this.elementNavigatorKeyListener);
+    }
+}
+
+enum NavigationMode {
+    POSITION = 'position',
+    DEFAULT = 'default',
+    NONE = 'none'
+}
+
+export class ElementNavigatorKeyListener extends KeyListener {
+    protected mode = NavigationMode.NONE;
+    protected previousNode?: SelectableBoundsAware;
+    protected navigator?: ElementNavigator;
+    protected readonly token = ElementNavigatorKeyListener.name;
+
+    constructor(protected readonly tool: ElementNavigatorTool) {
+        super();
+    }
+
+    registerShortcutKey(): void {
+        this.tool.actionDispatcher.dispatchOnceModelInitialized(
+            SetAccessibleKeyShortcutAction.create({
+                token: this.token,
+                keys: [
+                    { shortcuts: ['N'], description: 'Activate default navigation', group: 'Navigation', position: 0 },
+                    {
+                        shortcuts: ['ALT', 'N'],
+                        description: 'Activate position based navigation',
+                        group: 'Navigation',
+                        position: 1
+                    },
+                    {
+                        shortcuts: ['⬅  ⬆  ➡  ⬇'],
+                        description: 'Navigate by relation or neighbors according to navigation mode',
+                        group: 'Navigation',
+                        position: 2
+                    }
+                ]
+            })
+        );
+    }
+
+    override keyDown(element: SModelElement, event: KeyboardEvent): Action[] {
+        this.resetOnEscape(event, element);
+
+        if (this.getSelectedElements(element.root).length > 0) {
+            if (!this.triggerPositionNavigationOnEvent(event, element)) {
+                this.triggerDefaultNavigationOnEvent(event, element);
+            }
+
+            return this.navigate(element, event);
+        }
+
+        this.resetPositionNavigationOnEvent(event, element);
+        this.resetDefaultNavigationOnEvent(event, element);
+
+        return [];
+    }
+    protected resetOnEscape(event: KeyboardEvent, element: SModelElement): void {
+        if (this.mode !== NavigationMode.NONE && this.matchesDeactivateNavigationMode(event)) {
+            this.navigator?.clean?.(element.root);
+            this.clean();
+
+            if (this.mode === NavigationMode.POSITION) {
+                this.tool.actionDispatcher.dispatchAll([
+                    EnableDefaultToolsAction.create(),
+                    ShowToastMessageAction.createWithTimeout({
+                        id: Symbol.for(ElementNavigatorKeyListener.name),
+                        message: messages.navigation.local_navigation_mode_deactivated
+                    })
+                ]);
+            } else if (this.mode === NavigationMode.DEFAULT) {
+                this.tool.actionDispatcher.dispatchAll([
+                    EnableDefaultToolsAction.create(),
+                    ShowToastMessageAction.createWithTimeout({
+                        id: Symbol.for(ElementNavigatorKeyListener.name),
+                        message: messages.navigation.default_navigation_mode_deactivated
+                    })
+                ]);
+            }
+
+            this.mode = NavigationMode.NONE;
+        }
+    }
+
+    protected triggerPositionNavigationOnEvent(event: KeyboardEvent, element: SModelElement): boolean {
+        if (this.matchesActivatePositionNavigation(event)) {
+            if (this.mode !== NavigationMode.POSITION) {
+                this.clean();
+                this.tool.actionDispatcher.dispatchAll([
+                    EnableToolsAction.create([ElementNavigatorTool.ID, SearchAutocompletePaletteTool.ID, AccessibleKeyShortcutTool.ID]),
+                    ShowToastMessageAction.create({
+                        id: Symbol.for(ElementNavigatorKeyListener.name),
+                        message: messages.navigation.local_navigation_mode_activated
+                    })
+                ]);
+                this.navigator = this.tool.elementNavigator;
+                this.mode = NavigationMode.POSITION;
+            } else {
+                this.resetPositionNavigationOnEvent(event, element);
+            }
+
+            return true;
+        }
+
+        return false;
+    }
+
+    protected resetPositionNavigationOnEvent(event: KeyboardEvent, element: SModelElement): void {
+        if (this.mode === NavigationMode.POSITION && this.matchesActivatePositionNavigation(event)) {
+            this.navigator?.clean?.(element.root);
+            this.clean();
+            this.mode = NavigationMode.NONE;
+            this.tool.actionDispatcher.dispatchAll([
+                EnableDefaultToolsAction.create(),
+                ShowToastMessageAction.createWithTimeout({
+                    id: Symbol.for(ElementNavigatorKeyListener.name),
+                    message: messages.navigation.local_navigation_mode_deactivated
+                })
+            ]);
+        }
+    }
+    protected triggerDefaultNavigationOnEvent(event: KeyboardEvent, element: SModelElement): boolean {
+        if (this.matchesActivateDefaultNavigation(event)) {
+            if (this.mode !== NavigationMode.DEFAULT) {
+                this.clean();
+
+                this.tool.actionDispatcher.dispatchAll([
+                    EnableToolsAction.create([ElementNavigatorTool.ID, SearchAutocompletePaletteTool.ID, AccessibleKeyShortcutTool.ID]),
+                    ShowToastMessageAction.create({
+                        id: Symbol.for(ElementNavigatorKeyListener.name),
+                        message: messages.navigation.default_navigation_mode_activated
+                    })
+                ]);
+                this.navigator = this.tool.localElementNavigator;
+                this.mode = NavigationMode.DEFAULT;
+            } else {
+                this.resetDefaultNavigationOnEvent(event, element);
+            }
+
+            return true;
+        }
+        return false;
+    }
+
+    protected resetDefaultNavigationOnEvent(event: KeyboardEvent, element: SModelElement): void {
+        if (this.mode === NavigationMode.DEFAULT && this.matchesActivateDefaultNavigation(event)) {
+            this.navigator?.clean?.(element.root);
+            this.clean();
+            this.mode = NavigationMode.NONE;
+            this.tool.actionDispatcher.dispatchAll([
+                EnableDefaultToolsAction.create(),
+                ShowToastMessageAction.createWithTimeout({
+                    id: Symbol.for(ElementNavigatorKeyListener.name),
+                    message: messages.navigation.default_navigation_mode_deactivated
+                })
+            ]);
+        }
+    }
+
+    protected navigate(element: SModelElement, event: KeyboardEvent): Action[] {
+        const selected = this.getSelectedElements(element.root);
+        const current = selected.length > 0 ? selected[0] : undefined;
+
+        if (this.mode !== NavigationMode.NONE && this.navigator !== undefined && current !== undefined && isBoundsAware(current)) {
+            this.navigator.clean?.(current.root, current, this.previousNode);
+
+            const target = this.navigateOnEvent(event, this.navigator, current);
+
+            if (target !== undefined) {
+                this.navigator.process?.(current.root, current, target as SelectableBoundsAware, this.previousNode);
+            }
+            const selectableTarget = target ? findParentByFeature(target, isSelectable) : undefined;
+
+            if (selectableTarget) {
+                if (!(current instanceof SEdge)) {
+                    this.previousNode = current;
+                }
+                const deselectedElementsIDs = selected.map(e => e.id).filter(id => id !== selectableTarget.id);
+
+                return [
+                    SelectAction.create({ selectedElementsIDs: [selectableTarget.id], deselectedElementsIDs }),
+                    RepositionAction.create([selectableTarget.id])
+                ];
+            }
+        }
+
+        return [];
+    }
+
+    protected navigateOnEvent(
+        event: KeyboardEvent,
+        navigator: ElementNavigator,
+        current: SelectableBoundsAware
+    ): SModelElement | undefined {
+        if (this.matchesNavigatePrevious(event)) {
+            return navigator.previous(current.root, current);
+        } else if (this.matchesNavigateNext(event)) {
+            return navigator.next(current.root, current);
+        } else if (this.matchesNavigateUp(event)) {
+            return navigator.up?.(current.root, current, this.previousNode);
+        } else if (this.matchesNavigateDown(event)) {
+            return navigator.down?.(current.root, current, this.previousNode);
+        }
+
+        return undefined;
+    }
+
+    protected clean(): void {
+        this.previousNode = undefined;
+        this.navigator = undefined;
+    }
+
+    protected getSelectedElements(root: SModelRoot): (SModelElement & Selectable)[] {
+        return toArray(root.index.all().filter(e => isSelected(e))) as (SModelElement & Selectable)[];
+    }
+
+    protected matchesDeactivateNavigationMode(event: KeyboardEvent): boolean {
+        return matchesKeystroke(event, 'Escape');
+    }
+    protected matchesActivateDefaultNavigation(event: KeyboardEvent): boolean {
+        return matchesKeystroke(event, 'KeyN');
+    }
+    protected matchesActivatePositionNavigation(event: KeyboardEvent): boolean {
+        return matchesKeystroke(event, 'KeyN', 'alt');
+    }
+    protected matchesNavigatePrevious(event: KeyboardEvent): boolean {
+        return matchesKeystroke(event, 'ArrowLeft');
+    }
+    protected matchesNavigateNext(event: KeyboardEvent): boolean {
+        return matchesKeystroke(event, 'ArrowRight');
+    }
+    protected matchesNavigateUp(event: KeyboardEvent): boolean {
+        return matchesKeystroke(event, 'ArrowUp');
+    }
+    protected matchesNavigateDown(event: KeyboardEvent): boolean {
+        return matchesKeystroke(event, 'ArrowDown');
+    }
+}

package/src/features/accessibility/element-navigation/element-navigation-module.ts

@@ -0,0 +1,36 @@
+/********************************************************************************
+ * Copyright (c) 2023 Business Informatics Group (TU Wien) 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 { ContainerModule } from 'inversify';
+import { BindingContext, TYPES, bindAsService } from '~glsp-sprotty';
+import { PositionNavigator } from './position-navigator';
+import { LocalElementNavigator } from './local-element-navigator';
+import { ElementNavigatorTool } from './diagram-navigation-tool';
+import '../../../../css/navigation.css';
+
+/**
+ * Handles element navigation actions.
+ */
+
+export const glspElementNavigationModule = new ContainerModule((bind, unbind, isBound, rebind) => {
+    const context = { bind, unbind, isBound, rebind };
+    configureElementNavigationTool(context);
+});
+
+export function configureElementNavigationTool(context: BindingContext): void {
+    bindAsService(context, TYPES.IDefaultTool, ElementNavigatorTool);
+    bindAsService(context, TYPES.IElementNavigator, PositionNavigator);
+    bindAsService(context, TYPES.ILocalElementNavigator, LocalElementNavigator);
+}

package/src/features/accessibility/element-navigation/element-navigator.ts

@@ -0,0 +1,57 @@
+/********************************************************************************
+ * Copyright (c) 2023 Business Informatics Group (TU Wien) 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 { SModelElement, SModelRoot } from '~glsp-sprotty';
+import { SelectableBoundsAware } from '../../../utils/smodel-util';
+
+export interface ElementNavigator {
+    previous(
+        root: Readonly<SModelRoot>,
+        current: SelectableBoundsAware,
+        previousCurrent?: SelectableBoundsAware,
+        predicate?: (element: SModelElement) => boolean
+    ): SModelElement | undefined;
+
+    next(
+        root: Readonly<SModelRoot>,
+        current: SelectableBoundsAware,
+        previousCurrent?: SelectableBoundsAware,
+        predicate?: (element: SModelElement) => boolean
+    ): SModelElement | undefined;
+
+    up?(
+        root: Readonly<SModelRoot>,
+        current: SelectableBoundsAware,
+        previousCurrent?: SelectableBoundsAware,
+        predicate?: (element: SModelElement) => boolean
+    ): SModelElement | undefined;
+
+    down?(
+        root: Readonly<SModelRoot>,
+        current: SelectableBoundsAware,
+        previousCurrent?: SelectableBoundsAware,
+        predicate?: (element: SModelElement) => boolean
+    ): SModelElement | undefined;
+
+    process?(
+        root: Readonly<SModelRoot>,
+        current: SelectableBoundsAware,
+        target: SelectableBoundsAware,
+        previousCurrent?: SelectableBoundsAware,
+        predicate?: (element: SModelElement) => boolean
+    ): void;
+    clean?(root: Readonly<SModelRoot>, current?: SelectableBoundsAware, previousCurrent?: SelectableBoundsAware): void;
+}