@vived/app 2.21.2 → 2.23.0

package/lib/Entities/ObservableEntity.d.ts

@@ -0,0 +1,7 @@
+export declare type EntityObserver = () => void;
+export declare abstract class ObservableEntity {
+    private observerList;
+    addObserver: (observer: EntityObserver) => void;
+    removeObserver: (observer: EntityObserver) => void;
+    notify: () => void;
+}

package/lib/Entities/ObservableEntity.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObservableEntity = void 0;
+const ObserverList_1 = require("./ObserverList");
+class ObservableEntity {
+    constructor() {
+        this.observerList = new ObserverList_1.ObserverList();
+        this.addObserver = (observer) => {
+            this.observerList.add(observer);
+        };
+        this.removeObserver = (observer) => {
+            this.observerList.remove(observer);
+        };
+        this.notify = () => {
+            this.observerList.notify();
+        };
+    }
+}
+exports.ObservableEntity = ObservableEntity;

package/lib/Entities/Tool.d.ts

@@ -0,0 +1,48 @@
+import { ObservableEntity } from "./ObservableEntity";
+export declare enum ToolState {
+    HIDDEN = 0,
+    DISABLED = 1,
+    ENABLED = 2,
+    ACTIVE = 3
+}
+export interface ToolData {
+    id: string;
+    isDefault: boolean;
+    label: string;
+    shortcutLabel: string;
+    keyCode: string;
+}
+export declare abstract class Tool extends ObservableEntity {
+    /**
+     * The tool's unique identifier
+     */
+    abstract readonly id: string;
+    /**
+     * The shortcut key code for this tool.
+     * Example: 'KeyZ'
+     */
+    abstract readonly keyCode: string;
+    /**
+     * The label for this tool. This should be human readable
+     */
+    abstract readonly label: 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
+     * Example 'z'
+     */
+    abstract readonly shortcutLabel: string;
+    /**
+     * Get the current tool state
+     */
+    abstract get state(): ToolState;
+    /**
+     * Sets the current tool state. This will notify on change
+     */
+    abstract set state(val: ToolState);
+}
+export declare function makeTool(data: ToolData): Tool;

package/lib/Entities/Tool.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeTool = exports.Tool = exports.ToolState = void 0;
+const MemoizedNumber_1 = require("./MemoizedNumber");
+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 = exports.ToolState || (exports.ToolState = {}));
+class Tool extends ObservableEntity_1.ObservableEntity {
+}
+exports.Tool = Tool;
+function makeTool(data) {
+    return new ToolImp(data);
+}
+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.isDefault = data.isDefault;
+        this.shortcutLabel = data.shortcutLabel;
+    }
+    get state() {
+        return this.memoizedState.val;
+    }
+    set state(val) {
+        this.memoizedState.val = val;
+    }
+}

package/lib/Entities/ToolRepository.d.ts

@@ -0,0 +1,46 @@
+import { ObservableEntity } from "./ObservableEntity";
+import { Tool, ToolData } from "./Tool";
+export declare abstract class ToolRepository extends ObservableEntity {
+    /**
+     * Retuns the active tool. If no tool is active it will return undefined.
+     */
+    abstract get activeTool(): Tool | undefined;
+    /**
+     * Returns all the tools.
+     */
+    abstract get allTools(): Tool[];
+    /**
+     * 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;
+    /**
+     * Get's a tool by it's ID. Retruns undefined if no tool could be found
+     * @param id The tool ID
+     */
+    abstract getTool(id: string): Tool | 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
+     */
+    abstract getToolForKey(keyCode: string): Tool | undefined;
+    /**
+     * Call this to set the default tool as active
+     */
+    abstract setDefaultToolActive(): void;
+    /**
+     * Sets a tool active by ID.
+     * @param id Tool ID
+     */
+    abstract setToolActive(id: string): 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
+     */
+    abstract toggleToolVisibility(id: string): void;
+}
+export declare function makeToolRepo(): ToolRepository;

