@vived/app 2.40.1 → 2.41.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/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,23 @@
+import { ObservableEntity } from "./ObservableEntity";
+import { SceneModelData } from "./SceneModelData";
+export declare enum SceneModelState {
+    INIT = "Initialized",
+    LOADING = "Loading",
+    READY = "Ready",
+    ERROR = "Error"
+}
+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);
+}
+export declare function makeSceneModel(id: string): SceneModel;

package/lib/Entities/SceneModel.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeSceneModel = exports.SceneModel = exports.SceneModelState = void 0;
+const MemoizedBoolean_1 = require("./MemoizedBoolean");
+const MemoizedString_1 = require("./MemoizedString");
+const ObservableEntity_1 = require("./ObservableEntity");
+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.dataLookup = new Map();
+        this.memoizedMeshHasBeenSetup = new MemoizedBoolean_1.MemoizedBoolean(false, this.notify);
+        this.memoizedState = new MemoizedString_1.MemoizedString(SceneModelState.INIT, this.notify);
+        this.id = id;
+    }
+    get meshHasBeenSetup() {
+        return this.memoizedMeshHasBeenSetup.val;
+    }
+    set meshHasBeenSetup(val) {
+        this.memoizedMeshHasBeenSetup.val = val;
+    }
+    addData(id, data) {
+        this.dataLookup.set(id, data);
+        this.notify();
+    }
+    hasData(id) {
+        return this.dataLookup.has(id);
+    }
+    getData(id) {
+        return this.dataLookup.get(id);
+    }
+    get activeDataID() {
+        return this._activeDataID;
+    }
+    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 state() {
+        return this.memoizedState.val;
+    }
+    set state(val) {
+        this.memoizedState.val = val;
+    }
+    get error() {
+        return this._error;
+    }
+    set error(val) {
+        this._error = val;
+        this.memoizedState.val = SceneModelState.ERROR;
+    }
+}

package/lib/Entities/{MeshModel.d.ts → SceneModelData.d.ts}

@@ -1,7 +1,7 @@
 import { Quaternion, Vector3 } from "../ValueObjects";
 import { ModelObject } from "./ModelObject";
 import { ObservableEntity } from "./ObservableEntity";
-export interface MeshModelData {
+export interface SceneModelDataDTO {
     version: number;
     objects: ObjectData[];
     name: string;
@@ -34,7 +34,7 @@ export interface ObjectData {
     meshPaths: string[];
     label: string;
 }
-export declare abstract class MeshModel extends ObservableEntity {
+export declare abstract class SceneModelData extends ObservableEntity {
     abstract readonly objects: ModelObject[];
     abstract hasObject(id: string): boolean;
     abstract getObjectById(id: string): ModelObject | undefined;
@@ -62,7 +62,7 @@ export declare abstract class MeshModel extends ObservableEntity {
     abstract set defaultRotation(rotation: Quaternion);
     abstract get defaultScale(): number;
     abstract set defaultScale(scale: number);
-    abstract getData(): MeshModelData;
-    abstract setData(data: MeshModelData): void;
+    abstract getData(): SceneModelDataDTO;
+    abstract setData(data: SceneModelDataDTO): void;
 }
-export declare function makeMeshModel(): MeshModel;
+export declare function makeSceneModelData(): SceneModelData;

package/lib/Entities/{MeshModel.js → SceneModelData.js}

@@ -1,20 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeMeshModel = exports.MeshModel = void 0;
+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 MeshModel extends ObservableEntity_1.ObservableEntity {
+class SceneModelData extends ObservableEntity_1.ObservableEntity {
 }
-exports.MeshModel = MeshModel;
-function makeMeshModel() {
-    return new MeshModelImp();
+exports.SceneModelData = SceneModelData;
+function makeSceneModelData() {
+    return new SceneModelDataImp();
 }
-exports.makeMeshModel = makeMeshModel;
-class MeshModelImp extends MeshModel {
+exports.makeSceneModelData = makeSceneModelData;
+class SceneModelDataImp extends SceneModelData {
     constructor() {
         super(...arguments);
         this.objects = [];

package/lib/Entities/SceneModelRepo.d.ts

@@ -0,0 +1,14 @@
+import { ObservableEntityRepo } from "./ObservableEntityRepo";
+import { SceneModel } from "./SceneModel";
+import { SceneModelDataDTO } from "./SceneModelData";
+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 modelLoader(modelID: string): Promise<void>;
+    abstract dataLoader(dataID: string): Promise<SceneModelDataDTO>;
+    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 isLoadingModel() {
+        return this.memoizedIsLoading.val;
+    }
+    set isLoadingModel(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

@@ -13,9 +13,10 @@ export * from "./MemoizedNumber";
 export * from "./MemoizedString";
 export * from "./MemoizedVector2";
 export * from "./MemoizedVector3";
-export * from "./MeshModel";
+export * from "./SceneModelData";
 export * from "./MessageSystem";
 export * from "./ModelObject";
+export * from "./ObservableEntity";
 export * from "./ObserverList";
 export * from "./StateMachine";
 export * from "./Tool";
@@ -27,5 +28,10 @@ export * from "./ObservableEntity";
 export * from "./TouchInput";
 export * from "./QuestionChallengeAnswer";
 export * from "./QuestionChallenge";
+export * from "./SceneModel";
+export * from "./SceneModelData";
+export * from "./SceneModelRepo";
+export * from "./SceneObject";
+export * from "./SceneObjectsRepo";
 export * from "./SceneRoot";
 export * from "./WorkPlane";

package/lib/Entities/index.js

@@ -25,9 +25,10 @@ __exportStar(require("./MemoizedNumber"), exports);
 __exportStar(require("./MemoizedString"), exports);
 __exportStar(require("./MemoizedVector2"), exports);
 __exportStar(require("./MemoizedVector3"), exports);
-__exportStar(require("./MeshModel"), 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);
@@ -39,5 +40,10 @@ __exportStar(require("./ObservableEntity"), exports);
 __exportStar(require("./TouchInput"), exports);
 __exportStar(require("./QuestionChallengeAnswer"), exports);
 __exportStar(require("./QuestionChallenge"), exports);
+__exportStar(require("./SceneModel"), exports);
+__exportStar(require("./SceneModelData"), exports);
+__exportStar(require("./SceneModelRepo"), exports);
+__exportStar(require("./SceneObject"), exports);
+__exportStar(require("./SceneObjectsRepo"), exports);
 __exportStar(require("./SceneRoot"), exports);
 __exportStar(require("./WorkPlane"), exports);

package/package.json

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