@vived/app 4.17.4 → 4.18.0

package/lib/Components/ChannelModel/Mocks/ChannelModelObjectPMMock.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="jest" />
+import { AppObject } from "../../../AppObject";
+import { ChannelModelObjectPM } from "../PMs/ChannelModelObjectPM";
+export declare class ChannelModelObjectPMMock extends ChannelModelObjectPM {
+    vmsAreEqual: jest.Mock<any, any>;
+    constructor(appObject: AppObject);
+}

package/lib/Components/ChannelModel/Mocks/ChannelModelObjectPMMock.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChannelModelObjectPMMock = void 0;
+const ChannelModelObjectPM_1 = require("../PMs/ChannelModelObjectPM");
+class ChannelModelObjectPMMock extends ChannelModelObjectPM_1.ChannelModelObjectPM {
+    constructor(appObject) {
+        super(appObject, ChannelModelObjectPM_1.ChannelModelObjectPM.type);
+        this.vmsAreEqual = jest.fn();
+    }
+}
+exports.ChannelModelObjectPMMock = ChannelModelObjectPMMock;

package/lib/Components/ChannelModel/Mocks/ChannelModelPMMock.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="jest" />
+import { AppObject } from "../../../AppObject";
+import { ChannelModelPM } from "../PMs/ChannelModelPM";
+export declare class ChannelModelPMMock extends ChannelModelPM {
+    vmsAreEqual: jest.Mock<any, any>;
+    constructor(appObject: AppObject);
+}

package/lib/Components/ChannelModel/Mocks/ChannelModelPMMock.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChannelModelPMMock = void 0;
+const ChannelModelPM_1 = require("../PMs/ChannelModelPM");
+class ChannelModelPMMock extends ChannelModelPM_1.ChannelModelPM {
+    constructor(appObject) {
+        super(appObject, ChannelModelPM_1.ChannelModelPM.type);
+        this.vmsAreEqual = jest.fn();
+    }
+}
+exports.ChannelModelPMMock = ChannelModelPMMock;

package/lib/Components/ChannelModel/Mocks/ProcessChannelModelUCMock.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="jest" />
+import { AppObject, AppObjectRepo } from "../../../AppObject";
+import { ProcessChannelModelUC } from "../UC";
+export declare class ProcessChannelModelUCMock extends ProcessChannelModelUC {
+    processChannelModel: jest.Mock<any, any>;
+    constructor(appObject: AppObject);
+}
+export declare function makeProcessChannelModelUCMock(appObjects: AppObjectRepo): ProcessChannelModelUCMock;

package/lib/Components/ChannelModel/Mocks/ProcessChannelModelUCMock.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeProcessChannelModelUCMock = exports.ProcessChannelModelUCMock = void 0;
+const UC_1 = require("../UC");
+class ProcessChannelModelUCMock extends UC_1.ProcessChannelModelUC {
+    constructor(appObject) {
+        super(appObject, UC_1.ProcessChannelModelUC.type);
+        this.processChannelModel = jest.fn().mockResolvedValue(undefined);
+    }
+}
+exports.ProcessChannelModelUCMock = ProcessChannelModelUCMock;
+function makeProcessChannelModelUCMock(appObjects) {
+    return new ProcessChannelModelUCMock(appObjects.getOrCreate("ProcessChannelModelUCMock"));
+}
+exports.makeProcessChannelModelUCMock = makeProcessChannelModelUCMock;

package/lib/Components/ChannelModel/Mocks/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./ChannelModelObjectPMMock";
+export * from "./ChannelModelPMMock";
+export * from "./ProcessChannelModelUCMock";

package/lib/Components/ChannelModel/Mocks/index.js

@@ -0,0 +1,15 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./ChannelModelObjectPMMock"), exports);
+__exportStar(require("./ChannelModelPMMock"), exports);
+__exportStar(require("./ProcessChannelModelUCMock"), exports);

package/lib/Components/ChannelModel/PMs/ChannelModelObjectPM.d.ts

@@ -0,0 +1,12 @@
+import { AppObject, AppObjectPM, AppObjectRepo } from "../../../AppObject";
+export interface ChannelModelObjectVM {
+    label: string;
+    labelValidationMessage: string | null;
+    tags: string[];
+}
+export declare const defaultChannelModelObjectVM: ChannelModelObjectVM;
+export declare abstract class ChannelModelObjectPM extends AppObjectPM<ChannelModelObjectVM> {
+    static type: string;
+    static get(id: string, appObjects: AppObjectRepo): ChannelModelObjectPM | undefined;
+}
+export declare function makeChannelModelObjectPM(appObject: AppObject): ChannelModelObjectPM;

