@vived/app 2.23.0 → 2.26.0

package/lib/Controllers/HoverLabelMouse.d.ts

@@ -0,0 +1,10 @@
+import { Babylon, HoverLabels, MouseController, MouseInput, MouseInputEvent } from "../Entities";
+import { Vector2 } from "../ValueObjects";
+export declare class HoverLabelMouse implements MouseController {
+    private hoverLabels;
+    private currentTimeout;
+    tryHoverLabelUC: (position: Vector2) => void;
+    readonly hoverLabelDelay = 500;
+    onMove: (e: MouseInputEvent) => void;
+    constructor(hoverLabels: HoverLabels, mouseInput: MouseInput, babylon: Babylon);
+}

package/lib/Controllers/HoverLabelMouse.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HoverLabelMouse = void 0;
+const trySetHoverLabel_1 = require("../UseCases/HoverLabels/trySetHoverLabel");
+class HoverLabelMouse {
+    constructor(hoverLabels, mouseInput, babylon) {
+        this.hoverLabels = hoverLabels;
+        this.hoverLabelDelay = 500;
+        this.onMove = (e) => {
+            this.hoverLabels.hideHoverLabel();
+            if (this.currentTimeout) {
+                clearTimeout(this.currentTimeout);
+            }
+            this.currentTimeout = setTimeout(() => {
+                this.tryHoverLabelUC(e.position);
+                this.currentTimeout = undefined;
+            }, this.hoverLabelDelay);
+        };
+        mouseInput.registerController(this);
+        this.tryHoverLabelUC = trySetHoverLabel_1.makeTrySetHoverLabel(hoverLabels, babylon);
+    }
+}
+exports.HoverLabelMouse = HoverLabelMouse;

package/lib/Controllers/HoverLabelTouch.d.ts

@@ -0,0 +1,14 @@
+import { Babylon, HoverLabels, TouchController, TouchInput, TouchInputEvent } from "../Entities";
+import { Vector2 } from "../ValueObjects";
+export declare const touchLabelDragThreshold = 15;
+export declare class HoverLabelTouch implements TouchController {
+    private hoverLabels;
+    private lastPosition;
+    private startPosition;
+    private touchStarted;
+    tryHoverLabelUC: (position: Vector2) => void;
+    onTouchStart: (e: TouchInputEvent) => void;
+    onTouchMove: (e: TouchInputEvent) => void;
+    onTouchEnd: () => void;
+    constructor(hoverLabels: HoverLabels, touchInput: TouchInput, babylon: Babylon);
+}

package/lib/Controllers/HoverLabelTouch.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HoverLabelTouch = exports.touchLabelDragThreshold = void 0;
+const UseCases_1 = require("../UseCases");
+const ValueObjects_1 = require("../ValueObjects");
+exports.touchLabelDragThreshold = 15;
+class HoverLabelTouch {
+    constructor(hoverLabels, touchInput, babylon) {
+        this.hoverLabels = hoverLabels;
+        this.lastPosition = ValueObjects_1.Vector2.Zero();
+        this.startPosition = ValueObjects_1.Vector2.Zero();
+        this.touchStarted = false;
+        this.onTouchStart = (e) => {
+            this.hoverLabels.hideHoverLabel();
+            this.touchStarted = false;
+            if (e.touchCount !== 1)
+                return;
+            this.startPosition = e.touches[0].position;
+            this.lastPosition = e.touches[0].position;
+            this.touchStarted = true;
+        };
+        this.onTouchMove = (e) => {
+            if (!this.touchStarted)
+                return;
+            this.lastPosition = e.touches[0].position;
+        };
+        this.onTouchEnd = () => {
+            if (!this.touchStarted)
+                return;
+            const xDiff = this.lastPosition.x - this.startPosition.x;
+            const yDiff = this.lastPosition.y - this.startPosition.y;
+            const dist = Math.sqrt(xDiff * xDiff + yDiff * yDiff);
+            if (dist < exports.touchLabelDragThreshold) {
+                this.tryHoverLabelUC(this.lastPosition);
+            }
+        };
+        touchInput.registerController(this);
+        this.tryHoverLabelUC = UseCases_1.makeTrySetHoverLabel(hoverLabels, babylon);
+    }
+}
+exports.HoverLabelTouch = HoverLabelTouch;

package/lib/Controllers/ToolHotkeys.d.ts

@@ -0,0 +1,6 @@
+import { KeyboardController, KeyboardInput, ToolRepository } from "../Entities";
+export declare class ToolHotkeys<ToolTypes> implements KeyboardController {
+    private toolRepo;
+    onKeyDown: (e: KeyboardEvent) => void;
+    constructor(toolRepo: ToolRepository<ToolTypes>, keyboardInput: KeyboardInput);
+}

