@eclipse-glsp/client 1.1.0-RC10 → 1.1.0-next.0363f0b.261

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eclipse-glsp/client",
-  "version": "1.1.0-RC10",
+  "version": "1.1.0-next.0363f0b.261+0363f0b",
   "description": "A sprotty-based client for GLSP",
   "keywords": [
     "eclipse",
@@ -47,12 +47,13 @@
     "watch": "tsc -w"
   },
   "dependencies": {
-    "@eclipse-glsp/protocol": "1.1.0-RC10",
+    "@eclipse-glsp/protocol": "1.1.0-next.0363f0b.261+0363f0b",
     "autocompleter": "5.1.0",
     "lodash": "4.17.21",
     "sprotty": "0.14.0-next.02bbac0.26"
   },
   "devDependencies": {
+    "@types/file-saver": "^2.0.3",
     "@types/lodash": "4.14.191",
     "@vscode/codicons": "^0.0.25",
     "tsc-alias": "^1.8.2"
@@ -60,5 +61,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "415d2da9bf55d4d06f0c7df51ee76871a476b75a"
+  "gitHead": "0363f0b05943fa6f750ac0995bdc0b066680006a"
 }

package/src/base/action-dispatcher.ts

@@ -13,13 +13,15 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { inject } from 'inversify';
+import { inject, injectable } from 'inversify';
 import { Action, ActionDispatcher, RequestAction, ResponseAction } from '~glsp-sprotty';
 import { ModelInitializationConstraint } from './model-initialization-constraint';
 