package/lib/Components/ChannelModel/PMs/ChannelModelObjectPM.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeChannelModelObjectPM = exports.ChannelModelObjectPM = exports.defaultChannelModelObjectVM = void 0;
+const AppObject_1 = require("../../../AppObject");
+const Entities_1 = require("../Entities");
+exports.defaultChannelModelObjectVM = {
+    label: "",
+    labelValidationMessage: null,
+    tags: [],
+};
+class ChannelModelObjectPM extends AppObject_1.AppObjectPM {
+    static get(id, appObjects) {
+        var _a;
+        return (_a = appObjects
+            .get(id)) === null || _a === void 0 ? void 0 : _a.getComponent(ChannelModelObjectPM.type);
+    }
+}
+exports.ChannelModelObjectPM = ChannelModelObjectPM;
+ChannelModelObjectPM.type = "ChannelModelObjectPM";
+function makeChannelModelObjectPM(appObject) {
+    return new ChannelModelObjectPMImp(appObject);
+}
+exports.makeChannelModelObjectPM = makeChannelModelObjectPM;
+class ChannelModelObjectPMImp extends ChannelModelObjectPM {
+    constructor(appObject) {
+        var _a;
+        super(appObject, ChannelModelObjectPM.type);
+        this.onEntityChange = () => {
+            if (!this.modelObject)
+                return;
+            const vm = {
+                label: this.modelObject.label,
+                labelValidationMessage: this.modelObject.labelValidationMessage,
+                tags: this.modelObject.tags,
+            };
+            this.doUpdateView(vm);
+        };
+        (_a = this.modelObject) === null || _a === void 0 ? void 0 : _a.addChangeObserver(this.onEntityChange);
+        this.onEntityChange();
+    }
+    get modelObject() {
+        return this.getCachedLocalComponent(Entities_1.ChannelModelObject.type);
+    }
+    vmsAreEqual(a, b) {
+        if (a.label !== b.label)
+            return false;
+        if (a.labelValidationMessage !== b.labelValidationMessage)
+            return false;
+        if (a.tags.length !== b.tags.length)
+            return false;
+        let tagsAreTheSame = true;
+        a.tags.forEach((tagA, i) => {
+            const tagB = b.tags[i];
+            if (tagA !== tagB) {
+                tagsAreTheSame = false;
+            }
+        });
+        return tagsAreTheSame;
+    }
+}

package/lib/Components/ChannelModel/PMs/ChannelModelPM.d.ts

@@ -0,0 +1,11 @@
+import { AppObject, AppObjectPM, AppObjectRepo } from "../../../AppObject";
+export interface ChannelModelVM {
+    childHasValidationMessage: boolean;
+    modelObjectIds: string[];
+}
+export declare const defaultChannelModelVM: ChannelModelVM;
+export declare abstract class ChannelModelPM extends AppObjectPM<ChannelModelVM> {
+    static type: string;
+    static get(id: string, appObjects: AppObjectRepo): ChannelModelPM | undefined;
+}
+export declare function makeChannelModelPM(appObject: AppObject): ChannelModelPM;

package/lib/Components/ChannelModel/PMs/ChannelModelPM.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeChannelModelPM = exports.ChannelModelPM = exports.defaultChannelModelVM = void 0;
+const AppObject_1 = require("../../../AppObject");
+const Entities_1 = require("../Entities");
+exports.defaultChannelModelVM = {
+    childHasValidationMessage: false,
+    modelObjectIds: [],
+};
+class ChannelModelPM extends AppObject_1.AppObjectPM {
+    static get(id, appObjects) {
+        var _a;
+        return (_a = appObjects
+            .get(id)) === null || _a === void 0 ? void 0 : _a.getComponent(ChannelModelPM.type);
+    }
+}
+exports.ChannelModelPM = ChannelModelPM;
+ChannelModelPM.type = "ChannelModelPM";
+function makeChannelModelPM(appObject) {
+    return new ChannelModelPMImp(appObject);
+}
+exports.makeChannelModelPM = makeChannelModelPM;
+class ChannelModelPMImp extends ChannelModelPM {
+    constructor(appObject) {
+        var _a;
+        super(appObject, ChannelModelPM.type);
+        this.onEntityChange = () => {
+            if (!this.modelEntity)
+                return;
+            let childHasValidationMessage = false;
+            this.modelEntity.modelObjects().forEach(obj => {
+                if (childHasValidationMessage) {
+                    // Don't need to keep checking
+                    return;
+                }
+                if (obj.labelValidationMessage !== null) {
+                    childHasValidationMessage = true;
+                }
+            });
+            const vm = {
+                childHasValidationMessage,
+                modelObjectIds: this.modelEntity.modelObjectIds,
+            };
+            this.doUpdateView(vm);
+        };
+        (_a = this.modelEntity) === null || _a === void 0 ? void 0 : _a.addChangeObserver(this.onEntityChange);
+        this.onEntityChange();
+    }
+    get modelEntity() {
+        return this.getCachedLocalComponent(Entities_1.ChannelModelEntity.type);
+    }
+    vmsAreEqual(a, b) {
+        if (a.childHasValidationMessage !== b.childHasValidationMessage)
+            return false;
+        if (a.modelObjectIds.length !== b.modelObjectIds.length)
+            return false;
+        let objectsAreTheSame = true;
+        a.modelObjectIds.forEach((objA, i) => {
+            const objB = b.modelObjectIds[i];
+            if (objA !== objB) {
+                objectsAreTheSame = false;
+            }
+        });
+        return objectsAreTheSame;
+    }
+}