package/lib/Controllers/ToolHotkeys.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToolHotkeys = void 0;
+class ToolHotkeys {
+    constructor(toolRepo, keyboardInput) {
+        this.toolRepo = toolRepo;
+        this.onKeyDown = (e) => {
+            if (e.repeat)
+                return;
+            const currentKey = {
+                keyCode: e.code,
+                alt: e.altKey,
+                control: e.ctrlKey,
+                meta: e.metaKey,
+                shift: e.shiftKey,
+            };
+            const tool = this.toolRepo.getToolForHotkey(currentKey);
+            if (!tool)
+                return;
+            this.toolRepo.triggerTool(tool.type);
+        };
+        keyboardInput.registerController(this);
+    }
+}
+exports.ToolHotkeys = ToolHotkeys;

package/lib/Controllers/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./ToolHotkeys";
+export * from "./HoverLabelTouch";
+export * from "./HoverLabelMouse";

package/lib/Controllers/index.js

@@ -0,0 +1,15 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./ToolHotkeys"), exports);
+__exportStar(require("./HoverLabelTouch"), exports);
+__exportStar(require("./HoverLabelMouse"), exports);

package/lib/Entities/HoverLabels.d.ts

@@ -0,0 +1,42 @@
+import { Vector2 } from "../ValueObjects";
+import { ObservableEntity } from "./ObservableEntity";
+export declare abstract class HoverLabels extends ObservableEntity {
+    /**
+     * Should the label be shown
+     */
+    abstract get show(): boolean;
+    /**
+     * Pixel coordinates of the label
+     */
+    abstract get position(): Vector2;
+    /**
+     * String to display
+     */
+    abstract get label(): string;
+    /**
+     * Gets if hover labels should be allowed
+     */
+    abstract get allowHoverLabels(): boolean;
+    /**
+     * Sets if hover labels should be shown. Will notify
+     */
+    abstract set allowHoverLabels(allow: boolean);
+    /**
+     * Sets up a label for a scene object by id
+     */
+    abstract setLabelForSceneObject: (sceneObjectID: string, label: string) => void;
+    /**
+     * Removes the labels for a scene object by id
+     */
+    abstract removeLabelForSceneObject: (sceneObjectID: string) => void;
+    /**
+     * Tries to get a label for a scene object by id. Returns undefined if one does not exist
+     */
+    abstract getLabelFroSceneObject: (sceneObjectID: string) => string | undefined;
+    /**
+     * Sets up the system to show a label for a scene object at a given position
+     */
+    abstract showLabelForSceneObject: (sceneObjectID: string, position: Vector2) => void;
+    abstract hideHoverLabel: () => void;
+}
+export declare function makeHoverLabels(): HoverLabels;

package/lib/Entities/HoverLabels.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeHoverLabels = exports.HoverLabels = void 0;
+const ValueObjects_1 = require("../ValueObjects");
+const MemoizedBoolean_1 = require("./MemoizedBoolean");
+const ObservableEntity_1 = require("./ObservableEntity");
+class HoverLabels extends ObservableEntity_1.ObservableEntity {
+}
+exports.HoverLabels = HoverLabels;
+function makeHoverLabels() {
+    return new HoverLabelsImp();
+}
+exports.makeHoverLabels = makeHoverLabels;
+class HoverLabelsImp extends HoverLabels {
+    constructor() {
+        super(...arguments);
+        this.labelLookup = new Map();
+        this._show = false;
+        this._position = ValueObjects_1.Vector2.Zero();
+        this._label = "";
+        this.memoizedAllow = new MemoizedBoolean_1.MemoizedBoolean(true, this.notify);
+        this.setLabelForSceneObject = (sceneObjectID, label) => {
+            this.labelLookup.set(sceneObjectID, label);
+        };
+        this.removeLabelForSceneObject = (sceneObjectID) => {
+            this.labelLookup.delete(sceneObjectID);
+        };
+        this.getLabelFroSceneObject = (sceneObjectID) => {
+            return this.labelLookup.get(sceneObjectID);
+        };
+        this.showLabelForSceneObject = (sceneObjectID, position) => {
+            var _a;
+            if (this.labelLookup.has(sceneObjectID)) {
+                this.doShow((_a = this.labelLookup.get(sceneObjectID)) !== null && _a !== void 0 ? _a : "", position);
+            }
+            else {
+                this.hideHoverLabel();
+            }
+        };
+        this.hideHoverLabel = () => {
+            if (!this._show)
+                return;
+            this._show = false;
+            this._label = "";
+            this._position = ValueObjects_1.Vector2.Zero();
+            this.notify();
+        };
+    }
+    get show() {
+        return this._show;
+    }
+    get position() {
+        return this._position;
+    }
+    get label() {
+        return this._label;
+    }
+    get allowHoverLabels() {
+        return this.memoizedAllow.val;
+    }
+    set allowHoverLabels(allow) {
+        if (allow === this.memoizedAllow.val)
+            return;
+        this.memoizedAllow.val = allow;
+        if (allow === false) {
+            this.hideHoverLabel();
+        }
+    }
+    doShow(label, pos) {
+        if (!this.allowHoverLabels)
+            return;
+        if (label === this._label &&
+            ValueObjects_1.Vector2.Equal(pos, this._position) &&
+            this.show) {
+            return;
+        }
+        this._label = label;
+        this._position = pos;
+        this._show = true;
+        this.notify();
+    }
+}

