@vived/app 2.40.1 → 2.42.0

package/lib/Entities/AppDispatcher.d.ts

@@ -34,7 +34,7 @@ export interface SpinnerDTO {
 export declare abstract class AppDispatcher {
     abstract registerHostHandler: (hostHandler: Handler) => void;
     abstract dispatch: (request: Request) => void;
-    abstract stateHasChanged: (state: object, validationErrorMessage?: string) => void;
+    abstract stateHasChanged: (state: object, assets: string[], validationErrorMessage?: string) => void;
     abstract stateIsCompleted: () => void;
     abstract goToPreviousState: () => void;
     abstract goToNextState: () => void;

package/lib/Entities/AppDispatcher.js

@@ -21,12 +21,13 @@ class AppDistpatcherImp extends AppDispatcher {
             }
             this.hostHandler(request);
         };
-        this.stateHasChanged = (stateObject, validationErrorMessage) => {
+        this.stateHasChanged = (stateObject, assets, validationErrorMessage) => {
             const payload = {
                 stateObject,
+                assets,
                 validationErrorMessage,
             };
-            this.formRequestAndDispatch("ON_STATE_CHANGE", 2, payload);
+            this.formRequestAndDispatch("ON_STATE_CHANGE", 3, payload);
         };
         this.stateIsCompleted = () => {
             this.formRequestAndDispatch("ON_STATE_COMPLETED", 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/ObservableEntityRepo.d.ts

@@ -0,0 +1,14 @@
+import { ObservableEntity } from "./ObservableEntity";
+export declare class ObservableEntityRepo<T extends ObservableEntity> extends ObservableEntity {
+    private entityLookup;
+    has: (id: string) => boolean;
+    add: (id: string, entity: T) => void;
+    remove: (id: string) => void;
+    clear: () => void;
+    get: (id: string) => T | undefined;
+    getAll: () => T[];
+    set: (entities: {
+        id: string;
+        entity: T;
+    }[]) => void;
+}

package/lib/Entities/ObservableEntityRepo.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObservableEntityRepo = void 0;
+const ObservableEntity_1 = require("./ObservableEntity");
+class ObservableEntityRepo extends ObservableEntity_1.ObservableEntity {
+    constructor() {
+        super(...arguments);
+        this.entityLookup = new Map();
+        this.has = (id) => {
+            return this.entityLookup.has(id);
+        };
+        this.add = (id, entity) => {
+            const existing = this.entityLookup.get(id);
+            if (existing) {
+                existing.removeObserver(this.notify);
+            }
+            this.entityLookup.set(id, entity);
+            entity.addObserver(this.notify);
+            this.notify();
+        };
+        this.remove = (id) => {
+            const existing = this.entityLookup.get(id);
+            if (!existing)
+                return;
+            this.entityLookup.delete(id);
+            existing.removeObserver(this.notify);
+            this.notify();
+        };
+        this.clear = () => {
+            if (this.entityLookup.size === 0)
+                return;
+            this.entityLookup.forEach((entity) => {
+                entity.removeObserver(this.notify);
+            });
+            this.entityLookup.clear();
+            this.notify();
+        };
+        this.get = (id) => {
+            return this.entityLookup.get(id);
+        };
+        this.getAll = () => {
+            return Array.from(this.entityLookup.values());
+        };
+        this.set = (entities) => {
+            if (this.entityLookup.size === 0 && entities.length === 0) {
+                return;
+            }
+            this.entityLookup.forEach((entity) => {
+                entity.removeObserver(this.notify);
+            });
+            this.entityLookup.clear();
+            entities.forEach((e) => {
+                this.entityLookup.set(e.id, e.entity);
+                e.entity.addObserver(this.notify);
+            });
+            this.notify();
+        };
+    }
+}
+exports.ObservableEntityRepo = ObservableEntityRepo;

package/lib/Entities/SceneModel.d.ts

@@ -0,0 +1,85 @@
+import { Quaternion, Vector3 } from "../ValueObjects";
+import { ObservableEntity } from "./ObservableEntity";
+import { SceneModelObjectDTOv1, SceneModelObjectDTOv0 as SceneModelObjectDTOv0, SceneModelObject } from "./SceneModelObject";
+export declare enum SceneModelState {
+    INIT = "Initialized",
+    LOADING = "Loading",
+    READY = "Ready",
+    ERROR = "Error"
+}
+export declare abstract class SceneModel extends ObservableEntity {
+    abstract readonly id: string;
+    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

@@ -0,0 +1,200 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeSceneModel = exports.SceneModel = exports.SceneModelState = void 0;
+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";
+    SceneModelState["LOADING"] = "Loading";
+    SceneModelState["READY"] = "Ready";
+    SceneModelState["ERROR"] = "Error";
+})(SceneModelState = exports.SceneModelState || (exports.SceneModelState = {}));
+class SceneModel extends ObservableEntity_1.ObservableEntity {
+}
+exports.SceneModel = SceneModel;
+function makeSceneModel(id) {
+    return new SceneModelImp(id);
+}
+exports.makeSceneModel = makeSceneModel;
+class SceneModelImp extends SceneModel {
+    constructor(id) {
+        super();
+        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 name() {
+        return this._name.val;
+    }
+    set name(name) {
+        this._name.val = name;
+    }
+    get bounds_min() {
+        return this._boundsMin.val;
+    }
+    set bounds_min(bounds_min) {
+        this._boundsMin.val = bounds_min;
+    }
+    get bounds_max() {
+        return this._boundsMax.val;
+    }
+    set bounds_max(bounds_max) {
+        this._boundsMax.val = bounds_max;
+    }
+    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._state.val;
+    }
+    set state(val) {
+        this._state.val = val;
+    }
+    get error() {
+        return this._error;
+    }
+    set error(val) {
+        this._error = val;
+        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

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

package/lib/Entities/SceneModelRepo.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeSceneModelRepo = exports.SceneModelRepo = void 0;
+const MemoizedBoolean_1 = require("./MemoizedBoolean");
+const MemoizedString_1 = require("./MemoizedString");
+const ObservableEntityRepo_1 = require("./ObservableEntityRepo");
+class SceneModelRepo extends ObservableEntityRepo_1.ObservableEntityRepo {
+}
+exports.SceneModelRepo = SceneModelRepo;
+function makeSceneModelRepo() {
+    return new SceneModelRepoImp();
+}
+exports.makeSceneModelRepo = makeSceneModelRepo;
+class SceneModelRepoImp extends SceneModelRepo {
+    constructor() {
+        super(...arguments);
+        this.memoizedActiveModelID = new MemoizedString_1.MemoizedString("", this.notify);
+        this.memoizedIsLoading = new MemoizedBoolean_1.MemoizedBoolean(false, this.notify);
+    }
+    modelLoader( /*modelID: string*/) {
+        return Promise.reject(new Error(`SceneModelRepo function modelLoader has not been injected`));
+    }
+    dataLoader( /*dataID: string*/) {
+        return Promise.reject(new Error(`SceneModelRepo function dataLoader has not been injected`));
+    }
+    get activeModelID() {
+        return this.memoizedActiveModelID.val;
+    }
+    set activeModelID(id) {
+        if (!this.has(id)) {
+            console.warn("[SceneModelRepo] Unknown Model ID ", id);
+            return;
+        }
+        this.memoizedActiveModelID.val = id;
+    }
+    get isLoadingSceneModel() {
+        return this.memoizedIsLoading.val;
+    }
+    set isLoadingSceneModel(val) {
+        this.memoizedIsLoading.val = val;
+    }
+    clearActiveModel() {
+        this.memoizedActiveModelID.val = "";
+    }
+    get activeModel() {
+        return this.get(this.memoizedActiveModelID.val);
+    }
+}

package/lib/Entities/SceneObject.d.ts

@@ -0,0 +1,23 @@
+import { ObservableEntity } from "./ObservableEntity";
+import { TransformNode } from "./TransformNode";
+export declare abstract class SceneObject extends ObservableEntity {
+    abstract readonly id: string;
+    abstract get label(): string;
+    abstract set label(label: string);
+    abstract get enabled(): boolean;
+    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 {};

package/lib/Entities/SceneObject.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeSceneObject = exports.SceneObject = void 0;
+const MemoizedBoolean_1 = require("./MemoizedBoolean");
+const MemoizedString_1 = require("./MemoizedString");
+const ObservableEntity_1 = require("./ObservableEntity");
+const TransformNode_1 = require("./TransformNode");
+class SceneObject extends ObservableEntity_1.ObservableEntity {
+}
+exports.SceneObject = SceneObject;
+function makeSceneObject(id) {
+    return new SceneObjectImp(id);
+}
+exports.makeSceneObject = makeSceneObject;
+class SceneObjectImp extends SceneObject {
+    constructor(id) {
+        super();
+        this.memoizedLabel = new MemoizedString_1.MemoizedString("", this.notify);
+        this.memoizedEnabled = new MemoizedBoolean_1.MemoizedBoolean(true, this.notify);
+        this.transform = TransformNode_1.makeTransformNode();
+        this.id = id;
+        this.transform.addObserver(this.notify);
+    }
+    get label() {
+        return this.memoizedLabel.val;
+    }
+    set label(label) {
+        this.memoizedLabel.val = label;
+    }
+    get enabled() {
+        return this.memoizedEnabled.val;
+    }
+    set enabled(enabled) {
+        this.memoizedEnabled.val = enabled;
+    }
+}

package/lib/Entities/SceneObjectsRepo.d.ts

@@ -0,0 +1,9 @@
+import { ObservableEntityRepo } from "./ObservableEntityRepo";
+import { SceneObject } from "./SceneObject";
+export declare abstract class SceneObjectsRepo extends ObservableEntityRepo<SceneObject> {
+    abstract get pressedSceneObject(): string | null;
+    abstract set pressedSceneObject(sceneObjectId: string | null);
+    abstract get hoveredSceneObject(): string | null;
+    abstract set hoveredSceneObject(sceneObjectId: string | null);
+}
+export declare function makeSceneObjectRepo(): SceneObjectsRepo;

package/lib/Entities/SceneObjectsRepo.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeSceneObjectRepo = exports.SceneObjectsRepo = void 0;
+const ObservableEntityRepo_1 = require("./ObservableEntityRepo");
+class SceneObjectsRepo extends ObservableEntityRepo_1.ObservableEntityRepo {
+}
+exports.SceneObjectsRepo = SceneObjectsRepo;
+function makeSceneObjectRepo() {
+    return new SceneObjectsRepoImp();
+}
+exports.makeSceneObjectRepo = makeSceneObjectRepo;
+class SceneObjectsRepoImp extends SceneObjectsRepo {
+    constructor() {
+        super(...arguments);
+        this._pressedSceneObject = null;
+        this._hoveredSceneObject = null;
+    }
+    get pressedSceneObject() {
+        return this._pressedSceneObject;
+    }
+    set pressedSceneObject(sceneObjectId) {
+        if (sceneObjectId === this._pressedSceneObject) {
+            return;
+        }
+        this._pressedSceneObject = sceneObjectId;
+        this.notify();
+    }
+    get hoveredSceneObject() {
+        return this._hoveredSceneObject;
+    }
+    set hoveredSceneObject(sceneObjectId) {
+        if (sceneObjectId === this._hoveredSceneObject) {
+            return;
+        }
+        this._hoveredSceneObject = sceneObjectId;
+        this.notify();
+    }
+}

package/lib/Entities/index.d.ts

@@ -4,28 +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 "./MeshModel";
 export * from "./MessageSystem";
-export * from "./ModelObject";
+export * from "./MouseInput";
+export * from "./ObservableEntity";
+export * from "./ObservableEntityRepo";
 export * from "./ObserverList";
+export * from "./QuestionChallenge";
+export * from "./QuestionChallengeAnswer";
+export * from "./SceneModel";
+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 "./MouseInput";
-export * from "./ObservableEntity";
-export * from "./TouchInput";
-export * from "./QuestionChallengeAnswer";
-export * from "./QuestionChallenge";
-export * from "./SceneRoot";
 export * from "./WorkPlane";

package/lib/Entities/index.js

@@ -16,28 +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("./MeshModel"), exports);
 __exportStar(require("./MessageSystem"), exports);
-__exportStar(require("./ModelObject"), exports);
+__exportStar(require("./MouseInput"), exports);
+__exportStar(require("./ObservableEntity"), exports);
+__exportStar(require("./ObservableEntityRepo"), exports);
 __exportStar(require("./ObserverList"), exports);
+__exportStar(require("./QuestionChallenge"), exports);
+__exportStar(require("./QuestionChallengeAnswer"), exports);
+__exportStar(require("./SceneModel"), 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("./MouseInput"), exports);
-__exportStar(require("./ObservableEntity"), exports);
-__exportStar(require("./TouchInput"), exports);
-__exportStar(require("./QuestionChallengeAnswer"), exports);
-__exportStar(require("./QuestionChallenge"), exports);
-__exportStar(require("./SceneRoot"), 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.40.1",
+  "version": "2.42.0",
   "description": "Public package for the VIVED Learning App system",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",

package/lib/Entities/MeshModel.d.ts

@@ -1,68 +0,0 @@
-import { Quaternion, Vector3 } from "../ValueObjects";
-import { ModelObject } from "./ModelObject";
-import { ObservableEntity } from "./ObservableEntity";
-export interface MeshModelData {
-    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 MeshModel 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(): MeshModelData;
-    abstract setData(data: MeshModelData): void;
-}
-export declare function makeMeshModel(): MeshModel;

package/lib/Entities/MeshModel.js

@@ -1,174 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeMeshModel = exports.MeshModel = 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 MeshModel extends ObservableEntity_1.ObservableEntity {
-}
-exports.MeshModel = MeshModel;
-function makeMeshModel() {
-    return new MeshModelImp();
-}
-exports.makeMeshModel = makeMeshModel;
-class MeshModelImp extends MeshModel {
-    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;
-    }
-}

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();
-        }
-    }
-}