package/lib/Components/ChannelModel/PMs/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./ChannelModelObjectPM";
+export * from "./ChannelModelPM";

package/lib/Components/ChannelModel/PMs/index.js

@@ -0,0 +1,14 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./ChannelModelObjectPM"), exports);
+__exportStar(require("./ChannelModelPM"), exports);

package/lib/Components/ChannelModel/UC/InitializeChannelModelFromGLB.js

@@ -0,0 +1 @@
+"use strict";

package/lib/Components/ChannelModel/UC/SetupChannelModelUC.d.ts

@@ -1,10 +1,9 @@
-import { AppObject, AppObjectRepo, AppObjectUC } from "../../../AppObject";
-import { ChannelModel } from "../Entities";
+import { AppObjectRepo, AppObjectUC } from "../../../AppObject";
+import { ChannelModelEntity } from "../Entities";
 export declare const SCENE_MODEL_DATA_ASSET_LINK_TYPE = "default_model_data";
 export declare abstract class SetupChannelModelUC extends AppObjectUC {
     static readonly type: string;
     static readonly SCENE_MODEL_DATA_ASSET_LINK_TYPE = "default_model_data";
-    abstract setupChannelModel(modelID: string): Promise<ChannelModel>;
+    abstract setupChannelModel(modelID: string): Promise<ChannelModelEntity>;
     static get: (appObjects: AppObjectRepo) => SetupChannelModelUC | undefined;
 }
-export declare function makeSetupChannelModelUC(appObject: AppObject): SetupChannelModelUC;

package/lib/Components/ChannelModel/UC/SetupChannelModelUC.js

@@ -1,22 +1,7 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeSetupChannelModelUC = exports.SetupChannelModelUC = exports.SCENE_MODEL_DATA_ASSET_LINK_TYPE = void 0;
+exports.SetupChannelModelUC = exports.SCENE_MODEL_DATA_ASSET_LINK_TYPE = void 0;
 const AppObject_1 = require("../../../AppObject");
-const ValueObjects_1 = require("../../../ValueObjects");
-const Dispatcher_1 = require("../../Dispatcher");
-const Label_1 = require("../../Label");
-const Mesh_1 = require("../../Mesh");
-const Entities_1 = require("../Entities");
-const ProcessChannelModelUC_1 = require("./ProcessChannelModelUC");
 exports.SCENE_MODEL_DATA_ASSET_LINK_TYPE = "default_model_data";
 class SetupChannelModelUC extends AppObject_1.AppObjectUC {
 }
@@ -24,118 +9,3 @@ exports.SetupChannelModelUC = SetupChannelModelUC;
 SetupChannelModelUC.type = "SetupChannelModelUC";
 SetupChannelModelUC.SCENE_MODEL_DATA_ASSET_LINK_TYPE = "default_model_data";
 SetupChannelModelUC.get = (appObjects) => AppObject_1.getSingletonComponent(SetupChannelModelUC.type, appObjects);