package/lib/Entities/MessageSystem.d.ts

@@ -0,0 +1,14 @@
+import { Result } from "../ValueObjects";
+export declare type MessageDataFile = {
+    [key: string]: string;
+};
+export interface MessageSystem {
+    setMessages: (messages: MessageDataFile) => void;
+    getMessage: (keyword: string) => Result<string, Error>;
+}
+export declare class MessageSystemImp implements MessageSystem {
+    private messages;
+    setMessages: (messages: MessageDataFile) => void;
+    getMessage: (keyword: string) => Result<string, Error>;
+}
+export declare function makeMessageSystem(): MessageSystem;

package/lib/Entities/MessageSystem.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeMessageSystem = exports.MessageSystemImp = void 0;
+const ValueObjects_1 = require("../ValueObjects");
+class MessageSystemImp {
+    constructor() {
+        this.messages = new Map();
+        this.setMessages = (messages) => {
+            for (const keyword in messages) {
+                if (messages.hasOwnProperty(keyword)) {
+                    const message = messages[keyword];
+                    this.messages.set(keyword, message);
+                }
+            }
+        };
+        this.getMessage = (keyword) => {
+            const message = this.messages.get(keyword);
+            if (message) {
+                return new ValueObjects_1.Resolved(message);
+            }
+            else {
+                const err = new Error("Message System cant find message from keyword: " + keyword);
+                return new ValueObjects_1.Rejected(err);
+            }
+        };
+    }
+}
+exports.MessageSystemImp = MessageSystemImp;
+function makeMessageSystem() {
+    return new MessageSystemImp();
+}
+exports.makeMessageSystem = makeMessageSystem;

package/lib/Entities/Tool.d.ts

@@ -1,41 +1,52 @@
 import { ObservableEntity } from "./ObservableEntity";
 export declare enum ToolState {
-    HIDDEN = 0,
-    DISABLED = 1,
-    ENABLED = 2,
-    ACTIVE = 3
+    HIDDEN = "HIDDEN",
+    DISABLED = "DISABLED",
+    ENABLED = "ENABLED",
+    ACTIVE = "ACTIVE"
 }