+@injectable()
 export class GLSPActionDispatcher extends ActionDispatcher {
     protected readonly timeouts: Map<string, NodeJS.Timeout> = new Map();
     protected initializedConstraint = false;
+
     @inject(ModelInitializationConstraint) protected initializationConstraint: ModelInitializationConstraint;
 
     override initialize(): Promise<void> {
@@ -38,6 +40,10 @@ export class GLSPActionDispatcher extends ActionDispatcher {
         return this.initializationConstraint.onInitialized();
     }
 
+    hasHandler(action: Action): boolean {
+        return this.actionHandlerRegistry.get(action.kind).length > 0;
+    }
+
     override dispatch(action: Action): Promise<void> {
         const result = super.dispatch(action);
         this.initializationConstraint.notifyDispatched(action);

package/src/base/command-stack.ts

@@ -13,11 +13,51 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { injectable } from 'inversify';
-import { CommandStack, SModelRoot } from '~glsp-sprotty';
+import { injectable, multiInject, optional, preDestroy } from 'inversify';
+import {
+    CommandStack,
+    Disposable,
+    DisposableCollection,
+    Emitter,
+    Event,
+    ICommand,
+    SModelRoot,
+    SetModelCommand,
+    TYPES,
+    UpdateModelCommand
+} from '~glsp-sprotty';
+
+/**
+ * A hook to listen for model root changes. Will be called after a server update
+ * has been processed
+ */
+export interface ISModelRootListener {
+    modelRootChanged(root: Readonly<SModelRoot>): void;
+}
 
 @injectable()
-export class GLSPCommandStack extends CommandStack {
+export class GLSPCommandStack extends CommandStack implements Disposable {
+    @multiInject(TYPES.ISModelRootListener)
+    @optional()
+    protected modelRootListeners: ISModelRootListener[] = [];
+    protected toDispose = new DisposableCollection();
+
+    protected override initialize(): void {
+        super.initialize();
+        this.toDispose.push(this.onModelRootChangedEmitter);
+        this.modelRootListeners.forEach(listener => this.onModelRootChanged(root => listener.modelRootChanged(root)));
+    }
+
+    @preDestroy()
+    dispose(): void {
+        this.toDispose.dispose();
+    }
+
+    protected onModelRootChangedEmitter = new Emitter<Readonly<SModelRoot>>();
+    get onModelRootChanged(): Event<Readonly<SModelRoot>> {
+        return this.onModelRootChangedEmitter.event;
+    }
+
     override undo(): Promise<SModelRoot> {
         this.logger.warn(
             this,
@@ -33,4 +73,16 @@ export class GLSPCommandStack extends CommandStack {
         );
         return this.currentModel;
     }
+
+    override execute(command: ICommand): Promise<SModelRoot> {
+        const result = super.execute(command);
+        if (command instanceof SetModelCommand || command instanceof UpdateModelCommand) {
+            result.then(root => this.notifyListeners(root));
+        }
+        return result;
+    }
+
+    protected notifyListeners(root: Readonly<SModelRoot>): void {
+        this.onModelRootChangedEmitter.fire(root);
+    }
 }

package/src/base/{di.config.ts → default.module.ts}

@@ -14,34 +14,51 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 import '@vscode/codicons/dist/codicon.css';
-import { Container, ContainerModule } from 'inversify';
+import { Container } from 'inversify';
 import {
     ActionHandlerRegistry,
+    FeatureModule,
+    InitializeResult,
+    KeyTool,
+    LocationPostprocessor,
+    ModelSource,
+    MouseTool,
+    MoveCommand,
+    SetEditModeAction,
+    TYPES,
     bindAsService,
     bindOrRebind,
     configureActionHandler,
     configureCommand,
-    InitializeResult,
-    ModelSource,
-    SetEditModeAction,
-    SetModelCommand,
-    TYPES
+    sprottyDefaultModule
 } from '~glsp-sprotty';
 import '../../css/glsp-sprotty.css';
 import { GLSPActionDispatcher } from './action-dispatcher';
-import { FocusStateChangedAction } from './actions/focus-change-action';
 import { GLSPCommandStack } from './command-stack';
 import { EditorContextService } from './editor-context-service';
-import { FocusTracker } from './focus-tracker';
+import { ModifyCssFeedbackCommand } from './feedback/css-feedback';
+import { FeedbackActionDispatcher } from './feedback/feedback-action-dispatcher';
+import { FeedbackAwareUpdateModelCommand } from './feedback/update-model-command';
+import { FocusStateChangedAction } from './focus/focus-state-change-action';
+import { FocusTracker } from './focus/focus-tracker';
 import { DefaultModelInitializationConstraint, ModelInitializationConstraint } from './model-initialization-constraint';
 import { GLSPModelRegistry } from './model/model-registry';
-import { FeedbackAwareUpdateModelCommand, SetModelActionHandler } from './model/update-model-command';
 import { SelectionClearingMouseListener } from './selection-clearing-mouse-listener';
+import { SelectionService } from './selection-service';
 import { GLSPToolManager } from './tool-manager/glsp-tool-manager';
+import { GLSPKeyTool } from './view/key-tool';
+import { GLSPMouseTool } from './view/mouse-tool';
 import { GLSPViewRegistry } from './view/view-registry';
 
-const defaultGLSPModule = new ContainerModule((bind, _unbind, isBound, rebind) => {
-    const context = { bind, _unbind, isBound, rebind };
+/**
+ * The default module provides all of GLSP's base functionality and services.
+ * It builds on top of sprotty's default module {@link `sprottyDefaultModule`}.
+ */
+export const defaultModule = new FeatureModule((bind, unbind, isBound, rebind, ...rest) => {
+    // load bindings from sprotty's default module to avoid code duplication
+    sprottyDefaultModule.registry(bind, unbind, isBound, rebind, ...rest);
+    const context = { bind, unbind, isBound, rebind };
+
     bind(EditorContextService).toSelf().inSingletonScope();
     bind(TYPES.IEditorContextServiceProvider).toProvider<EditorContextService>(
         ctx => () =>
@@ -60,12 +77,17 @@ const defaultGLSPModule = new ContainerModule((bind, _unbind, isBound, rebind) =
     configureActionHandler(context, FocusStateChangedAction.KIND, FocusTracker);
 
     // Model update initialization ------------------------------------
+    bind(TYPES.IFeedbackActionDispatcher).to(FeedbackActionDispatcher).inSingletonScope();
     configureCommand(context, FeedbackAwareUpdateModelCommand);
-    configureActionHandler(context, SetModelCommand.KIND, SetModelActionHandler);
+
+    bind(GLSPMouseTool).toSelf().inSingletonScope();
+    bindOrRebind(context, MouseTool).toService(GLSPMouseTool);
+    bind(GLSPKeyTool).toSelf().inSingletonScope();
+    bindOrRebind(context, KeyTool).toService(GLSPKeyTool);
 
     bindAsService(context, TYPES.MouseListener, SelectionClearingMouseListener);
 
-    bindOrRebind(context, TYPES.ICommandStack).to(GLSPCommandStack);
+    bindOrRebind(context, TYPES.ICommandStack).to(GLSPCommandStack).inSingletonScope();
     bind(GLSPToolManager).toSelf().inSingletonScope();
     bindOrRebind(context, TYPES.IToolManager).toService(GLSPToolManager);
     bind(GLSPActionDispatcher).toSelf().inSingletonScope();
@@ -76,9 +98,19 @@ const defaultGLSPModule = new ContainerModule((bind, _unbind, isBound, rebind) =
     // support re-registration of model elements and views
     bindOrRebind(context, TYPES.SModelRegistry).to(GLSPModelRegistry).inSingletonScope();
     bindOrRebind(context, TYPES.ViewRegistry).to(GLSPViewRegistry).inSingletonScope();
-});
 
-export default defaultGLSPModule;
+    bind(SelectionService).toSelf().inSingletonScope();
+    bind(TYPES.ISModelRootListener).toService(SelectionService);
+
+    // Feedback Support ------------------------------------
+    // Generic re-usable feedback modifying css classes
+    configureCommand(context, ModifyCssFeedbackCommand);
+    // We support using sprotty's MoveCommand as client-side visual feedback
+    configureCommand(context, MoveCommand);
+
+    bindAsService(context, TYPES.IVNodePostprocessor, LocationPostprocessor);
+    bind(TYPES.HiddenVNodePostprocessor).toService(LocationPostprocessor);
+});
 
 /**
  * Utility function to configure the {@link ModelSource}, i.e. the `DiagramServer`, as action handler for all server actions for the given

package/src/base/drag-aware-mouse-listener.ts

@@ -24,8 +24,8 @@ import { Action, MouseListener, SModelElement } from '~glsp-sprotty';
  * of mouse up events.
  */
 export class DragAwareMouseListener extends MouseListener {
-    private _isMouseDown = false;
-    private _isMouseDrag = false;
+    protected _isMouseDown = false;
+    protected _isMouseDrag = false;
 
     override mouseDown(target: SModelElement, event: MouseEvent): Action[] {
         this._isMouseDown = true;

package/src/base/editor-context-service.ts

@@ -13,12 +13,16 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { inject, injectable, multiInject, optional } from 'inversify';
+import { inject, injectable, multiInject, optional, postConstruct, preDestroy } from 'inversify';
 import {
     Action,
     Args,
+    Disposable,
+    DisposableCollection,
     EditMode,
     EditorContext,
+    Emitter,
+    Event,
     IActionHandler,
     ModelSource,
     MousePositionTracker,
@@ -26,13 +30,12 @@ import {
     SModelRoot,
     SetEditModeAction,
     TYPES,
-    distinctAdd,
-    remove
+    ValueChange
 } from '~glsp-sprotty';
-import { SelectionService } from '../features/select/selection-service';
+import { SelectionService } from './selection-service';
 import { isSourceUriAware } from './source-uri-aware';
 
-export interface EditModeListener {
+export interface IEditModeListener {
     editModeChanged(newValue: string, oldValue: string): void;
 }
 
@@ -49,8 +52,8 @@ export interface EditModeListener {
  *    position, etc.).
  */
 @injectable()
-export class EditorContextService implements IActionHandler {
-    @inject(TYPES.SelectionService)
+export class EditorContextService implements IActionHandler, Disposable {
+    @inject(SelectionService)
     protected selectionService: SelectionService;
 
     @inject(MousePositionTracker)
@@ -58,19 +61,31 @@ export class EditorContextService implements IActionHandler {
 
     @multiInject(TYPES.IEditModeListener)
     @optional()
-    protected editModeListeners: EditModeListener[] = [];
+    protected editModeListeners: IEditModeListener[] = [];
 
     @inject(TYPES.ModelSourceProvider)
     protected modelSourceProvider: () => Promise<ModelSource>;
 
     protected _editMode: string;
 
-    register(editModeListener: EditModeListener): void {
-        distinctAdd(this.editModeListeners, editModeListener);
+    protected onEditModeChangedEmitter = new Emitter<ValueChange<string>>();
+    get onEditModeChanged(): Event<ValueChange<string>> {
+        return this.onEditModeChangedEmitter.event;
     }
 
-    deregister(editModeListener: EditModeListener): void {
-        remove(this.editModeListeners, editModeListener);
+    protected toDispose = new DisposableCollection();
+
+    @postConstruct()
+    protected initialize(): void {
+        this.toDispose.push(this.onEditModeChangedEmitter);
+        this.editModeListeners.forEach(listener =>
+            this.onEditModeChanged(change => listener.editModeChanged(change.newValue, change.oldValue))
+        );
+    }
+
+    @preDestroy()
+    dispose(): void {
+        this.toDispose.dispose();
     }
 
     get(args?: Args): EditorContext {
@@ -98,7 +113,7 @@ export class EditorContextService implements IActionHandler {
     }
 
     protected notifyEditModeListeners(oldValue: string): void {
-        this.editModeListeners.forEach(listener => listener.editModeChanged(oldValue, this.editMode));
+        this.onEditModeChangedEmitter.fire({ newValue: this.editMode, oldValue });
     }
 
     async getSourceUri(): Promise<string | undefined> {

package/src/{features/tool-feedback → base/feedback}/css-feedback.ts

@@ -16,7 +16,7 @@
 import { inject, injectable } from 'inversify';
 import { Action, CommandExecutionContext, SModelElement, SModelRoot, TYPES, hasArrayProp } from '~glsp-sprotty';
 import { addCssClasses, getElements, removeCssClasses } from '../../utils/smodel-util';
-import { FeedbackCommand } from './model';
+import { FeedbackCommand } from './feedback-command';
 
 export interface ModifyCSSFeedbackAction extends Action {
     kind: typeof ModifyCSSFeedbackAction.KIND;

package/src/{features/tool-feedback → base/feedback}/feedback-action-dispatcher.ts

@@ -14,7 +14,7 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 import { inject, injectable } from 'inversify';
-import { Action, IActionDispatcher, ILogger, TYPES } from '~glsp-sprotty';
+import { Action, Disposable, IActionDispatcher, ILogger, TYPES } from '~glsp-sprotty';
 
 export interface IFeedbackEmitter {}
 
@@ -35,21 +35,23 @@ export interface IFeedbackActionDispatcher {
     /**
      * Registers `actions` to be sent out by a `feedbackEmitter`.
      * @param feedbackEmitter the emitter sending out feedback actions.
-     * @param actions the actions to be sent out.
+     * @param feedbackActions the actions to be sent out.
+     * @param cleanupActions the actions to be sent out when the feedback is de-registered through the returned Disposable.
+     * @returns A 'Disposable' that de-registers the feedback and cleans up any pending feedback with the given `cleanupActions`.
      */
-    registerFeedback(feedbackEmitter: IFeedbackEmitter, actions: Action[]): void;
+    registerFeedback(feedbackEmitter: IFeedbackEmitter, feedbackActions: Action[], cleanupActions?: Action[]): Disposable;
 
     /**
      * Deregisters a `feedbackEmitter` from this dispatcher and thereafter
      * dispatches the provided `actions`.
      * @param feedbackEmitter the emitter to be deregistered.
-     * @param actions the actions to be dispatched right after the deregistration.
+     * @param cleanupActions the actions to be dispatched right after the deregistration.
      * These actions do not have to be related to the actions sent out by the
      * deregistered `feedbackEmitter`. The purpose of these actions typically is
      * to reset the normal state of the diagram without the feedback (e.g., reset a
      * CSS class that was set by a feedbackEmitter).
      */
-    deregisterFeedback(feedbackEmitter: IFeedbackEmitter, actions: Action[]): void;
+    deregisterFeedback(feedbackEmitter: IFeedbackEmitter, cleanupActions?: Action[]): void;
 
     /**
      * Retrieve all `actions` sent out by currently registered `feedbackEmitter`.
@@ -59,41 +61,47 @@ export interface IFeedbackActionDispatcher {
 
 @injectable()
 export class FeedbackActionDispatcher implements IFeedbackActionDispatcher {
-    protected feedbackEmitters: Map<IFeedbackEmitter, Action[]> = new Map();
+    protected registeredFeedback: Map<IFeedbackEmitter, Action[]> = new Map();
 
     @inject(TYPES.IActionDispatcherProvider) protected actionDispatcher: () => Promise<IActionDispatcher>;
     @inject(TYPES.ILogger) protected logger: ILogger;
 
-    registerFeedback(feedbackEmitter: IFeedbackEmitter, actions: Action[]): void {
-        this.feedbackEmitters.set(feedbackEmitter, actions);
-        this.dispatch(actions, feedbackEmitter);
+    registerFeedback(feedbackEmitter: IFeedbackEmitter, feedbackActions: Action[], cleanupActions?: Action[] | undefined): Disposable {
+        this.registeredFeedback.set(feedbackEmitter, feedbackActions);
+        this.dispatchFeedback(feedbackActions, feedbackEmitter);
+        return Disposable.create(() => this.deregisterFeedback(feedbackEmitter, cleanupActions));
     }
 
-    deregisterFeedback(feedbackEmitter: IFeedbackEmitter, actions: Action[]): void {
-        this.feedbackEmitters.delete(feedbackEmitter);
-        this.dispatch(actions, feedbackEmitter);
-    }
-
-    private dispatch(actions: Action[], feedbackEmitter: IFeedbackEmitter): void {
-        this.actionDispatcher()
-            .then(dispatcher => dispatcher.dispatchAll(actions))
-            .then(() => this.logger.info(this, `Dispatched feedback actions for ${feedbackEmitter}`))
-            .catch(reason => this.logger.error(this, 'Failed to dispatch feedback actions', reason));
+    deregisterFeedback(feedbackEmitter: IFeedbackEmitter, cleanupActions?: Action[] | undefined): void {
+        this.registeredFeedback.delete(feedbackEmitter);
+        if (cleanupActions) {
+            this.dispatchFeedback(cleanupActions, feedbackEmitter);
+        }
     }
 
     getRegisteredFeedback(): Action[] {
         const result: Action[] = [];
-        this.feedbackEmitters.forEach((value, key) => result.push(...value));
+        this.registeredFeedback.forEach(actions => result.push(...actions));
         return result;
     }
 
     getRegisteredFeedbackEmitters(action: Action): IFeedbackEmitter[] {
         const result: IFeedbackEmitter[] = [];
-        this.feedbackEmitters.forEach((value, key) => {
-            if (value.find(a => a === action)) {
-                result.push(key);
+        this.registeredFeedback.forEach((actions, emitter) => {
+            if (actions.includes(action)) {
+                result.push(emitter);
             }
         });
         return result;
     }
+
+    protected async dispatchFeedback(actions: Action[], feedbackEmitter: IFeedbackEmitter): Promise<void> {
+        try {
+            const actionDispatcher = await this.actionDispatcher();
+            await actionDispatcher.dispatchAll(actions);
+            this.logger.info(this, `Dispatched feedback actions for ${feedbackEmitter}`);
+        } catch (reason) {
+            this.logger.error(this, 'Failed to dispatch feedback actions', reason);
+        }
+    }
 }

package/src/base/{model → feedback}/update-model-command.ts

@@ -13,46 +13,25 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { inject, injectable, multiInject, optional } from 'inversify';
+import { inject, injectable, optional } from 'inversify';
 import {
-    Action,
     ActionHandlerRegistry,
     Animation,
     Command,
     CommandActionHandler,
     CommandExecutionContext,
     CommandReturn,
-    IActionHandler,
     ILogger,
     MorphEdgesAnimation,
     SModelRoot,
-    SetModelAction,
     TYPES,
     UpdateAnimationData,
     UpdateModelAction,
     UpdateModelCommand,
     toTypeGuard
 } from '~glsp-sprotty';
-import { IFeedbackActionDispatcher } from '../../features/tool-feedback/feedback-action-dispatcher';
-import { FeedbackCommand } from '../../features/tool-feedback/model';
-
-/**
- * ActionHandler that transforms a {@link SetModelAction} into an {@link UpdateModelAction} that can be handled
- * by the {@link FeedbackAwareUpdateModelCommand}. This can be done because in sprotty an {@link UpdateModelCommand} and
- * a {@link SetModelCommand} have the same behavior of no model is present yet.
- */
-@injectable()
-export class SetModelActionHandler implements IActionHandler {
-    handle(action: Action): Action | void {
-        if (SetModelAction.is(action)) {
-            return UpdateModelAction.create(action.newRoot, { animate: false });
-        }
-    }
-}
-
-export interface SModelRootListener {
-    modelRootChanged(root: Readonly<SModelRoot>): void;
-}
+import { IFeedbackActionDispatcher } from './feedback-action-dispatcher';
+import { FeedbackCommand } from './feedback-command';
 
 /**
  * A special {@link UpdateModelCommand} that retrieves all registered {@link Action}s from the {@link IFeedbackActionDispatcher}
@@ -68,10 +47,6 @@ export class FeedbackAwareUpdateModelCommand extends UpdateModelCommand {
     @optional()
     protected feedbackActionDispatcher: IFeedbackActionDispatcher;
 
-    @multiInject(TYPES.SModelRootListener)
-    @optional()
-    protected modelRootListeners: SModelRootListener[] = [];
-
     protected actionHandlerRegistry?: ActionHandlerRegistry;
 
     constructor(
@@ -96,7 +71,6 @@ export class FeedbackAwareUpdateModelCommand extends UpdateModelCommand {
             feedbackCommands.forEach(command => command.execute(tempContext));
         }
 
-        this.modelRootListeners.forEach(listener => listener.modelRootChanged(newRoot));
         return super.performUpdate(oldRoot, newRoot, context);
     }
 

package/src/base/{focus-tracker.ts → focus/focus-tracker.ts}

@@ -15,7 +15,7 @@
  ********************************************************************************/
 import { inject, injectable } from 'inversify';
 import { Action, IActionHandler, ICommand, TYPES, ViewerOptions } from '~glsp-sprotty';
-import { FocusStateChangedAction } from './actions/focus-change-action';
+import { FocusStateChangedAction } from './focus-state-change-action';
 
 @injectable()
 export class FocusTracker implements IActionHandler {

package/src/base/ranked.ts

@@ -0,0 +1,42 @@
+/********************************************************************************
+ * 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 { AnyObject, hasNumberProp } from '~glsp-sprotty';
+
+/**
+ * A common interface for services/listeners that should be
+ * orderable by a type or rank/priority.
+ */
+export interface Ranked {
+    rank: number;
+}
+
+export namespace Ranked {
+    export const DEFAULT_RANK = 0;
+    export function is(object: unknown): object is Ranked {
+        return AnyObject.is(object) && hasNumberProp(object, 'rank');
+    }
+
+    /**
+     * Tries to retrieve the rank form the given object. If the object
+     * implements the {@link Ranked} interface the corresponding rank is returned
+     * otherwise the {@link DEFAULT_RANK} is returned.
+     * @param object
+     */
+    export function getRank(object: unknown): number {
+        return is(object) ? object.rank : DEFAULT_RANK;
+    }
+}