@vived/app 2.25.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/index.d.ts

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

package/lib/Controllers/index.js

@@ -11,3 +11,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 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/index.d.ts

@@ -1,6 +1,7 @@
 export * from "./Babylon";
 export * from "./BaseApp";
 export * from "./DevicePreview";
+export * from "./HoverLabels";
 export * from "./KeyboardInput";
 export * from "./MemoizedBoolean";
 export * from "./MemoizedNumber";

package/lib/Entities/index.js

@@ -13,6 +13,7 @@ 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);

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/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.25.0",
+  "version": "2.26.0",
   "description": "Public package for the VIVED Learning App system",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",