@vived/app 2.41.0 → 2.42.1

package/lib/Entities/MemoizedQuaternion.d.ts

@@ -0,0 +1,9 @@
+import { Quaternion } from "../ValueObjects";
+export declare class MemoizedQuaternion {
+    private _val;
+    get val(): Quaternion;
+    set val(v: Quaternion);
+    setValQuietly(val: Quaternion): void;
+    private onChangeCallback;
+    constructor(initialValue: Quaternion, onChangeCallback: () => void);
+}

package/lib/Entities/MemoizedQuaternion.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoizedQuaternion = void 0;
+const ValueObjects_1 = require("../ValueObjects");
+class MemoizedQuaternion {
+    constructor(initialValue, onChangeCallback) {
+        this._val = initialValue;
+        this.onChangeCallback = onChangeCallback;
+    }
+    get val() {
+        return this._val;
+    }
+    set val(v) {
+        if (ValueObjects_1.Quaternion.Equal(v, this._val))
+            return;
+        this._val = v;
+        this.onChangeCallback();
+    }
+    setValQuietly(val) {
+        this._val = val;
+    }
+}
+exports.MemoizedQuaternion = MemoizedQuaternion;

package/lib/Entities/SceneModel.d.ts

@@ -1,5 +1,6 @@
+import { Quaternion, Vector3 } from "../ValueObjects";
 import { ObservableEntity } from "./ObservableEntity";