-function makeSetupChannelModelUC(appObject) {
-    return new SetupChannelModelUCImp(appObject);
-}
-exports.makeSetupChannelModelUC = makeSetupChannelModelUC;
-class SetupChannelModelUCImp extends SetupChannelModelUC {
-    constructor(appObject) {
-        super(appObject, SetupChannelModelUC.type);
-        this.setupChannelModel = (modelID) => __awaiter(this, void 0, void 0, function* () {
-            const channelModelRepo = this.appObject.getComponent(Entities_1.ChannelModelRepo.type);
-            if (!channelModelRepo) {
-                this.warn("Unable to get channelModelRepo from the model repo App Object");
-                return Promise.reject(new Error("No Channel Model Repo"));
-            }
-            const processModel = ProcessChannelModelUC_1.ProcessChannelModelUC.get(this.appObjects);
-            if (!processModel) {
-                return Promise.reject(new Error("No Process ModelUC"));
-            }
-            const appObj = this.appObjects.getOrCreate(modelID);
-            const channelModel = channelModelRepo.makeIfMissing(appObj);
-            if (channelModel.state === Entities_1.ChannelModelState.LOADING) {
-                return Promise.resolve(channelModel);
-            }
-            if (channelModel.state === Entities_1.ChannelModelState.READY) {
-                return Promise.resolve(channelModel);
-            }
-            channelModel.modelError = undefined;
-            channelModel.state = Entities_1.ChannelModelState.LOADING;
-            channelModelRepo.isLoadingChannelModel = true;
-            const spinner = Dispatcher_1.ShowSpinnerUC.get(this.appObjects);
-            let closeSpinner = () => {
-                // done
-            };
-            if (spinner) {
-                closeSpinner = yield spinner.showSpinner("Loading active model and data", "Loading...");
-            }
-            try {
-                const { bounds_max, bounds_min, defaultPosition, defaultRotation, defaultScale, name, objects, } = yield this.modelDataLoader(modelID);
-                channelModel.name = name;
-                channelModel.bounds_max = ValueObjects_1.Vector3.FromDTO(bounds_max);
-                channelModel.bounds_min = ValueObjects_1.Vector3.FromDTO(bounds_min);
-                channelModel.defaultPosition = ValueObjects_1.Vector3.FromDTO(defaultPosition);
-                channelModel.defaultScale = defaultScale;
-                channelModel.defaultRotation = ValueObjects_1.Quaternion.FromDTO(defaultRotation);
-                const meshes = [];
-                objects.forEach((mesh) => {
-                    const { id, label, meshPaths } = mesh;
-                    meshes.push(mesh.id);
-                    this.setupMeshObject(id, label, meshPaths);
-                });
-                channelModel.meshList = meshes;
-                yield processModel.processChannelModel(modelID);
-                channelModel.state = Entities_1.ChannelModelState.READY;
-                channelModelRepo.isLoadingChannelModel = false;
-                Dispatcher_1.dispatchStateChange(this.appObjects);
-                closeSpinner();
-                return Promise.resolve(channelModel);
-            }
-            catch (e) {
-                const error = e;
-                if (channelModelRepo) {
-                    channelModelRepo.isLoadingChannelModel = false;
-                }
-                channelModel.modelError = error;
-                closeSpinner();
-                const alertDTO = {
-                    title: "Load Error",
-                    message: `Failed to Load the Model and Data. Error message: ${error.message}`,
-                    closeButtonLabel: "OK",
-                    closeCallback: () => {
-                        // done
-                    },
-                };
-                const showAlertUC = Dispatcher_1.ShowAlertUC.get(this.appObjects);
-                if (showAlertUC) {
-                    showAlertUC.showAlert(alertDTO);
-                }
-                else {
-                    this.warn(alertDTO.message);
-                }
-                return Promise.reject(error);
-            }
-        });
-    }
-    setupMeshObject(id, label, meshPaths) {
-        const appObj = this.appObjects.getOrCreate(id);
-        const labelEntity = Label_1.Label.addIfMissing(appObj);
-        labelEntity.default = label;
-        const meshEntity = Mesh_1.Mesh.addIfMissing(appObj);
-        meshPaths.forEach((meshPath) => {
-            meshEntity.addSubMesh({
-                meshPath,
-                neutralPosition: ValueObjects_1.Vector3.Zero(),
-                neutralRotation: ValueObjects_1.Quaternion.Identity(),
-                neutralScale: ValueObjects_1.Vector3.One(),
-            });
-        });
-    }
-    modelDataLoader(modelID) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const dataAssets = yield Dispatcher_1.getLinkedAssets(modelID, SetupChannelModelUC.SCENE_MODEL_DATA_ASSET_LINK_TYPE, this.appObjects);
-                if (dataAssets.length === 0) {
-                    return Promise.reject(new Error("Model asset does not have data"));
-                }
-                const dataFileBlobURL = yield Dispatcher_1.getAssetBlobURL(dataAssets[0].id, this.appObjects);
-                const fetchDataResp = yield fetch(dataFileBlobURL);
-                const modelJSONData = yield fetchDataResp.json();
-                return Promise.resolve(modelJSONData);
-            }
-            catch (e) {
-                return Promise.reject(e);
-            }
-        });
-    }
-}