package/lib/Entities/ToolRepository.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeToolRepo = exports.ToolRepository = void 0;
+const ObservableEntity_1 = require("./ObservableEntity");
+const Tool_1 = require("./Tool");
+class ToolRepository extends ObservableEntity_1.ObservableEntity {
+}
+exports.ToolRepository = ToolRepository;
+function makeToolRepo() {
+    return new ToolRepositoryImp();
+}
+exports.makeToolRepo = makeToolRepo;
+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);
+        }
+        else {
+            console.warn(`[ToolRepository] No default tools has been specified`);
+        }
+    }
+    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 tool = Tool_1.makeTool(toolData);
+            this.toolLookup.set(tool.id, tool);
+            if (toolData.isDefault) {
+                if (this._defaultToolID) {
+                    console.warn(`[ToolRepository] More than one tools is marked as default. Replacing`);
+                }
+                this._defaultToolID = tool.id;
+            }
+        });
+        if (!this._defaultToolID) {
+            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.setToolActive(this._defaultToolID);
+    }
+    getTool(id) {
+        return this.toolLookup.get(id);
+    }
+    getToolForKey(keyCode) {
+        let tool;
+        this.allTools.forEach((t) => {
+            if (t.keyCode === keyCode) {
+                tool = t;
+            }
+        });
+        return tool;
+    }
+    get activeTool() {
+        return this.getTool(this._activeToolID);
+    }
+    setToolActive(id) {
+        if (this._activeToolID === id)
+            return;
+        const newActiveTool = this.toolLookup.get(id);
+        if (!newActiveTool) {
+            console.warn(`[ToolRepository] Unable to find tool ${id}`);
+            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;
+                tool.state = Tool_1.ToolState.ACTIVE;
+            }
+            else if (tool.state === Tool_1.ToolState.ACTIVE) {
+                tool.state = Tool_1.ToolState.ENABLED;
+            }
+        });
+        this.notify();
+    }
+    toggleToolVisibility(id) {
+        const tool = this.getTool(id);
+        if (!tool) {
+            console.warn(`[ToolRepository] Unable to find tool to toggle: ${id}`);
+            return;
+        }
+        if (tool.id === this._defaultToolID) {
+            console.warn(`[ToolRepository] The default tool's visibility cannot be toggled`);
+            return;
+        }
+        if (tool.state === Tool_1.ToolState.HIDDEN) {
+            tool.state = Tool_1.ToolState.ENABLED;
+        }
+        else {
+            if (tool.state === Tool_1.ToolState.ACTIVE) {
+                this.setDefaultToolActive();
+            }
+            tool.state = Tool_1.ToolState.HIDDEN;
+        }
+    }
+}

package/lib/Entities/index.d.ts

@@ -10,9 +10,12 @@ export * from "./MemoizedVector3";
 export * from "./ObserverList";
 export * from "./FocusCamera";
 export * from "./StateMachine";
+export * from "./Tool";
+export * from "./ToolRepository";
 export * from "./TransformNode";
 export * from "./UndoRedo";
 export * from "./MouseInput";
+export * from "./ObservableEntity";
 export * from "./TouchInput";
 export * from "./QuestionChallengeAnswer";
 export * from "./QuestionChallenge";

package/lib/Entities/index.js

@@ -22,9 +22,12 @@ __exportStar(require("./MemoizedVector3"), exports);
 __exportStar(require("./ObserverList"), exports);
 __exportStar(require("./FocusCamera"), exports);
 __exportStar(require("./StateMachine"), exports);
+__exportStar(require("./Tool"), exports);
+__exportStar(require("./ToolRepository"), exports);
 __exportStar(require("./TransformNode"), exports);
 __exportStar(require("./UndoRedo"), exports);
 __exportStar(require("./MouseInput"), exports);
+__exportStar(require("./ObservableEntity"), exports);
 __exportStar(require("./TouchInput"), exports);
 __exportStar(require("./QuestionChallengeAnswer"), exports);
 __exportStar(require("./QuestionChallenge"), exports);