-import { SceneModelData } from "./SceneModelData";
+import { SceneModelObjectDTOv1, SceneModelObjectDTOv0 as SceneModelObjectDTOv0, SceneModelObject } from "./SceneModelObject";
 export declare enum SceneModelState {
     INIT = "Initialized",
     LOADING = "Loading",
@@ -8,16 +9,77 @@ export declare enum SceneModelState {
 }
 export declare abstract class SceneModel extends ObservableEntity {
     abstract readonly id: string;
-    abstract get meshHasBeenSetup(): boolean;
-    abstract set meshHasBeenSetup(val: boolean);
-    abstract addData(id: string, data: SceneModelData): void;
-    abstract hasData(id: string): boolean;
-    abstract getData(id: string): SceneModelData | undefined;
-    abstract get activeDataID(): string | undefined;
-    abstract set activeDataID(val: string | undefined);
-    abstract get state(): SceneModelState;
-    abstract set state(val: SceneModelState);
-    abstract get error(): Error | undefined;
-    abstract set error(val: Error | undefined);
+    abstract name: string;
+    abstract state: SceneModelState;
+    abstract error: Error | undefined;
+    abstract bounds_min: Vector3;
+    abstract bounds_max: Vector3;
+    abstract defaultPosition: Vector3;
+    abstract defaultRotation: Quaternion;
+    abstract defaultScale: number;
+    abstract hasObject(id: string): boolean;
+    abstract getObjectById(id: string): SceneModelObject | undefined;
+    abstract getObjectByPath(path: string): SceneModelObject | undefined;
+    abstract addObject(object: SceneModelObject): void;
+    abstract removeObject(id: string): void;
+    abstract getAllObjects(): SceneModelObject[];
+    abstract applyData(data: SceneModelDTO): void;
+    abstract toData(): SceneModelDTO;
 }
 export declare function makeSceneModel(id: string): SceneModel;
+export declare type SceneModelDTO = SceneModelDTOV0 | SceneModelDTOv1;
+export interface SceneModelDTOV0 {
+    version: number;
+    objects: SceneModelObjectDTOv0[];
+    name: string;
+    description: string;
+    bounds_min: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    bounds_max: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    defaultPosition: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    defaultRotation: {
+        x: number;
+        y: number;
+        z: number;
+        w: number;
+    };
+    defaultScale: number;
+}
+export interface SceneModelDTOv1 {
+    version: number;
+    objects: SceneModelObjectDTOv1[];
+    name: string;
+    bounds_min: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    bounds_max: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    defaultPosition: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    defaultRotation: {
+        x: number;
+        y: number;
+        z: number;
+        w: number;
+    };
+    defaultScale: number;
+}

package/lib/Entities/SceneModel.js

@@ -1,9 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeSceneModel = exports.SceneModel = exports.SceneModelState = void 0;
-const MemoizedBoolean_1 = require("./MemoizedBoolean");
+const ValueObjects_1 = require("../ValueObjects");
+const MemoizedNumber_1 = require("./MemoizedNumber");
+const MemoizedQuaternion_1 = require("./MemoizedQuaternion");
 const MemoizedString_1 = require("./MemoizedString");
+const MemoizedVector3_1 = require("./MemoizedVector3");
 const ObservableEntity_1 = require("./ObservableEntity");
+const SceneModelObject_1 = require("./SceneModelObject");
 var SceneModelState;
 (function (SceneModelState) {
     SceneModelState["INIT"] = "Initialized";
@@ -21,51 +25,176 @@ exports.makeSceneModel = makeSceneModel;
 class SceneModelImp extends SceneModel {
     constructor(id) {
         super();
-        this.dataLookup = new Map();
-        this.memoizedMeshHasBeenSetup = new MemoizedBoolean_1.MemoizedBoolean(false, this.notify);
-        this.memoizedState = new MemoizedString_1.MemoizedString(SceneModelState.INIT, this.notify);
+        this._name = new MemoizedString_1.MemoizedString("", this.notify);
+        this._boundsMin = new MemoizedVector3_1.MemoizedVector3(ValueObjects_1.Vector3.Zero(), this.notify);
+        this._boundsMax = new MemoizedVector3_1.MemoizedVector3(ValueObjects_1.Vector3.Zero(), this.notify);
+        this._defaultPosition = new MemoizedVector3_1.MemoizedVector3(ValueObjects_1.Vector3.Zero(), this.notify);
+        this._defaultRotation = new MemoizedQuaternion_1.MemoizedQuaternion(ValueObjects_1.Quaternion.Identity(), this.notify);
+        this._defaultScale = new MemoizedNumber_1.MemoizedNumber(1, this.notify);
+        this._state = new MemoizedString_1.MemoizedString(SceneModelState.INIT, this.notify);
+        this.sceneModelObjectLookup = new Map();
+        this.hasObject = (id) => {
+            return this.sceneModelObjectLookup.has(id);
+        };
+        this.getObjectById = (id) => {
+            return this.sceneModelObjectLookup.get(id);
+        };
+        this.getObjectByPath = (path) => {
+            let rVal;
+            this.sceneModelObjectLookup.forEach((sceneModelObject) => {
+                if (sceneModelObject.hasMeshPath(path)) {
+                    rVal = sceneModelObject;
+                }
+            });
+            return rVal;
+        };
+        this.addObject = (object) => {
+            if (this.sceneModelObjectLookup.has(object.id)) {
+                const orig = this.sceneModelObjectLookup.get(object.id);
+                orig === null || orig === void 0 ? void 0 : orig.removeObserver(this.notify);
+            }
+            this.sceneModelObjectLookup.set(object.id, object);
+            object.addObserver(this.notify);
+            this.notify();
+        };
+        this.removeObject = (id) => {
+            const orig = this.sceneModelObjectLookup.get(id);
+            if (orig) {
+                this.sceneModelObjectLookup.delete(id);
+                orig.removeObserver(this.notify);
+                this.notify();
+            }
+        };
+        this.getAllObjects = () => {
+            return Array.from(this.sceneModelObjectLookup.values());
+        };
+        this.applyData = (data) => {
+            if (data.version === 0) {
+                this.applyDataV0(data);
+            }
+            else if (data.version === 1) {
+                this.applyDataV1(data);
+            }
+            else {
+                throw new Error(`applyData unsupported version number: ${data.version}`);
+            }
+        };
+        this.toData = () => {
+            const data = {
+                version: 1,
+                bounds_max: this.bounds_max.dto,
+                bounds_min: this.bounds_min.dto,
+                defaultPosition: this.defaultPosition.dto,
+                defaultRotation: this.defaultRotation.dto,
+                defaultScale: this.defaultScale,
+                name: this.name,
+                objects: this.getAllObjects().map((obj) => obj.toData()),
+            };
+            return data;
+        };
         this.id = id;
     }
-    get meshHasBeenSetup() {
-        return this.memoizedMeshHasBeenSetup.val;
+    get name() {
+        return this._name.val;
     }
-    set meshHasBeenSetup(val) {
-        this.memoizedMeshHasBeenSetup.val = val;
+    set name(name) {
+        this._name.val = name;
     }
-    addData(id, data) {
-        this.dataLookup.set(id, data);
-        this.notify();
+    get bounds_min() {
+        return this._boundsMin.val;
     }
-    hasData(id) {
-        return this.dataLookup.has(id);
+    set bounds_min(bounds_min) {
+        this._boundsMin.val = bounds_min;
     }
-    getData(id) {
-        return this.dataLookup.get(id);
+    get bounds_max() {
+        return this._boundsMax.val;
     }
-    get activeDataID() {
-        return this._activeDataID;
+    set bounds_max(bounds_max) {
+        this._boundsMax.val = bounds_max;
     }
-    set activeDataID(val) {
-        if (this._activeDataID === val)
-            return;
-        if (val !== undefined && !this.hasData(val)) {
-            console.warn("[SceneModel] Model does not have data id " + val);
-            return;
-        }
-        this._activeDataID = val;
-        this.notify();
+    get defaultPosition() {
+        return this._defaultPosition.val;
+    }
+    set defaultPosition(position) {
+        this._defaultPosition.val = position;
+    }
+    get defaultRotation() {
+        return this._defaultRotation.val;
+    }
+    set defaultRotation(rotation) {
+        this._defaultRotation.val = rotation;
+    }
+    get defaultScale() {
+        return this._defaultScale.val;
+    }
+    set defaultScale(scale) {
+        this._defaultScale.val = scale;
     }
     get state() {
-        return this.memoizedState.val;
+        return this._state.val;
     }
     set state(val) {
-        this.memoizedState.val = val;
+        this._state.val = val;
     }
     get error() {
         return this._error;
     }
     set error(val) {
         this._error = val;
-        this.memoizedState.val = SceneModelState.ERROR;
+        this._state.val = SceneModelState.ERROR;
+    }
+    applyDataV0(data) {
+        this._name.setValQuietly(data.name);
+        this._boundsMin.setValQuietly(ValueObjects_1.Vector3.FromDTO(data.bounds_min));
+        this._boundsMax.setValQuietly(ValueObjects_1.Vector3.FromDTO(data.bounds_max));
+        this._defaultPosition.setValQuietly(ValueObjects_1.Vector3.FromDTO(data.defaultPosition));
+        this._defaultScale.setValQuietly(data.defaultScale);
+        this._defaultRotation.setValQuietly(ValueObjects_1.Quaternion.FromDTO(data.defaultRotation));
+        const objectsToKeep = [];
+        data.objects.forEach((objectDTO) => {
+            const existingObj = this.sceneModelObjectLookup.get(objectDTO.id);
+            if (existingObj) {
+                existingObj.applyData(objectDTO);
+            }
+            else {
+                const newObj = SceneModelObject_1.makeSceneModelObject(objectDTO);
+                this.addObject(newObj);
+            }
+            objectsToKeep.push(objectDTO.id);
+        });
+        const allObjects = Array.from(this.sceneModelObjectLookup.keys());
+        allObjects.forEach((obj) => {
+            if (!objectsToKeep.includes(obj)) {
+                this.removeObject(obj);
+            }
+        });
+        this.notify();
+    }
+    applyDataV1(data) {
+        this._name.setValQuietly(data.name);
+        this._boundsMin.setValQuietly(ValueObjects_1.Vector3.FromDTO(data.bounds_min));
+        this._boundsMax.setValQuietly(ValueObjects_1.Vector3.FromDTO(data.bounds_max));
+        this._defaultPosition.setValQuietly(ValueObjects_1.Vector3.FromDTO(data.defaultPosition));
+        this._defaultScale.setValQuietly(data.defaultScale);
+        this._defaultRotation.setValQuietly(ValueObjects_1.Quaternion.FromDTO(data.defaultRotation));
+        const objectsToKeep = [];
+        data.objects.forEach((objectDTO) => {
+            const existingObj = this.sceneModelObjectLookup.get(objectDTO.id);
+            if (existingObj) {
+                existingObj.applyData(objectDTO);
+            }
+            else {
+                const newObj = SceneModelObject_1.makeSceneModelObject(objectDTO);
+                this.addObject(newObj);
+            }
+            objectsToKeep.push(objectDTO.id);
+        });
+        const allObjects = Array.from(this.sceneModelObjectLookup.keys());
+        allObjects.forEach((obj) => {
+            if (!objectsToKeep.includes(obj)) {
+                this.removeObject(obj);
+            }
+        });
+        this.notify();
     }
 }

package/lib/Entities/SceneModelObject.d.ts

@@ -0,0 +1,40 @@
+import { ObservableEntity } from "./ObservableEntity";
+export declare abstract class SceneModelObject extends ObservableEntity {
+    abstract readonly id: string;
+    abstract label: string;
+    abstract meshPaths: string[];
+    abstract addMeshPath(path: string): void;
+    abstract hasMeshPath(path: string): boolean;
+    abstract removeMeshPath(path: string): void;
+    abstract toData(): SceneModelObjectDTO;
+    abstract applyData(data: SceneModelObjectDTO): void;
+}
+export declare function makeSceneModelObject(dto: SceneModelObjectDTO): SceneObjectImp;
+declare class SceneObjectImp extends SceneModelObject {
+    readonly id: string;
+    private _label;
+    get label(): string;
+    set label(label: string);
+    private _meshPaths;
+    get meshPaths(): string[];
+    set meshPaths(paths: string[]);
+    addMeshPath: (path: string) => void;
+    hasMeshPath: (path: string) => boolean;
+    removeMeshPath: (path: string) => void;
+    toData: () => SceneModelObjectDTO;
+    applyData: (data: SceneModelObjectDTO) => void;
+    constructor(dto: SceneModelObjectDTO);
+}
+export declare type SceneModelObjectDTO = SceneModelObjectDTOv0 | SceneModelObjectDTOv1;
+export interface SceneModelObjectDTOv1 {
+    version: number;
+    id: string;
+    meshPaths: string[];
+    label: string;
+}
+export interface SceneModelObjectDTOv0 {
+    id: string;
+    meshPaths: string[];
+    label: string;
+}
+export {};

package/lib/Entities/SceneModelObject.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeSceneModelObject = exports.SceneModelObject = void 0;
+const MemoizedString_1 = require("./MemoizedString");
+const ObservableEntity_1 = require("./ObservableEntity");
+class SceneModelObject extends ObservableEntity_1.ObservableEntity {
+}
+exports.SceneModelObject = SceneModelObject;
+function makeSceneModelObject(dto) {
+    return new SceneObjectImp(dto);
+}
+exports.makeSceneModelObject = makeSceneModelObject;
+class SceneObjectImp extends SceneModelObject {
+    constructor(dto) {
+        super();
+        this._label = new MemoizedString_1.MemoizedString("", this.notify);
+        this._meshPaths = [];
+        this.addMeshPath = (path) => {
+            if (this._meshPaths.includes(path))
+                return;
+            this._meshPaths.push(path);
+            this.notify();
+        };
+        this.hasMeshPath = (path) => {
+            return this._meshPaths.includes(path);
+        };
+        this.removeMeshPath = (path) => {
+            const index = this._meshPaths.indexOf(path);
+            if (index >= 0) {
+                this._meshPaths.splice(index, 1);
+                this.notify();
+            }
+        };
+        this.toData = () => {
+            const dto = {
+                version: 1,
+                id: this.id,
+                label: this.label,
+                meshPaths: [...this._meshPaths],
+            };
+            return dto;
+        };
+        this.applyData = (data) => {
+            this.label = data.label;
+            this.meshPaths = data.meshPaths;
+        };
+        this.id = dto.id;
+        this._label.setValQuietly(dto.label);
+        this._meshPaths = [...dto.meshPaths];
+    }
+    get label() {
+        return this._label.val;
+    }
+    set label(label) {
+        this._label.val = label;
+    }
+    get meshPaths() {
+        return [...this._meshPaths];
+    }
+    set meshPaths(paths) {
+        let pathsHaveChanged = false;
+        if (paths.length !== this._meshPaths.length) {
+            pathsHaveChanged = true;
+        }
+        else {
+            paths.forEach((path, i) => {
+                if (path !== this._meshPaths[i]) {
+                    pathsHaveChanged = true;
+                }
+            });
+        }
+        if (!pathsHaveChanged)
+            return;
+        this._meshPaths = paths;
+        this.notify();
+    }
+}

package/lib/Entities/SceneModelRepo.d.ts

@@ -1,14 +1,11 @@
 import { ObservableEntityRepo } from "./ObservableEntityRepo";
-import { SceneModel } from "./SceneModel";
-import { SceneModelDataDTO } from "./SceneModelData";
+import { SceneModel, SceneModelDTO } from "./SceneModel";
 export declare abstract class SceneModelRepo extends ObservableEntityRepo<SceneModel> {
     abstract get activeModel(): SceneModel | undefined;
-    abstract get activeModelID(): string;
-    abstract set activeModelID(id: string);
-    abstract get isLoadingModel(): boolean;
-    abstract set isLoadingModel(val: boolean);
+    abstract activeModelID: string;
+    abstract isLoadingSceneModel: boolean;
     abstract modelLoader(modelID: string): Promise<void>;
-    abstract dataLoader(dataID: string): Promise<SceneModelDataDTO>;
+    abstract dataLoader(dataID: string): Promise<SceneModelDTO>;
     abstract clearActiveModel(): void;
 }
 export declare function makeSceneModelRepo(): SceneModelRepo;

package/lib/Entities/SceneModelRepo.js

@@ -33,10 +33,10 @@ class SceneModelRepoImp extends SceneModelRepo {
         }
         this.memoizedActiveModelID.val = id;
     }
-    get isLoadingModel() {
+    get isLoadingSceneModel() {
         return this.memoizedIsLoading.val;
     }
-    set isLoadingModel(val) {
+    set isLoadingSceneModel(val) {
         this.memoizedIsLoading.val = val;
     }
     clearActiveModel() {

package/lib/Entities/SceneObject.d.ts

@@ -8,16 +8,4 @@ export declare abstract class SceneObject extends ObservableEntity {
     abstract set enabled(enabled: boolean);
     abstract transform: TransformNode;
 }
-export declare function makeSceneObject(id: string): SceneObjectImp;
-declare class SceneObjectImp extends SceneObject {
-    readonly id: string;
-    private memoizedLabel;
-    get label(): string;
-    set label(label: string);
-    private memoizedEnabled;
-    get enabled(): boolean;
-    set enabled(enabled: boolean);
-    transform: TransformNode;
-    constructor(id: string);
-}
-export {};
+export declare function makeSceneObject(id: string): SceneObject;

package/lib/Entities/index.d.ts

@@ -4,34 +4,33 @@ export * from "./AppHandler";
 export * from "./Babylon";
 export * from "./BaseApp";
 export * from "./DevicePreview";
-export * from "./FramedScreenContainer";
 export * from "./FramedScreen";
+export * from "./FramedScreenContainer";
 export * from "./HoverLabels";
 export * from "./KeyboardInput";
 export * from "./MemoizedBoolean";
 export * from "./MemoizedNumber";
+export * from "./MemoizedQuaternion";
 export * from "./MemoizedString";
 export * from "./MemoizedVector2";
 export * from "./MemoizedVector3";
-export * from "./SceneModelData";
 export * from "./MessageSystem";
-export * from "./ModelObject";
-export * from "./ObservableEntity";
-export * from "./ObserverList";
-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 "./ObservableEntityRepo";
+export * from "./ObserverList";
 export * from "./QuestionChallenge";
+export * from "./QuestionChallengeAnswer";
 export * from "./SceneModel";
-export * from "./SceneModelData";
+export * from "./SceneModelObject";
 export * from "./SceneModelRepo";
 export * from "./SceneObject";
 export * from "./SceneObjectsRepo";
 export * from "./SceneRoot";
+export * from "./StateMachine";
+export * from "./Tool";
+export * from "./ToolRepository";
+export * from "./TouchInput";
+export * from "./TransformNode";
+export * from "./UndoRedo";
 export * from "./WorkPlane";

package/lib/Entities/index.js

@@ -16,34 +16,33 @@ __exportStar(require("./AppHandler"), exports);
 __exportStar(require("./Babylon"), exports);
 __exportStar(require("./BaseApp"), exports);
 __exportStar(require("./DevicePreview"), exports);
-__exportStar(require("./FramedScreenContainer"), exports);
 __exportStar(require("./FramedScreen"), exports);
+__exportStar(require("./FramedScreenContainer"), exports);
 __exportStar(require("./HoverLabels"), exports);
 __exportStar(require("./KeyboardInput"), exports);
 __exportStar(require("./MemoizedBoolean"), exports);
 __exportStar(require("./MemoizedNumber"), exports);
+__exportStar(require("./MemoizedQuaternion"), exports);
 __exportStar(require("./MemoizedString"), exports);
 __exportStar(require("./MemoizedVector2"), exports);
 __exportStar(require("./MemoizedVector3"), exports);
-__exportStar(require("./SceneModelData"), exports);
 __exportStar(require("./MessageSystem"), exports);
-__exportStar(require("./ModelObject"), exports);
-__exportStar(require("./ObservableEntity"), exports);
-__exportStar(require("./ObserverList"), 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("./ObservableEntityRepo"), exports);
+__exportStar(require("./ObserverList"), exports);
 __exportStar(require("./QuestionChallenge"), exports);
+__exportStar(require("./QuestionChallengeAnswer"), exports);
 __exportStar(require("./SceneModel"), exports);
-__exportStar(require("./SceneModelData"), exports);
+__exportStar(require("./SceneModelObject"), exports);
 __exportStar(require("./SceneModelRepo"), exports);
 __exportStar(require("./SceneObject"), exports);
 __exportStar(require("./SceneObjectsRepo"), exports);
 __exportStar(require("./SceneRoot"), exports);
+__exportStar(require("./StateMachine"), exports);
+__exportStar(require("./Tool"), exports);
+__exportStar(require("./ToolRepository"), exports);
+__exportStar(require("./TouchInput"), exports);
+__exportStar(require("./TransformNode"), exports);
+__exportStar(require("./UndoRedo"), exports);
 __exportStar(require("./WorkPlane"), exports);

package/lib/ValueObjects/Quaternion.d.ts

@@ -30,6 +30,17 @@ export declare class Quaternion {
      * @returns A Quaterion
      */
     static FromArray(values: [number, number, number, number]): Quaternion;
+    /**
+     * Creates a Quaterion from a Data Transfer Object
+     * @param dto The Data Transfer Object
+     * @returns The Quaternion
+     */
+    static FromDTO(dto: {
+        x: number;
+        y: number;
+        z: number;
+        w: number;
+    }): Quaternion;
     /**
      * Creates an Identity Quaternion
      * @returns An Identity Quaternion
@@ -86,6 +97,15 @@ export declare class Quaternion {
     toArray(): [number, number, number, number];
     get angle(): Angle;
     get axis(): Vector3;
+    /**
+     * Get the vector as a Data Transfer Object
+     */
+    get dto(): {
+        x: number;
+        y: number;
+        z: number;
+        w: number;
+    };
     readonly x: number;
     readonly y: number;
     readonly z: number;

package/lib/ValueObjects/Quaternion.js

@@ -69,6 +69,14 @@ class Quaternion {
     static FromArray(values) {
         return new Quaternion(values[0], values[1], values[2], values[3]);
     }
+    /**
+     * Creates a Quaterion from a Data Transfer Object
+     * @param dto The Data Transfer Object
+     * @returns The Quaternion
+     */
+    static FromDTO(dto) {
+        return new Quaternion(dto.x, dto.y, dto.z, dto.w);
+    }
     /**
      * Creates an Identity Quaternion
      * @returns An Identity Quaternion
@@ -239,5 +247,11 @@ class Quaternion {
         const z = this.z / Math.sqrt(1 - this.w * this.w);
         return new Vector3_1.Vector3(x, y, z);
     }
+    /**
+     * Get the vector as a Data Transfer Object
+     */
+    get dto() {
+        return { x: this.x, y: this.y, z: this.z, w: this.w };
+    }
 }
 exports.Quaternion = Quaternion;

package/lib/ValueObjects/Vector2.d.ts

@@ -17,6 +17,15 @@ export declare class Vector2 {
      * @returns True if Vector A === Vector B
      */
     static Equal(a: Vector2, b: Vector2): boolean;
+    /**
+     * Creates a Vector from a Data Transfer Object
+     * @param dto The Data Transfer Object
+     * @returns The Vector
+     */
+    static FromDTO(dto: {
+        x: number;
+        y: number;
+    }): Vector2;
     /**
      * Adds Vector B to Vector A
      * @param a Vector A
@@ -100,5 +109,12 @@ export declare class Vector2 {
      * Retuns the vector as an array of numbers [x,y]
      */
     get array(): [number, number];
+    /**
+     * Get the vector as a Data Transfer Object
+     */
+    get dto(): {
+        x: number;
+        y: number;
+    };
     constructor(x: number, y: number);
 }

package/lib/ValueObjects/Vector2.js

@@ -34,6 +34,14 @@ class Vector2 {
             return false;
         return true;
     }
+    /**
+     * Creates a Vector from a Data Transfer Object
+     * @param dto The Data Transfer Object
+     * @returns The Vector
+     */
+    static FromDTO(dto) {
+        return new Vector2(dto.x, dto.y);
+    }
     /**
      * Adds Vector B to Vector A
      * @param a Vector A
@@ -86,6 +94,12 @@ class Vector2 {
     get array() {
         return [this.x, this.y];
     }
+    /**
+     * Get the vector as a Data Transfer Object
+     */
+    get dto() {
+        return { x: this.x, y: this.y };
+    }
 }
 exports.Vector2 = Vector2;
 /**

package/lib/ValueObjects/Vector3.d.ts

@@ -52,6 +52,16 @@ export declare class Vector3 {
      * @returns The Vector
      */
     static FromArray(values: [number, number, number]): Vector3;
+    /**
+     * Creates a Vector from a Data Transfer Object
+     * @param dto The Data Transfer Object
+     * @returns The Vector
+     */
+    static FromDTO(dto: {
+        x: number;
+        y: number;
+        z: number;
+    }): Vector3;
     /**
      * Adds Vector B to Vector A
      * @param a Vector A
@@ -129,5 +139,13 @@ export declare class Vector3 {
      * @returns an array representing the vector
      */
     get array(): [number, number, number];
+    /**
+     * Get the vector as a Data Transfer Object
+     */
+    get dto(): {
+        x: number;
+        y: number;
+        z: number;
+    };
     constructor(x: number, y: number, z: number);
 }

package/lib/ValueObjects/Vector3.js

@@ -78,6 +78,14 @@ class Vector3 {
     static FromArray(values) {
         return new Vector3(values[0], values[1], values[2]);
     }
+    /**
+     * Creates a Vector from a Data Transfer Object
+     * @param dto The Data Transfer Object
+     * @returns The Vector
+     */
+    static FromDTO(dto) {
+        return new Vector3(dto.x, dto.y, dto.z);
+    }
     /**
      * Gets the magnitude of the Vector3
      * @returns the magnitude of the Vector3
@@ -110,6 +118,12 @@ class Vector3 {
     get array() {
         return [this.x, this.y, this.z];
     }
+    /**
+     * Get the vector as a Data Transfer Object
+     */
+    get dto() {
+        return { x: this.x, y: this.y, z: this.z };
+    }
 }
 exports.Vector3 = Vector3;
 /**

package/package.json

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

package/lib/Entities/ModelObject.d.ts

@@ -1,10 +0,0 @@
-import { ObservableEntity } from "./ObservableEntity";
-export declare abstract class ModelObject extends ObservableEntity {
-    abstract readonly id: string;
-    abstract get label(): string;
-    abstract set label(label: string);
-    abstract get meshPaths(): string[];
-    abstract addMeshPath(path: string): void;
-    abstract removeMeshPath(path: string): void;
-}
-export declare function makeModelObject(id: string): ModelObject;

package/lib/Entities/ModelObject.js

@@ -1,42 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeModelObject = exports.ModelObject = void 0;
-const MemoizedString_1 = require("./MemoizedString");
-const ObservableEntity_1 = require("./ObservableEntity");
-class ModelObject extends ObservableEntity_1.ObservableEntity {
-}
-exports.ModelObject = ModelObject;
-function makeModelObject(id) {
-    return new ModelObjectImp(id);
-}
-exports.makeModelObject = makeModelObject;
-class ModelObjectImp extends ModelObject {
-    constructor(id) {
-        super();
-        this.memoizedLabel = new MemoizedString_1.MemoizedString("", this.notify);
-        this._meshPaths = new Set([]);
-        this.id = id;
-    }
-    get label() {
-        return this.memoizedLabel.val;
-    }
-    set label(label) {
-        this.memoizedLabel.val = label;
-    }
-    get meshPaths() {
-        return Array.from(this._meshPaths);
-    }
-    addMeshPath(path) {
-        if (this._meshPaths.has(path)) {
-            return;
-        }
-        this._meshPaths.add(path);
-        this.notify();
-    }
-    removeMeshPath(path) {
-        if (this._meshPaths.has(path)) {
-            this._meshPaths.delete(path);
-            this.notify();
-        }
-    }
-}

package/lib/Entities/SceneModelData.d.ts

@@ -1,68 +0,0 @@
-import { Quaternion, Vector3 } from "../ValueObjects";
-import { ModelObject } from "./ModelObject";
-import { ObservableEntity } from "./ObservableEntity";
-export interface SceneModelDataDTO {
-    version: number;
-    objects: ObjectData[];
-    name: string;
-    description: string;
-    bounds_min: {
-        x: number;
-        y: number;
-        z: number;
-    };
-    bounds_max: {
-        x: number;
-        y: number;
-        z: number;
-    };
-    defaultPosition: {
-        x: number;
-        y: number;
-        z: number;
-    };
-    defaultRotation: {
-        x: number;
-        y: number;
-        z: number;
-        w: number;
-    };
-    defaultScale: number;
-}
-export interface ObjectData {
-    id: string;
-    meshPaths: string[];
-    label: string;
-}
-export declare abstract class SceneModelData extends ObservableEntity {
-    abstract readonly objects: ModelObject[];
-    abstract hasObject(id: string): boolean;
-    abstract getObjectById(id: string): ModelObject | undefined;
-    abstract getObjectByPath(path: string): ModelObject | undefined;
-    abstract addObject(object: ModelObject): void;
-    abstract deleteObject(id: string): void;
-    abstract get modelFile(): File | undefined;
-    abstract set modelFile(file: File | undefined);
-    abstract get version(): number;
-    abstract set version(scale: number);
-    abstract get name(): string;
-    abstract set name(name: string);
-    abstract get description(): string;
-    abstract set description(name: string);
-    abstract get image(): Blob | undefined;
-    abstract set image(image: Blob | undefined);
-    abstract get imageURL(): string | undefined;
-    abstract get bounds_min(): Vector3;
-    abstract set bounds_min(position: Vector3);
-    abstract get bounds_max(): Vector3;
-    abstract set bounds_max(position: Vector3);
-    abstract get defaultPosition(): Vector3;
-    abstract set defaultPosition(position: Vector3);
-    abstract get defaultRotation(): Quaternion;
-    abstract set defaultRotation(rotation: Quaternion);
-    abstract get defaultScale(): number;
-    abstract set defaultScale(scale: number);
-    abstract getData(): SceneModelDataDTO;
-    abstract setData(data: SceneModelDataDTO): void;
-}
-export declare function makeSceneModelData(): SceneModelData;

package/lib/Entities/SceneModelData.js

@@ -1,174 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeSceneModelData = exports.SceneModelData = void 0;
-const ValueObjects_1 = require("../ValueObjects");
-const MemoizedNumber_1 = require("./MemoizedNumber");
-const MemoizedString_1 = require("./MemoizedString");
-const MemoizedVector3_1 = require("./MemoizedVector3");
-const ModelObject_1 = require("./ModelObject");
-const ObservableEntity_1 = require("./ObservableEntity");
-class SceneModelData extends ObservableEntity_1.ObservableEntity {
-}
-exports.SceneModelData = SceneModelData;
-function makeSceneModelData() {
-    return new SceneModelDataImp();
-}
-exports.makeSceneModelData = makeSceneModelData;
-class SceneModelDataImp extends SceneModelData {
-    constructor() {
-        super(...arguments);
-        this.objects = [];
-        this._modelFile = undefined;
-        this._memoizedVersion = new MemoizedNumber_1.MemoizedNumber(0, this.notify);
-        this._memoizedName = new MemoizedString_1.MemoizedString("", this.notify);
-        this._memoizedDescription = new MemoizedString_1.MemoizedString("", this.notify);
-        this._image = undefined;
-        this._memoizedBoundsMin = new MemoizedVector3_1.MemoizedVector3(ValueObjects_1.Vector3.Zero(), this.notify);
-        this._memoizedBoundsMax = new MemoizedVector3_1.MemoizedVector3(ValueObjects_1.Vector3.Zero(), this.notify);
-        this._memoizedDefaultPosition = new MemoizedVector3_1.MemoizedVector3(ValueObjects_1.Vector3.Zero(), this.notify);
-        this._defaultRotation = ValueObjects_1.Quaternion.Identity();
-        this._memoizedDefaultScale = new MemoizedNumber_1.MemoizedNumber(1, this.notify);
-        this._imageURL = undefined;
-    }
-    hasObject(id) {
-        return !!this.objects.find((obj) => obj.id === id);
-    }
-    getObjectById(id) {
-        return this.objects.find((obj) => obj.id === id);
-    }
-    getObjectByPath(path) {
-        let rVal;
-        this.objects.forEach((obj) => {
-            if (obj.meshPaths.includes(path)) {
-                rVal = obj;
-            }
-        });
-        return rVal;
-    }
-    addObject(object) {
-        object.addObserver(this.notify);
-        this.objects.push(object);
-        this.notify();
-    }
-    deleteObject(id) {
-        this.objects = this.objects.filter((obj) => {
-            if (obj.id === id) {
-                obj.removeObserver(this.notify);
-                return false;
-            }
-            return true;
-        });
-        this.notify();
-    }
-    get modelFile() {
-        return this._modelFile;
-    }
-    set modelFile(file) {
-        this._modelFile = file;
-        this.notify();
-    }
-    get version() {
-        return this._memoizedVersion.val;
-    }
-    set version(version) {
-        this._memoizedVersion.val = version;
-    }
-    get name() {
-        return this._memoizedName.val;
-    }
-    set name(name) {
-        this._memoizedName.val = name;
-    }
-    get description() {
-        return this._memoizedDescription.val;
-    }
-    set description(description) {
-        this._memoizedDescription.val = description;
-    }
-    get image() {
-        return this._image;
-    }
-    set image(image) {
-        if (!this._image && !image)
-            return;
-        if (this._image && image && this._image.size === image.size)
-            return;
-        this._image = image;
-        if (image === undefined) {
-            this._imageURL = undefined;
-        }
-        else {
-            this._imageURL = URL.createObjectURL(image);
-        }
-        this.notify();
-    }
-    get imageURL() {
-        return this._imageURL;
-    }
-    get bounds_min() {
-        return this._memoizedBoundsMin.val;
-    }
-    set bounds_min(bounds_min) {
-        this._memoizedBoundsMin.val = bounds_min;
-    }
-    get bounds_max() {
-        return this._memoizedBoundsMax.val;
-    }
-    set bounds_max(bounds_max) {
-        this._memoizedBoundsMax.val = bounds_max;
-    }
-    get defaultPosition() {
-        return this._memoizedDefaultPosition.val;
-    }
-    set defaultPosition(position) {
-        this._memoizedDefaultPosition.val = position;
-    }
-    get defaultRotation() {
-        return this._defaultRotation;
-    }
-    set defaultRotation(rotation) {
-        if (ValueObjects_1.Quaternion.Equal(this._defaultRotation, rotation))
-            return;
-        this._defaultRotation = rotation;
-        this.notify();
-    }
-    get defaultScale() {
-        return this._memoizedDefaultScale.val;
-    }
-    set defaultScale(scale) {
-        this._memoizedDefaultScale.val = scale;
-    }
-    getData() {
-        return {
-            version: this.version,
-            objects: this.objects.map((obj) => ({
-                id: obj.id,
-                label: obj.label,
-                meshPaths: [...obj.meshPaths],
-            })),
-            name: this.name,
-            description: this.description,
-            bounds_min: this.bounds_min,
-            bounds_max: this.bounds_max,
-            defaultPosition: this.defaultPosition,
-            defaultRotation: this.defaultRotation,
-            defaultScale: this.defaultScale,
-        };
-    }
-    setData(data) {
-        this.version = data.version;
-        data.objects.forEach((obj) => {
-            const modelObject = ModelObject_1.makeModelObject(obj.id);
-            modelObject.label = obj.label;
-            obj.meshPaths.forEach((path) => modelObject.addMeshPath(path));
-            this.addObject(modelObject);
-        });
-        this.name = data.name;
-        this.description = data.description;
-        this.bounds_min = data.bounds_min;
-        this.bounds_max = data.bounds_max;
-        this.defaultPosition = data.defaultPosition;
-        this.defaultRotation = data.defaultRotation;
-        this.defaultScale = data.defaultScale;
-    }
-}