package/lib/Components/ChannelModel/index.d.ts

@@ -1,2 +1,6 @@
+export * from "./Adapters";
+export * from "./Controllers";
 export * from "./Entities";
+export * from "./Mocks";
+export * from "./PMs";
 export * from "./UC";

package/lib/Components/ChannelModel/index.js

@@ -10,5 +10,9 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Adapters"), exports);
+__exportStar(require("./Controllers"), exports);
 __exportStar(require("./Entities"), exports);
+__exportStar(require("./Mocks"), exports);
+__exportStar(require("./PMs"), exports);
 __exportStar(require("./UC"), exports);

package/lib/Components/GLBModel/Entities/GblModelRepo.d.ts

@@ -0,0 +1,9 @@
+import { AppObject, AppObjectEntityRepo, AppObjectRepo } from "../../../AppObject";
+import { GlbModelEntity } from "./GlbModelEntity";
+export declare abstract class GlbModelRepo extends AppObjectEntityRepo<GlbModelEntity> {
+    static type: string;
+    abstract sceneModelFactory(id: string): GlbModelEntity;
+    abstract createSceneModel(id?: string): GlbModelEntity;
+    static get(appObjects: AppObjectRepo): GlbModelRepo | undefined;
+}
+export declare function makeGlbModelRepo(appObject: AppObject): GlbModelRepo;

package/lib/Components/GLBModel/Entities/GblModelRepo.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeGlbModelRepo = exports.GlbModelRepo = void 0;
+const AppObject_1 = require("../../../AppObject");
+const Utilities_1 = require("../../../Utilities");
+const GlbModelEntity_1 = require("./GlbModelEntity");
+class GlbModelRepo extends AppObject_1.AppObjectEntityRepo {
+    static get(appObjects) {
+        return AppObject_1.getSingletonComponent(GlbModelRepo.type, appObjects);
+    }
+}
+exports.GlbModelRepo = GlbModelRepo;
+GlbModelRepo.type = "GlbModelRepo";
+function makeGlbModelRepo(appObject) {
+    return new GlbModelRepoImp(appObject);
+}
+exports.makeGlbModelRepo = makeGlbModelRepo;
+class GlbModelRepoImp extends GlbModelRepo {
+    constructor(appObject) {
+        super(appObject, GlbModelRepo.type);
+        this.sceneModelFactory = (id) => {
+            const ao = this.appObjects.getOrCreate(id);
+            return GlbModelEntity_1.makeGlbModelEntity(ao);
+        };
+        this.createSceneModel = (id) => {
+            const idToUse = id !== null && id !== void 0 ? id : Utilities_1.generateUniqueID();
+            const object = this.sceneModelFactory(idToUse);
+            this.add(object);
+            return object;
+        };
+    }
+}

package/lib/Components/GLBModel/Entities/GlbModelEntity.d.ts

@@ -0,0 +1,26 @@
+import { AppObject, AppObjectEntity } from "../../../AppObject";
+export declare enum GlbModelState {
+    INIT = "Initialized",
+    LOADING = "Loading",
+    READY = "Ready",
+    ERROR = "Error"
+}
+export interface GLBMesh {
+    path: string;
+    name: string;
+    mesh: unknown;
+}
+export declare abstract class GlbModelEntity extends AppObjectEntity {
+    static type: string;
+    abstract get id(): string;
+    abstract get state(): GlbModelState;
+    abstract set state(val: GlbModelState);
+    abstract get modelError(): Error | undefined;
+    abstract set modelError(val: Error | undefined);
+    abstract rootNode?: unknown;
+    abstract hasMesh(path: string): boolean;
+    abstract getMesh(path: string): GLBMesh | undefined;
+    abstract addMesh(mesh: GLBMesh): void;
+    abstract getAllMeshes(): GLBMesh[];
+}
+export declare function makeGlbModelEntity(appObject: AppObject): GlbModelEntity;