-export interface ToolData {
-    id: string;
+export interface ToolData<ToolTypes> {
+    type: ToolTypes;
     isDefault: boolean;
     label: string;
     shortcutLabel: string;
+    hotkeys: HotKey[];
+}
+export interface HotKey {
     keyCode: string;
+    control?: boolean;
+    shift?: boolean;
+    meta?: boolean;
+    alt?: boolean;
 }
-export declare abstract class Tool extends ObservableEntity {
+export declare abstract class Tool<ToolTypes> extends ObservableEntity {
     /**
-     * The tool's unique identifier
+     * The tool's type
      */
-    abstract readonly id: string;
+    abstract readonly type: ToolTypes;
     /**
-     * The shortcut key code for this tool.
-     * Example: 'KeyZ'
+     * Gets label for this tool. This will be human readable
      */
-    abstract readonly keyCode: string;
+    abstract get label(): string;
     /**
-     * The label for this tool. This should be human readable
+     * Sets label for this tool. This should be human readable. A change will notify
      */
-    abstract readonly label: string;
+    abstract set label(toolLabel: string);
     /**
      * Is this the default tool? The default tool is what is initiall set Active and
      * is what will be set active if the currently active tool is hidden or disabled.
      */
     abstract readonly isDefault: boolean;
     /**
-     * The keyboard shorcut label. This will be displayed to the user via the tool tip
+     * Gets the keyboard shorcut label. This will be displayed to the user via the tool tip
      * Example 'z'
      */
-    abstract readonly shortcutLabel: string;
+    abstract get shortcutLabel(): string;
+    /**
+     * Sets the keyboard shorcut label. This will be displayed to the user via the tool tip
+     * Example 'z'. This will notify when changed
+     */
+    abstract set shortcutLabel(shorcut: string);
     /**
      * Get the current tool state
      */
@@ -44,5 +55,27 @@ export declare abstract class Tool extends ObservableEntity {
      * Sets the current tool state. This will notify on change
      */
     abstract set state(val: ToolState);
+    /**
+     * The keyboard shortcuts for this tool
+     */
+    abstract readonly hotkeys: HotKey[];
+    /**
+     * Is this tool an action tool. In other words do you just click it and something should happen
+     */
+    abstract get isAction(): boolean;
+    /**
+     * If this is an action tool calling this will trigger any actions that have been registered
+     */
+    abstract triggerActions(): void;
+    /**
+     * Registers an action with this tool. This action will be called when this tool is triggered
+     * @param action The action to call when this tool is triggered
+     */
+    abstract registerAction(action: () => void): void;
+    /**
+     * Returns a true if the passed hotkey is in my hotkey list
+     * @param hotkey The Hotkey to chekc
+     */
+    abstract isMyHotkey(hotkey: HotKey): boolean;
 }
-export declare function makeTool(data: ToolData): Tool;
+export declare function makeTool<ToolTypes>(data: ToolData<ToolTypes>): Tool<ToolTypes>;

package/lib/Entities/Tool.js

@@ -1,14 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeTool = exports.Tool = exports.ToolState = void 0;
-const MemoizedNumber_1 = require("./MemoizedNumber");
+const MemoizedString_1 = require("./MemoizedString");
 const ObservableEntity_1 = require("./ObservableEntity");
 var ToolState;
 (function (ToolState) {
-    ToolState[ToolState["HIDDEN"] = 0] = "HIDDEN";
-    ToolState[ToolState["DISABLED"] = 1] = "DISABLED";
-    ToolState[ToolState["ENABLED"] = 2] = "ENABLED";
-    ToolState[ToolState["ACTIVE"] = 3] = "ACTIVE";
+    ToolState["HIDDEN"] = "HIDDEN";
+    ToolState["DISABLED"] = "DISABLED";
+    ToolState["ENABLED"] = "ENABLED";
+    ToolState["ACTIVE"] = "ACTIVE";
 })(ToolState = exports.ToolState || (exports.ToolState = {}));
 class Tool extends ObservableEntity_1.ObservableEntity {
 }
@@ -20,12 +20,44 @@ exports.makeTool = makeTool;
 class ToolImp extends Tool {
     constructor(data) {
         super();
-        this.memoizedState = new MemoizedNumber_1.MemoizedNumber(ToolState.ENABLED, this.notify);
-        this.id = data.id;
-        this.keyCode = data.keyCode;
-        this.label = data.label;
+        this.memoizedState = new MemoizedString_1.MemoizedString(ToolState.ENABLED, this.notify);
+        this.actions = [];
+        this._isAction = false;
+        this.registerAction = (action) => {
+            this.actions.push(action);
+            this._isAction = true;
+        };
+        this.triggerActions = () => {
+            this.actions.forEach((action) => {
+                action();
+            });
+        };
+        this.isMyHotkey = (hotkey) => {
+            let isMine = false;
+            this.hotkeys.forEach((myHotkey) => {
+                if (this.hotkeysMatch(myHotkey, hotkey)) {
+                    isMine = true;
+                }
+            });
+            return isMine;
+        };
+        this.type = data.type;
+        this.memoizedLabel = new MemoizedString_1.MemoizedString(data.label, this.notify);
         this.isDefault = data.isDefault;
-        this.shortcutLabel = data.shortcutLabel;
+        this.memoizedShortcut = new MemoizedString_1.MemoizedString(data.shortcutLabel, this.notify);
+        this.hotkeys = data.hotkeys;
+    }
+    get label() {
+        return this.memoizedLabel.val;
+    }
+    set label(toolLabel) {
+        this.memoizedLabel.val = toolLabel;
+    }
+    get shortcutLabel() {
+        return this.memoizedShortcut.val;
+    }
+    set shortcutLabel(shorcut) {
+        this.memoizedShortcut.val = shorcut;
     }
     get state() {
         return this.memoizedState.val;
@@ -33,4 +65,30 @@ class ToolImp extends Tool {
     set state(val) {
         this.memoizedState.val = val;
     }
+    get isAction() {
+        return this._isAction;
+    }
+    hotkeysMatch(a, b) {
+        if (a.keyCode !== b.keyCode)
+            return false;
+        const aComplete = this.fillInMissingModifiers(a);
+        const bComplete = this.fillInMissingModifiers(b);
+        if (aComplete.alt !== bComplete.alt)
+            return false;
+        if (aComplete.control !== bComplete.control)
+            return false;
+        if (aComplete.meta !== bComplete.meta)
+            return false;
+        if (aComplete.shift !== bComplete.shift)
+            return false;
+        return true;
+    }
+    fillInMissingModifiers(hotkey) {
+        const rVal = Object.assign({}, hotkey);
+        rVal.alt = hotkey.alt === undefined ? false : hotkey.alt;
+        rVal.control = hotkey.control === undefined ? false : hotkey.control;
+        rVal.meta = hotkey.meta === undefined ? false : hotkey.meta;
+        rVal.shift = hotkey.shift === undefined ? false : hotkey.shift;
+        return rVal;
+    }
 }

package/lib/Entities/ToolRepository.d.ts

@@ -1,46 +1,46 @@
 import { ObservableEntity } from "./ObservableEntity";
-import { Tool, ToolData } from "./Tool";
-export declare abstract class ToolRepository extends ObservableEntity {
+import { HotKey, Tool, ToolData } from "./Tool";
+export declare abstract class ToolRepository<ToolTypes> extends ObservableEntity {
     /**
      * Retuns the active tool. If no tool is active it will return undefined.
      */
-    abstract get activeTool(): Tool | undefined;
+    abstract get activeTool(): Tool<ToolTypes> | undefined;
     /**
      * Returns all the tools.
      */
-    abstract get allTools(): Tool[];
+    abstract get allTools(): Tool<ToolTypes>[];
     /**
      * Set up the tools from a JSON data file. This should be called during construction.
      * It is assumed this is only called once.
      * @param toolData
      */
-    abstract setupToolsFromData(toolData: ToolData[]): void;
+    abstract setupToolsFromData(toolData: ToolData<ToolTypes>[]): void;
     /**
-     * Get's a tool by it's ID. Retruns undefined if no tool could be found
-     * @param id The tool ID
+     * Get's a tool by it's type. Retruns undefined if no tool could be found
+     * @param toolType The tool type
      */
-    abstract getTool(id: string): Tool | undefined;
+    abstract getTool(toolType: ToolTypes): Tool<ToolTypes> | undefined;
     /**
      * Returns the tool that has been assinged to a particular key code.
      * Will return undefined of no tool is found
-     * @param keyCode Key Code
+     * @param hotkey Key Code
      */
-    abstract getToolForKey(keyCode: string): Tool | undefined;
+    abstract getToolForHotkey(hotkey: HotKey): Tool<ToolTypes> | undefined;
     /**
      * Call this to set the default tool as active
      */
     abstract setDefaultToolActive(): void;
     /**
-     * Sets a tool active by ID.
-     * @param id Tool ID
+     * Triggers a tool of type
+     * @param toolType Tool's type
      */
-    abstract setToolActive(id: string): void;
+    abstract triggerTool(toolType: ToolTypes): void;
     /**
      * Toggls a tool between Hidden and shown.
      * If the tool is tool is currently Active, the default tool will be set active
      * The Default Tool cannot be toggled
-     * @param id Tool ID
+     * @param toolType Tool's type
      */
-    abstract toggleToolVisibility(id: string): void;
+    abstract toggleToolVisibility(toolType: ToolTypes): void;
 }
-export declare function makeToolRepo(): ToolRepository;
+export declare function makeToolRepo<ToolTypes>(): ToolRepository<ToolTypes>;

package/lib/Entities/ToolRepository.js

@@ -14,15 +14,13 @@ class ToolRepositoryImp extends ToolRepository {
     constructor() {
         super(...arguments);
         this.toolLookup = new Map();
-        this._defaultToolID = "";
-        this._activeToolID = "";
     }
     get allTools() {
         return Array.from(this.toolLookup.values());
     }
     setDefaultToolActive() {
-        if (this._defaultToolID) {
-            this.setToolActive(this._defaultToolID);
+        if (this._defaultToolType !== undefined) {
+            this.triggerTool(this._defaultToolType);
         }
         else {
             console.warn(`[ToolRepository] No default tools has been specified`);
@@ -30,58 +28,65 @@ class ToolRepositoryImp extends ToolRepository {
     }
     setupToolsFromData(toolDatas) {
         toolDatas.forEach((toolData) => {
-            if (this.toolLookup.has(toolData.id)) {
-                console.warn(`[ToolRepository] A tool with the ID ${toolData.id} already exists. Replacing`);
+            const type = toolData.type;
+            if (this.toolLookup.has(type)) {
+                console.warn(`[ToolRepository] A tool with the ID ${toolData.type} already exists. Replacing`);
             }
             const tool = Tool_1.makeTool(toolData);
-            this.toolLookup.set(tool.id, tool);
+            this.toolLookup.set(type, tool);
             if (toolData.isDefault) {
-                if (this._defaultToolID) {
+                if (this._defaultToolType) {
                     console.warn(`[ToolRepository] More than one tools is marked as default. Replacing`);
                 }
-                this._defaultToolID = tool.id;
+                this._defaultToolType = type;
             }
         });
-        if (!this._defaultToolID) {
+        if (!this._defaultToolType) {
             console.warn(`[ToolRepository] No default tools was specified. Defaulting to the first tool in the list`);
-            this._defaultToolID = Array.from(this.toolLookup.values())[0].id;
+            this._defaultToolType = Array.from(this.toolLookup.keys())[0];
+        }
+        if (this._defaultToolType) {
+            this.triggerTool(this._defaultToolType);
         }
-        this.setToolActive(this._defaultToolID);
     }
-    getTool(id) {
-        return this.toolLookup.get(id);
+    getTool(type) {
+        return this.toolLookup.get(type);
     }
-    getToolForKey(keyCode) {
+    getToolForHotkey(hotkey) {
         let tool;
         this.allTools.forEach((t) => {
-            if (t.keyCode === keyCode) {
+            if (t.isMyHotkey(hotkey)) {
                 tool = t;
             }
         });
         return tool;
     }
     get activeTool() {
-        return this.getTool(this._activeToolID);
+        if (!this._activeToolType)
+            return undefined;
+        return this.getTool(this._activeToolType);
     }
-    setToolActive(id) {
-        if (this._activeToolID === id)
+    triggerTool(type) {
+        if (this._activeToolType === type)
             return;
-        const newActiveTool = this.toolLookup.get(id);
+        const newActiveTool = this.toolLookup.get(type);
         if (!newActiveTool) {
-            console.warn(`[ToolRepository] Unable to find tool ${id}`);
+            console.warn(`[ToolRepository] Unable to find tool ${type}`);
+            return;
+        }
+        if (newActiveTool.isAction) {
+            newActiveTool.triggerActions();
             return;
         }
         if (newActiveTool.state === Tool_1.ToolState.DISABLED) {
-            console.warn(`[ToolRepository] ${newActiveTool.label} cannot be set active because it is disabled`);
             return;
         }
         if (newActiveTool.state === Tool_1.ToolState.HIDDEN) {
-            console.warn(`[ToolRepository] ${newActiveTool.label} cannot be set active because it is hidden`);
             return;
         }
         this.toolLookup.forEach((tool) => {
-            if (tool.id === id) {
-                this._activeToolID = id;
+            if (tool.type === type) {
+                this._activeToolType = type;
                 tool.state = Tool_1.ToolState.ACTIVE;
             }
             else if (tool.state === Tool_1.ToolState.ACTIVE) {
@@ -90,13 +95,13 @@ class ToolRepositoryImp extends ToolRepository {
         });
         this.notify();
     }
-    toggleToolVisibility(id) {
-        const tool = this.getTool(id);
+    toggleToolVisibility(type) {
+        const tool = this.getTool(type);
         if (!tool) {
-            console.warn(`[ToolRepository] Unable to find tool to toggle: ${id}`);
+            console.warn(`[ToolRepository] Unable to find tool to toggle: ${type}`);
             return;
         }
-        if (tool.id === this._defaultToolID) {
+        if (tool.type === this._defaultToolType) {
             console.warn(`[ToolRepository] The default tool's visibility cannot be toggled`);
             return;
         }

package/lib/Entities/index.d.ts

@@ -1,12 +1,14 @@
 export * from "./Babylon";
 export * from "./BaseApp";
 export * from "./DevicePreview";
+export * from "./HoverLabels";
 export * from "./KeyboardInput";
 export * from "./MemoizedBoolean";
 export * from "./MemoizedNumber";
 export * from "./MemoizedString";
 export * from "./MemoizedVector2";
 export * from "./MemoizedVector3";
+export * from "./MessageSystem";
 export * from "./ObserverList";
 export * from "./FocusCamera";
 export * from "./StateMachine";

package/lib/Entities/index.js

@@ -13,12 +13,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./Babylon"), exports);
 __exportStar(require("./BaseApp"), exports);
 __exportStar(require("./DevicePreview"), exports);
+__exportStar(require("./HoverLabels"), exports);
 __exportStar(require("./KeyboardInput"), exports);
 __exportStar(require("./MemoizedBoolean"), exports);
 __exportStar(require("./MemoizedNumber"), exports);
 __exportStar(require("./MemoizedString"), exports);
 __exportStar(require("./MemoizedVector2"), exports);
 __exportStar(require("./MemoizedVector3"), exports);
+__exportStar(require("./MessageSystem"), exports);
 __exportStar(require("./ObserverList"), exports);
 __exportStar(require("./FocusCamera"), exports);
 __exportStar(require("./StateMachine"), exports);

package/lib/PresentationManagers/HoverLabelPM.d.ts

@@ -0,0 +1,17 @@
+import { HoverLabels } from "../Entities";
+import { PresentionManager } from "./PresentationManager";
+export interface HoverLabelVM {
+    show: boolean;
+    text: string;
+    position: {
+        x: number;
+        y: number;
+    };
+}
+export declare class HoverLabelPM extends PresentionManager {
+    private hoverLabel;
+    private updateView;
+    doUpdateView: () => void;
+    constructor(hoverLabel: HoverLabels, updateView: (vm: HoverLabelVM) => void);
+    static defaultHoverLabelVM: HoverLabelVM;
+}

package/lib/PresentationManagers/HoverLabelPM.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HoverLabelPM = void 0;
+const PresentationManager_1 = require("./PresentationManager");
+class HoverLabelPM extends PresentationManager_1.PresentionManager {
+    constructor(hoverLabel, updateView) {
+        super(hoverLabel);
+        this.hoverLabel = hoverLabel;
+        this.updateView = updateView;
+        this.doUpdateView = () => {
+            const vm = {
+                show: false,
+                text: "",
+                position: { x: 0, y: 0 },
+            };
+            if (this.hoverLabel.show) {
+                vm.show = true;
+                vm.text = this.hoverLabel.label;
+                vm.position.x = this.hoverLabel.position.x;
+                vm.position.y = this.hoverLabel.position.y;
+            }
+            this.updateView(vm);
+        };
+        this.doUpdateView();
+    }
+}
+exports.HoverLabelPM = HoverLabelPM;
+HoverLabelPM.defaultHoverLabelVM = {
+    show: false,
+    text: "",
+    position: { x: 0, y: 0 },
+};

package/lib/PresentationManagers/HoverLabels/AllowHoverLabelPM.d.ts

@@ -0,0 +1,9 @@
+import { HoverLabels } from "../../Entities";
+import { PresentionManager } from "../PresentationManager";
+export declare class AllowHoverLabelPM extends PresentionManager {
+    private hoverLabel;
+    private updateView;
+    private lastState?;
+    doUpdateView: () => void;
+    constructor(hoverLabel: HoverLabels, updateView: (allow: boolean) => void);
+}

package/lib/PresentationManagers/HoverLabels/AllowHoverLabelPM.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AllowHoverLabelPM = void 0;
+const PresentationManager_1 = require("../PresentationManager");
+class AllowHoverLabelPM extends PresentationManager_1.PresentionManager {
+    constructor(hoverLabel, updateView) {
+        super(hoverLabel);
+        this.hoverLabel = hoverLabel;
+        this.updateView = updateView;
+        this.doUpdateView = () => {
+            if (this.lastState === this.hoverLabel.allowHoverLabels)
+                return;
+            this.updateView(this.hoverLabel.allowHoverLabels);
+            this.lastState = this.hoverLabel.allowHoverLabels;
+        };
+        this.doUpdateView();
+    }
+}
+exports.AllowHoverLabelPM = AllowHoverLabelPM;

package/lib/PresentationManagers/HoverLabels/HoverLabelPM.d.ts

@@ -0,0 +1,17 @@
+import { HoverLabels } from "../../Entities";
+import { PresentionManager } from "../PresentationManager";
+export interface HoverLabelVM {
+    show: boolean;
+    text: string;
+    position: {
+        x: number;
+        y: number;
+    };
+}
+export declare class HoverLabelPM extends PresentionManager {
+    private hoverLabel;
+    private updateView;
+    doUpdateView: () => void;
+    constructor(hoverLabel: HoverLabels, updateView: (vm: HoverLabelVM) => void);
+    static defaultHoverLabelVM: HoverLabelVM;
+}

package/lib/PresentationManagers/HoverLabels/HoverLabelPM.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HoverLabelPM = void 0;
+const PresentationManager_1 = require("../PresentationManager");
+class HoverLabelPM extends PresentationManager_1.PresentionManager {
+    constructor(hoverLabel, updateView) {
+        super(hoverLabel);
+        this.hoverLabel = hoverLabel;
+        this.updateView = updateView;
+        this.doUpdateView = () => {
+            const vm = {
+                show: false,
+                text: "",
+                position: { x: 0, y: 0 },
+            };
+            if (this.hoverLabel.show) {
+                vm.show = true;
+                vm.text = this.hoverLabel.label;
+                vm.position.x = this.hoverLabel.position.x;
+                vm.position.y = this.hoverLabel.position.y;
+            }
+            this.updateView(vm);
+        };
+        this.doUpdateView();
+    }
+}
+exports.HoverLabelPM = HoverLabelPM;
+HoverLabelPM.defaultHoverLabelVM = {
+    show: false,
+    text: "",
+    position: { x: 0, y: 0 },
+};

package/lib/PresentationManagers/HoverLabels/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./HoverLabelPM";
+export * from "./AllowHoverLabelPM";

package/lib/PresentationManagers/HoverLabels/index.js

@@ -0,0 +1,14 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./HoverLabelPM"), exports);
+__exportStar(require("./AllowHoverLabelPM"), exports);

package/lib/PresentationManagers/ToolPM.d.ts

@@ -1,7 +1,7 @@
 import { Tool } from "../Entities";
 import { PresentionManager } from "./PresentationManager";
-export interface ToolVM {
-    toolID: string;
+export interface ToolVM<ToolType> {
+    type: ToolType;
     label: string;
     enabled: boolean;
     selected: boolean;
@@ -9,10 +9,9 @@ export interface ToolVM {
     shortcutLabel: string;
     tooltipLabel: string;
 }
-export declare class ToolPM extends PresentionManager {
+export declare class ToolPM<ToolType> extends PresentionManager {
     private tool;
     private updateView;
     doUpdateView: () => void;
-    constructor(tool: Tool, updateView: (tools: ToolVM) => void);
+    constructor(tool: Tool<ToolType>, updateView: (tools: ToolVM<ToolType>) => void);
 }
-export declare const defaultToolVM: ToolVM;

package/lib/PresentationManagers/ToolPM.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.defaultToolVM = exports.ToolPM = void 0;
+exports.ToolPM = void 0;
 const Entities_1 = require("../Entities");
 const PresentationManager_1 = require("./PresentationManager");
 class ToolPM extends PresentationManager_1.PresentionManager {
@@ -9,21 +9,22 @@ class ToolPM extends PresentationManager_1.PresentionManager {
         this.tool = tool;
         this.updateView = updateView;
         this.doUpdateView = () => {
+            const { type, state, label, shortcutLabel } = this.tool;
             let enabled = false;
-            if (this.tool.state === Entities_1.ToolState.ACTIVE ||
-                this.tool.state === Entities_1.ToolState.ENABLED) {
+            if (state === Entities_1.ToolState.ACTIVE ||
+                state === Entities_1.ToolState.ENABLED) {
                 enabled = true;
             }
-            const selected = this.tool.state === Entities_1.ToolState.ACTIVE ? true : false;
-            const show = this.tool.state === Entities_1.ToolState.HIDDEN ? false : true;
-            const tooltipLabel = `${this.tool.label} [${this.tool.shortcutLabel}]`;
+            const selected = state === Entities_1.ToolState.ACTIVE ? true : false;
+            const show = state === Entities_1.ToolState.HIDDEN ? false : true;
+            const tooltipLabel = `${label} [${shortcutLabel}]`;
             const vm = {
-                toolID: this.tool.id,
+                type,
                 enabled,
-                label: this.tool.label,
+                label,
                 selected,
                 show,
-                shortcutLabel: this.tool.shortcutLabel,
+                shortcutLabel,
                 tooltipLabel,
             };
             this.updateView(vm);
@@ -32,12 +33,3 @@ class ToolPM extends PresentationManager_1.PresentionManager {
     }
 }
 exports.ToolPM = ToolPM;
-exports.defaultToolVM = {
-    toolID: "",
-    enabled: false,
-    label: "",
-    selected: false,
-    shortcutLabel: "",
-    show: false,
-    tooltipLabel: "",
-};

package/lib/PresentationManagers/index.d.ts

@@ -9,3 +9,4 @@ export * from "./QuestionChallenge";
 export * from "./FocusCameraPosRotPM";
 export * from "./ToolPM";
 export * from "./TransformNodePM";
+export * from "./HoverLabels";

package/lib/PresentationManagers/index.js

@@ -21,3 +21,4 @@ __exportStar(require("./QuestionChallenge"), exports);
 __exportStar(require("./FocusCameraPosRotPM"), exports);
 __exportStar(require("./ToolPM"), exports);
 __exportStar(require("./TransformNodePM"), exports);
+__exportStar(require("./HoverLabels"), exports);

package/lib/UseCases/HoverLabels/SerializeAllowHoverLabel.d.ts

@@ -0,0 +1,14 @@
+import { HoverLabels, SerializedSystem, StateMachine } from "../../Entities";
+export declare class SerializeAllowHoverLabel implements SerializedSystem {
+    private hoverLabels;
+    name: string;
+    seriliziationVersion: number;
+    getSystemState(): object;
+    applySystemState(state: object, version: number): void;
+    applyDefaultState(): void;
+    private applyDataV1;
+    constructor(hoverLabels: HoverLabels, stateMachine: StateMachine);
+}
+export interface AllowHoverLabelV1 {
+    allow: boolean;
+}

package/lib/UseCases/HoverLabels/SerializeAllowHoverLabel.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SerializeAllowHoverLabel = void 0;
+class SerializeAllowHoverLabel {
+    constructor(hoverLabels, stateMachine) {
+        this.hoverLabels = hoverLabels;
+        this.name = "allowHoverLabel";
+        this.seriliziationVersion = 1;
+        stateMachine.registerSerializedSystem(this);
+    }
+    getSystemState() {
+        const state = {
+            allow: this.hoverLabels.allowHoverLabels
+        };
+        return state;
+    }
+    applySystemState(state, version) {
+        if (state && version === 1) {
+            const castState = state;
+            this.applyDataV1(castState);
+        }
+        else {
+            // Unsupported version
+            console.warn(`Unsupported data version ${version} for serialized system ${this.name}. Reverting to default state`);
+            this.applyDefaultState();
+        }
+    }
+    applyDefaultState() {
+        this.hoverLabels.allowHoverLabels = true;
+    }
+    applyDataV1(data) {
+        this.hoverLabels.allowHoverLabels = data.allow;
+    }
+}
+exports.SerializeAllowHoverLabel = SerializeAllowHoverLabel;

package/lib/UseCases/HoverLabels/trySetHoverLabel.d.ts

@@ -0,0 +1,3 @@
+import { Babylon, HoverLabels } from "../../Entities";
+import { Vector2 } from "../../ValueObjects";
+export declare function makeTrySetHoverLabel(hoverLabels: HoverLabels, babylon: Babylon): (position: Vector2) => void;

package/lib/UseCases/HoverLabels/trySetHoverLabel.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeTrySetHoverLabel = void 0;
+function makeTrySetHoverLabel(hoverLabels, babylon) {
+    return function trySetHoverLabel(position) {
+        babylon.sceneObjectPick(position).then(sceneObjectID => {
+            hoverLabels.showLabelForSceneObject(sceneObjectID, position);
+        });
+    };
+}
+exports.makeTrySetHoverLabel = makeTrySetHoverLabel;

package/lib/UseCases/index.d.ts

@@ -3,3 +3,5 @@ export * from "./FocusCamera";
 export * from "./QuestionChallenge";
 export * from "./LerpVector3";
 export * from "./SceneRoot";
+export * from "./HoverLabels/trySetHoverLabel";
+export * from "./HoverLabels/SerializeAllowHoverLabel";

package/lib/UseCases/index.js

@@ -15,3 +15,5 @@ __exportStar(require("./FocusCamera"), exports);
 __exportStar(require("./QuestionChallenge"), exports);
 __exportStar(require("./LerpVector3"), exports);
 __exportStar(require("./SceneRoot"), exports);
+__exportStar(require("./HoverLabels/trySetHoverLabel"), exports);
+__exportStar(require("./HoverLabels/SerializeAllowHoverLabel"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vived/app",
-  "version": "2.23.0",
+  "version": "2.26.0",
   "description": "Public package for the VIVED Learning App system",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",