package/lib/PresentationManagers/PresentationManager.d.ts

@@ -0,0 +1,8 @@
+import { EntityObserver, ObservableEntity } from "../Entities";
+export declare abstract class PresentionManager {
+    private observableEntity;
+    abstract doUpdateView: EntityObserver;
+    private internalDoUodateView;
+    dispose: () => void;
+    constructor(observableEntity: ObservableEntity);
+}

package/lib/PresentationManagers/PresentationManager.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PresentionManager = void 0;
+class PresentionManager {
+    constructor(observableEntity) {
+        this.observableEntity = observableEntity;
+        this.internalDoUodateView = () => {
+            this.doUpdateView();
+        };
+        this.dispose = () => {
+            this.observableEntity.removeObserver(this.internalDoUodateView);
+        };
+        observableEntity.addObserver(this.internalDoUodateView);
+    }
+}
+exports.PresentionManager = PresentionManager;

package/lib/PresentationManagers/ToolPM.d.ts

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

package/lib/PresentationManagers/ToolPM.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultToolVM = exports.ToolPM = void 0;
+const Entities_1 = require("../Entities");
+const PresentationManager_1 = require("./PresentationManager");
+class ToolPM extends PresentationManager_1.PresentionManager {
+    constructor(tool, updateView) {
+        super(tool);
+        this.tool = tool;
+        this.updateView = updateView;
+        this.doUpdateView = () => {
+            let enabled = false;
+            if (this.tool.state === Entities_1.ToolState.ACTIVE ||
+                this.tool.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 vm = {
+                toolID: this.tool.id,
+                enabled,
+                label: this.tool.label,
+                selected,
+                show,
+                shortcutLabel: this.tool.shortcutLabel,
+                tooltipLabel,
+            };
+            this.updateView(vm);
+        };
+        this.doUpdateView();
+    }
+}
+exports.ToolPM = ToolPM;
+exports.defaultToolVM = {
+    toolID: "",
+    enabled: false,
+    label: "",
+    selected: false,
+    shortcutLabel: "",
+    show: false,
+    tooltipLabel: "",
+};

package/lib/PresentationManagers/index.d.ts

@@ -1,9 +1,11 @@
 export * from "./DevicePreviewPM";
 export * from "./IsAuthoringPM";
+export * from "./PresentationManager";
 export * from "./ShowBabylonInspectorPM";
 export * from "./HasRedoPM";
 export * from "./HasUndoPM";
 export * from "./FocusCameraPM";
 export * from "./QuestionChallenge";
 export * from "./FocusCameraPosRotPM";
+export * from "./ToolPM";
 export * from "./TransformNodePM";

package/lib/PresentationManagers/index.js

@@ -12,10 +12,12 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./DevicePreviewPM"), exports);
 __exportStar(require("./IsAuthoringPM"), exports);
+__exportStar(require("./PresentationManager"), exports);
 __exportStar(require("./ShowBabylonInspectorPM"), exports);
 __exportStar(require("./HasRedoPM"), exports);
 __exportStar(require("./HasUndoPM"), exports);
 __exportStar(require("./FocusCameraPM"), exports);
 __exportStar(require("./QuestionChallenge"), exports);
 __exportStar(require("./FocusCameraPosRotPM"), exports);
+__exportStar(require("./ToolPM"), exports);
 __exportStar(require("./TransformNodePM"), exports);

package/lib/ValueObjects/Color.js

@@ -76,11 +76,13 @@ class Color {
      * @returns True if Color A === Color B
      */
     static Equal(a, b) {
-        if (a.a !== b.a)
-            return false;
-        if (a.b !== b.a)
-            return false;
-        return true;
+        let areEqual = true;
+        for (let index = 0; index < 4; index++) {
+            if (a.array[index] !== b.array[index]) {
+                areEqual = false;
+            }
+        }
+        return areEqual;
     }
     /**
      * Return the r value as a percent

package/package.json

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