package/lib/Components/GLBModel/Entities/GlbModelEntity.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeGlbModelEntity = exports.GlbModelEntity = exports.GlbModelState = void 0;
+const AppObject_1 = require("../../../AppObject");
+const Entities_1 = require("../../../Entities");
+var GlbModelState;
+(function (GlbModelState) {
+    GlbModelState["INIT"] = "Initialized";
+    GlbModelState["LOADING"] = "Loading";
+    GlbModelState["READY"] = "Ready";
+    GlbModelState["ERROR"] = "Error";
+})(GlbModelState = exports.GlbModelState || (exports.GlbModelState = {}));
+class GlbModelEntity extends AppObject_1.AppObjectEntity {
+}
+exports.GlbModelEntity = GlbModelEntity;
+GlbModelEntity.type = "GlbModelEntity";
+function makeGlbModelEntity(appObject) {
+    return new GlbModelEntityImp(appObject);
+}
+exports.makeGlbModelEntity = makeGlbModelEntity;
+class GlbModelEntityImp extends GlbModelEntity {
+    constructor(appObject) {
+        super(appObject, GlbModelEntity.type);
+        this._state = new Entities_1.MemoizedString(GlbModelState.INIT, this.notifyOnChange);
+        this.meshLookup = new Map();
+        this.hasMesh = (id) => {
+            return this.meshLookup.has(id);
+        };
+        this.getMesh = (path) => {
+            return this.meshLookup.get(path);
+        };
+        this.addMesh = (mesh) => {
+            this.meshLookup.set(mesh.path, mesh);
+            this.notifyOnChange();
+        };
+        this.getAllMeshes = () => {
+            return Array.from(this.meshLookup.values());
+        };
+    }
+    get id() {
+        return this.appObject.id;
+    }
+    get state() {
+        return this._state.val;
+    }
+    set state(val) {
+        this._state.val = val;
+    }
+    get modelError() {
+        return this._error;
+    }
+    set modelError(val) {
+        this._error = val;
+        this._state.val = GlbModelState.ERROR;
+    }
+}

package/lib/Components/GLBModel/Entities/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./GblModelRepo";
+export * from "./GlbModelEntity";

package/lib/Components/GLBModel/Entities/index.js

@@ -0,0 +1,14 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./GblModelRepo"), exports);
+__exportStar(require("./GlbModelEntity"), exports);

package/lib/Components/GLBModel/Mocks/LoadGlbFileUCMock.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="jest" />
+import { AppObject, AppObjectRepo } from "../../../AppObject";
+import { LoadGlbFileUC } from "../UCs/LoadGlbFileUC";
+export declare class LoadGlbFileUCMock extends LoadGlbFileUC {
+    loadFile: jest.Mock<any, any>;
+    constructor(appObject: AppObject);
+}
+export declare function makeLoadGlbFileUCMock(appObjects: AppObjectRepo): LoadGlbFileUCMock;

package/lib/Components/GLBModel/Mocks/LoadGlbFileUCMock.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeLoadGlbFileUCMock = exports.LoadGlbFileUCMock = void 0;
+const LoadGlbFileUC_1 = require("../UCs/LoadGlbFileUC");
+class LoadGlbFileUCMock extends LoadGlbFileUC_1.LoadGlbFileUC {
+    constructor(appObject) {
+        super(appObject, LoadGlbFileUC_1.LoadGlbFileUC.type);
+        this.loadFile = jest.fn().mockResolvedValue(undefined);
+    }
+}
+exports.LoadGlbFileUCMock = LoadGlbFileUCMock;
+function makeLoadGlbFileUCMock(appObjects) {
+    return new LoadGlbFileUCMock(appObjects.getOrCreate("LoadGlbFileUCMock"));
+}
+exports.makeLoadGlbFileUCMock = makeLoadGlbFileUCMock;

package/lib/Components/GLBModel/Mocks/index.d.ts

@@ -0,0 +1 @@
+export * from "./LoadGlbFileUCMock";

package/lib/Components/GLBModel/Mocks/index.js

@@ -0,0 +1,13 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./LoadGlbFileUCMock"), exports);

package/lib/Components/GLBModel/UCs/LoadGlbFileUC.d.ts

@@ -0,0 +1,7 @@
+import { AppObjectRepo, AppObjectUC } from "../../../AppObject";
+import { GlbModelEntity } from "../Entities/GlbModelEntity";
+export declare abstract class LoadGlbFileUC extends AppObjectUC {
+    static type: string;
+    abstract loadFile(file: File, glbEntity: GlbModelEntity): Promise<void>;
+    static get(appObjects: AppObjectRepo): LoadGlbFileUC | undefined;
+}