@vived/app 4.23.0 → 4.24.0

package/lib/AppObject/index.d.ts

@@ -7,3 +7,4 @@ export * from "./AppObjectUC";
 export * from "./AppObjectController";
 export * from "./AppObjectView";
 export * from "./getSingletonComponent";
+export * from "./printAppObjectDetails";

package/lib/AppObject/index.js

@@ -19,3 +19,4 @@ __exportStar(require("./AppObjectUC"), exports);
 __exportStar(require("./AppObjectController"), exports);
 __exportStar(require("./AppObjectView"), exports);
 __exportStar(require("./getSingletonComponent"), exports);
+__exportStar(require("./printAppObjectDetails"), exports);

package/lib/AppObject/printAppObjectDetails.d.ts

@@ -0,0 +1,2 @@
+import { AppObjectRepo } from "./AppObjectRepo";
+export declare function printAppObjectDetails(id: string, appObjects: AppObjectRepo): void;

package/lib/AppObject/printAppObjectDetails.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printAppObjectDetails = void 0;
+function printAppObjectDetails(id, appObjects) {
+    const appObject = appObjects.get(id);
+    if (!appObject) {
+        console.warn("[printAppObjectDetails] Unable to find App Object by ID");
+        return;
+    }
+    console.log("[printAppObjectDetails] Start App Object Details ---");
+    console.log(`id: ${appObject.id}`);
+    const components = appObject.allComponents();
+    components.forEach((component) => {
+        console.log(`Has Component: ${component.type}`);
+    });
+    console.log("[printAppObjectDetails] End App Object Details ---");
+}
+exports.printAppObjectDetails = printAppObjectDetails;

package/lib/Components/ChannelModel/Adapters/activeModelAdapter.js

@@ -7,7 +7,7 @@ exports.activeModelAdapter = {
     subscribe: (appObjects, setVM) => {
         const pm = ActiveModelPM_1.ActiveModelPM.get(appObjects);
         if (!pm) {
-            appObjects.submitError("animationFrameAdapter", "Unable to find ActiveModelPM");
+            appObjects.submitError("activeModelAdapter", "Unable to find ActiveModelPM");
             return;
         }
         pm.addView(setVM);
@@ -15,7 +15,7 @@ exports.activeModelAdapter = {
     unsubscribe: (appObjects, setVM) => {
         const pm = ActiveModelPM_1.ActiveModelPM.get(appObjects);
         if (!pm) {
-            appObjects.submitError("animationFrameAdapter", "Unable to find ActiveModelPM");
+            appObjects.submitError("activeModelAdapter", "Unable to find ActiveModelPM");
             return;
         }
         pm.removeView(setVM);

package/lib/Components/ChannelModel/Adapters/activeModelObjectListAdapter.d.ts

@@ -0,0 +1,2 @@
+import { SingletonPmAdapter } from "../../../Types";
+export declare const activeModelObjectListAdapter: SingletonPmAdapter<string[]>;

package/lib/Components/ChannelModel/Adapters/activeModelObjectListAdapter.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.activeModelObjectListAdapter = void 0;
+const ActiveModelObjectListPM_1 = require("../PMs/ActiveModelObjectListPM");
+exports.activeModelObjectListAdapter = {
+    defaultVM: [],
+    subscribe: (appObjects, setVM) => {
+        const pm = ActiveModelObjectListPM_1.ActiveModelObjectListPM.get(appObjects);
+        if (!pm) {
+            appObjects.submitError("activeModelObjectListAdapter", "Unable to find ActiveModelObjectListPM");
+            return;
+        }
+        pm.addView(setVM);
+    },
+    unsubscribe: (appObjects, setVM) => {
+        const pm = ActiveModelObjectListPM_1.ActiveModelObjectListPM.get(appObjects);
+        if (!pm) {
+            appObjects.submitError("activeModelObjectListAdapter", "Unable to find ActiveModelObjectListPM");
+            return;
+        }
+        pm.removeView(setVM);
+    },
+};

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

@@ -1,3 +1,5 @@
 export * from "./activeModelAdapter";
+export * from "./activeModelObjectListAdapter";
 export * from "./channelModelAdapter";
 export * from "./channelModelObjectAdapter";
+export * from "./modelObjectsAreHiddenAdapter";

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

@@ -11,5 +11,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./activeModelAdapter"), exports);
+__exportStar(require("./activeModelObjectListAdapter"), exports);
 __exportStar(require("./channelModelAdapter"), exports);
 __exportStar(require("./channelModelObjectAdapter"), exports);
+__exportStar(require("./modelObjectsAreHiddenAdapter"), exports);

package/lib/Components/ChannelModel/Adapters/modelObjectsAreHiddenAdapter.d.ts

@@ -0,0 +1,2 @@
+import { PmAdapter } from "../../../Types/PmAdapter";
+export declare const modelObjectsAreHiddenAdapter: PmAdapter<boolean>;

package/lib/Components/ChannelModel/Adapters/modelObjectsAreHiddenAdapter.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.modelObjectsAreHiddenAdapter = void 0;
+const ModelObjectsAreHiddenPM_1 = require("../PMs/ModelObjectsAreHiddenPM");
+exports.modelObjectsAreHiddenAdapter = {
+    defaultVM: false,
+    subscribe: (id, appObjects, setVM) => {
+        if (!id)
+            return;
+        const pm = ModelObjectsAreHiddenPM_1.ModelObjectsAreHiddenPM.get(id, appObjects);
+        if (!pm) {
+            appObjects.submitError("modelObjectsAreHiddenAdapter", "Unable to find ModelObjectsAreHiddenPM");
+            return;
+        }
+        pm.addView(setVM);
+    },
+    unsubscribe: (id, appObjects, setVM) => {
+        if (!id)
+            return;
+        const pm = ModelObjectsAreHiddenPM_1.ModelObjectsAreHiddenPM.get(id, appObjects);
+        if (!pm) {
+            appObjects.submitError("modelObjectsAreHiddenAdapter", "Unable to find ModelObjectsAreHiddenPM");
+            return;
+        }
+        pm.removeView(setVM);
+    }
+};

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

@@ -1,2 +1,2 @@
 export * from "./clickSelectChannelModel";
-export * from "./setModelObjectLabel";
+export * from "./unhideAllActiveObjects";

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

@@ -11,4 +11,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./clickSelectChannelModel"), exports);
-__exportStar(require("./setModelObjectLabel"), exports);
+__exportStar(require("./unhideAllActiveObjects"), exports);

package/lib/Components/ChannelModel/Controllers/setModelObjectLabel.js

@@ -5,7 +5,7 @@ const Entities_1 = require("../Entities");
 function setModelObjectLabel(label, id, appObjects) {
     const entity = Entities_1.ChannelModelObject.get(id, appObjects);
     if (entity) {
-        entity.label = label;
+        entity.label.custom = label;
     }
     else {
         appObjects.submitWarning("setModelObjectLabel", "Unable to find object by ID");

package/lib/Components/ChannelModel/Controllers/unhideAllActiveObjects.d.ts

@@ -0,0 +1,2 @@
+import { AppObjectRepo } from "../../../AppObject";
+export declare function unhideAllActiveObjects(appObjects: AppObjectRepo): void;

package/lib/Components/ChannelModel/Controllers/unhideAllActiveObjects.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unhideAllActiveObjects = void 0;
+const ChannelModelRepo_1 = require("../Entities/ChannelModelRepo");
+const UnhideAllChannelModelObjectsUC_1 = require("../UC/UnhideAllChannelModelObjectsUC");
+function unhideAllActiveObjects(appObjects) {
+    const repo = ChannelModelRepo_1.ChannelModelRepo.get(appObjects);
+    if (!repo) {
+        appObjects.submitError("unhideAllActiveObjects", "Unable to find ChannelModelRepo");
+        return;
+    }
+    if (!repo.activeModel) {
+        appObjects.submitWarning("unhideAllActiveObjects", "No Model is Active");
+        return;
+    }
+    const uc = UnhideAllChannelModelObjectsUC_1.UnhideAllChannelModelObjectsUC.get(repo.activeModel, appObjects);
+    if (!uc) {
+        appObjects.submitError("unhideAllActiveObjects", "Unable to find UnhideAllChannelModelObjectsUC");
+        return;
+    }
+    uc.unhideAll();
+}
+exports.unhideAllActiveObjects = unhideAllActiveObjects;

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

@@ -12,6 +12,8 @@ export declare abstract class ChannelModelEntity extends AppObjectEntity {
     abstract get id(): string;
     abstract get name(): string;
     abstract set name(val: string);
+    abstract get enabled(): boolean;
+    abstract set enabled(val: boolean);
     abstract get bounds_min(): Vector3;
     abstract set bounds_min(val: Vector3);
     abstract get bounds_max(): Vector3;

package/lib/Components/ChannelModel/Entities/ChannelModel.js

@@ -5,6 +5,7 @@ const AppObject_1 = require("../../../AppObject");
 const Entities_1 = require("../../../Entities");
 const Utilities_1 = require("../../../Utilities");
 const ValueObjects_1 = require("../../../ValueObjects");
+const Enablement_1 = require("../../Enablement");
 const ChannelModelObject_1 = require("./ChannelModelObject");
 var ChannelModelState;
 (function (ChannelModelState) {
@@ -114,7 +115,7 @@ class ChannelModelEntityImp extends ChannelModelEntity {
                     if ("id" in obj) {
                         const modelObj = this.addModelObject(obj.id);
                         if ("label" in obj) {
-                            modelObj.label = obj.label;
+                            modelObj.label.default = obj.label;
                         }
                         if ("meshPaths" in obj) {
                             modelObj.subMeshPaths = obj.meshPaths;
@@ -126,6 +127,8 @@ class ChannelModelEntityImp extends ChannelModelEntity {
                 });
             }
         };
+        this.enablement = Enablement_1.makeEnablementEntity(appObject);
+        this.enablement.addChangeObserver(this.notifyOnChange);
     }
     get id() {
         return this.appObject.id;
@@ -185,6 +188,12 @@ class ChannelModelEntityImp extends ChannelModelEntity {
         this._error = val;
         this._state.val = ChannelModelState.ERROR;
     }
+    get enabled() {
+        return this.enablement.enabled;
+    }
+    set enabled(val) {
+        this.enablement.enabled = val;
+    }
     get modelObjectIds() {
         return Array.from(this.modelObjectLookup.keys());
     }
@@ -193,7 +202,7 @@ class ChannelModelEntityImp extends ChannelModelEntity {
         const objects = modelObjects.map((obj) => {
             return {
                 id: obj.id,
-                label: obj.label,
+                label: obj.label.default,
                 meshPaths: [...obj.subMeshPaths],
                 tags: [...obj.tags],
             };

package/lib/Components/ChannelModel/Entities/ChannelModelObject.d.ts

@@ -1,11 +1,9 @@
 import { AppObject, AppObjectEntity, AppObjectRepo } from "../../../AppObject";
+import { LabelEntity } from "../../Label";
 export declare abstract class ChannelModelObject extends AppObjectEntity {
     static readonly type = "ChannelModelObject";
     abstract get id(): string;
-    abstract get label(): string;
-    abstract set label(val: string);
-    abstract get labelValidationMessage(): string | null;
-    abstract labelValidator(val: string): string | null;
+    abstract label: LabelEntity;
     abstract get tags(): string[];
     abstract set tags(val: string[]);
     abstract get subMeshPaths(): string[];

package/lib/Components/ChannelModel/Entities/ChannelModelObject.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeChannelModelObject = exports.ChannelModelObject = void 0;
 const AppObject_1 = require("../../../AppObject");
-const Entities_1 = require("../../../Entities");
+const Label_1 = require("../../Label");
 class ChannelModelObject extends AppObject_1.AppObjectEntity {
     static get(id, appObjects) {
         const appObject = appObjects.get(id);
@@ -22,31 +22,14 @@ exports.makeChannelModelObject = makeChannelModelObject;
 class ChannelModelObjectImp extends ChannelModelObject {
     constructor(appObject) {
         super(appObject, ChannelModelObject.type);
-        this.memoisedLabel = new Entities_1.MemoizedString("", this.notifyOnChange);
-        this.labelValidator = (val) => {
-            if (val.length === 0) {
-                return "Object name cannot be empty";
-            }
-            else if (val.length > 40) {
-                return "Object names are limited to 40 characters";
-            }
-            return null;
-        };
         this._tags = [];
         this._subMeshes = [];
+        this.label = Label_1.makeLabelEntity(appObject);
+        this.label.addChangeObserver(this.notifyOnChange);
     }
     get id() {
         return this.appObject.id;
     }
-    get label() {
-        return this.memoisedLabel.val;
-    }
-    set label(val) {
-        this.memoisedLabel.val = val;
-    }
-    get labelValidationMessage() {
-        return this.labelValidator(this.memoisedLabel.val);
-    }
     get tags() {
         return [...this._tags];
     }

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

@@ -0,0 +1,8 @@
+/// <reference types="jest" />
+import { AppObject, AppObjectRepo } from "../../../AppObject";
+import { ActiveModelObjectListPM } from "../PMs/ActiveModelObjectListPM";
+export declare class ActiveModelObjectListMock extends ActiveModelObjectListPM {
+    vmsAreEqual: jest.Mock<any, any>;
+    constructor(appObject: AppObject);
+}
+export declare function makeActiveModelObjectListMock(appObjects: AppObjectRepo): ActiveModelObjectListMock;

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

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeActiveModelObjectListMock = exports.ActiveModelObjectListMock = void 0;
+const ActiveModelObjectListPM_1 = require("../PMs/ActiveModelObjectListPM");
+class ActiveModelObjectListMock extends ActiveModelObjectListPM_1.ActiveModelObjectListPM {
+    constructor(appObject) {
+        super(appObject, ActiveModelObjectListPM_1.ActiveModelObjectListPM.type);
+        this.vmsAreEqual = jest.fn();
+    }
+}
+exports.ActiveModelObjectListMock = ActiveModelObjectListMock;
+function makeActiveModelObjectListMock(appObjects) {
+    return new ActiveModelObjectListMock(appObjects.getOrCreate("ActiveModelObjectListMock"));
+}
+exports.makeActiveModelObjectListMock = makeActiveModelObjectListMock;

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

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

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

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

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

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

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

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnhideAllChannelModelObjectsUCMock = void 0;
+const UnhideAllChannelModelObjectsUC_1 = require("../UC/UnhideAllChannelModelObjectsUC");
+class UnhideAllChannelModelObjectsUCMock extends UnhideAllChannelModelObjectsUC_1.UnhideAllChannelModelObjectsUC {
+    constructor(appObject) {
+        super(appObject, UnhideAllChannelModelObjectsUC_1.UnhideAllChannelModelObjectsUC.type);
+        this.unhideAll = jest.fn();
+    }
+}
+exports.UnhideAllChannelModelObjectsUCMock = UnhideAllChannelModelObjectsUCMock;

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

@@ -1,6 +1,9 @@
 export * from "./ActiveModelMock";
+export * from "./ActiveModelObjectListMock";
 export * from "./ChannelModelObjectPMMock";
 export * from "./ChannelModelPMMock";
 export * from "./ChannelModelViewFactoryMock";
 export * from "./LoadChannelModelMock";
+export * from "./ModelObjectsAreHiddenPMMock";
 export * from "./SelectChannelModelUCMock";
+export * from "./UnhideAllChannelModelObjectsUCMock";

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

@@ -11,8 +11,11 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./ActiveModelMock"), exports);
+__exportStar(require("./ActiveModelObjectListMock"), exports);
 __exportStar(require("./ChannelModelObjectPMMock"), exports);
 __exportStar(require("./ChannelModelPMMock"), exports);
 __exportStar(require("./ChannelModelViewFactoryMock"), exports);
 __exportStar(require("./LoadChannelModelMock"), exports);
+__exportStar(require("./ModelObjectsAreHiddenPMMock"), exports);
 __exportStar(require("./SelectChannelModelUCMock"), exports);
+__exportStar(require("./UnhideAllChannelModelObjectsUCMock"), exports);

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

@@ -0,0 +1,14 @@
+import { AppObject, AppObjectPM, AppObjectRepo } from "../../../AppObject";
+export declare abstract class ActiveModelObjectListPM extends AppObjectPM<string[]> {
+    static readonly type = "ActiveModelObjectListPM";
+    static get(appObjects: AppObjectRepo): ActiveModelObjectListPM | undefined;
+}
+export declare function makeActiveModelObjectListPM(appObject: AppObject): ActiveModelObjectListPMImp;
+declare class ActiveModelObjectListPMImp extends ActiveModelObjectListPM {
+    private get repo();
+    private lastActiveModelID?;
+    vmsAreEqual(a: string[], b: string[]): boolean;
+    onEntityChange: () => void;
+    constructor(appObject: AppObject);
+}
+export {};

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

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeActiveModelObjectListPM = exports.ActiveModelObjectListPM = void 0;
+const AppObject_1 = require("../../../AppObject");
+const Entities_1 = require("../Entities");
+class ActiveModelObjectListPM extends AppObject_1.AppObjectPM {
+    static get(appObjects) {
+        return AppObject_1.getSingletonComponent(ActiveModelObjectListPM.type, appObjects);
+    }
+}
+exports.ActiveModelObjectListPM = ActiveModelObjectListPM;
+ActiveModelObjectListPM.type = "ActiveModelObjectListPM";
+function makeActiveModelObjectListPM(appObject) {
+    return new ActiveModelObjectListPMImp(appObject);
+}
+exports.makeActiveModelObjectListPM = makeActiveModelObjectListPM;
+class ActiveModelObjectListPMImp extends ActiveModelObjectListPM {
+    constructor(appObject) {
+        var _a;
+        super(appObject, ActiveModelObjectListPM.type);
+        this.onEntityChange = () => {
+            if (!this.repo)
+                return;
+            if (this.lastActiveModelID === this.repo.activeModel)
+                return;
+            let vm = [];
+            if (this.repo.activeModel) {
+                const model = this.repo.getChannelModel(this.repo.activeModel, false);
+                if (model) {
+                    vm = model.modelObjectIds;
+                    this.lastActiveModelID = this.repo.activeModel;
+                }
+            }
+            else {
+                this.lastActiveModelID = "";
+            }
+            this.doUpdateView(vm);
+        };
+        (_a = this.repo) === null || _a === void 0 ? void 0 : _a.addChangeObserver(this.onEntityChange);
+        this.onEntityChange();
+        this.appObjects.registerSingleton(this);
+    }
+    get repo() {
+        return this.getCachedSingleton(Entities_1.ChannelModelRepo.type);
+    }
+    vmsAreEqual(a, b) {
+        if (a.length !== b.length)
+            return false;
+        let arraysAreEqual = true;
+        a.forEach((aID, i) => {
+            if (!arraysAreEqual)
+                return;
+            const bID = b[i];
+            if (aID !== bID) {
+                arraysAreEqual = false;
+            }
+        });
+        return arraysAreEqual;
+    }
+}

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

@@ -29,8 +29,8 @@ class ChannelModelObjectPMImp extends ChannelModelObjectPM {
             if (!this.modelObject)
                 return;
             const vm = {
-                label: this.modelObject.label,
-                labelValidationMessage: this.modelObject.labelValidationMessage,
+                label: this.modelObject.label.display,
+                labelValidationMessage: this.modelObject.label.customLabelValidationMessage,
                 tags: this.modelObject.tags,
             };
             this.doUpdateView(vm);

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

@@ -33,7 +33,7 @@ class ChannelModelPMImp extends ChannelModelPM {
                     // Don't need to keep checking
                     return;
                 }
-                if (obj.labelValidationMessage !== null) {
+                if (obj.label.customLabelValidationMessage !== null) {
                     childHasValidationMessage = true;
                 }
             });

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

@@ -0,0 +1,6 @@
+import { AppObject, AppObjectPM, AppObjectRepo } from "../../../AppObject";
+export declare abstract class ModelObjectsAreHiddenPM extends AppObjectPM<boolean> {
+    static readonly type = "ModelObjectsAreHiddenPM";
+    static get(appObjID: string, appObjects: AppObjectRepo): ModelObjectsAreHiddenPM | undefined;
+}
+export declare function makeModelObjectsAreHiddenPM(appObject: AppObject): ModelObjectsAreHiddenPM;

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

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeModelObjectsAreHiddenPM = exports.ModelObjectsAreHiddenPM = void 0;
+const AppObject_1 = require("../../../AppObject");
+const Hideable_1 = require("../../Hideable/Entities/Hideable");
+const ChannelModel_1 = require("../Entities/ChannelModel");
+class ModelObjectsAreHiddenPM extends AppObject_1.AppObjectPM {
+    static get(appObjID, appObjects) {
+        var _a;
+        return (_a = appObjects
+            .get(appObjID)) === null || _a === void 0 ? void 0 : _a.getComponent(ModelObjectsAreHiddenPM.type);
+    }
+}
+exports.ModelObjectsAreHiddenPM = ModelObjectsAreHiddenPM;
+ModelObjectsAreHiddenPM.type = "ModelObjectsAreHiddenPM";
+function makeModelObjectsAreHiddenPM(appObject) {
+    return new ModelObjectsAreHiddenPMImp(appObject);
+}
+exports.makeModelObjectsAreHiddenPM = makeModelObjectsAreHiddenPM;
+class ModelObjectsAreHiddenPMImp extends ModelObjectsAreHiddenPM {
+    constructor(appObject) {
+        super(appObject, ModelObjectsAreHiddenPM.type);
+        this.onRepoChange = () => {
+            if (!this.channelModel)
+                return;
+            let hidden = false;
+            this.channelModel.modelObjects().forEach((obj) => {
+                var _a;
+                if (hidden)
+                    return;
+                if ((_a = obj.appObject.getComponent(Hideable_1.Hideable.type)) === null || _a === void 0 ? void 0 : _a.isHidden) {
+                    hidden = true;
+                }
+            });
+            this.doUpdateView(hidden);
+        };
+        this.dispose = () => {
+            var _a, _b;
+            super.dispose();
+            (_a = this.channelModel) === null || _a === void 0 ? void 0 : _a.removeChangeObserver(this.onRepoChange);
+            (_b = this.channelModel) === null || _b === void 0 ? void 0 : _b.removeOnDisposeObserver(this.dispose);
+        };
+        if (this.channelModel) {
+            this.channelModel.addChangeObserver(this.onRepoChange);
+            this.channelModel.addOnDisposeObserver(() => this.dispose());
+            this.onRepoChange();
+        }
+        else {
+            this.error("App Object does not have a ChannelModelEntity");
+        }
+    }
+    get channelModel() {
+        return this.getCachedLocalComponent(ChannelModel_1.ChannelModelEntity.type);
+    }
+    vmsAreEqual(a, b) {
+        return a === b;
+    }
+}

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

@@ -1,3 +1,5 @@
+export * from "./ActiveModelObjectListPM";
 export * from "./ActiveModelPM";
 export * from "./ChannelModelObjectPM";
 export * from "./ChannelModelPM";
+export * from "./ModelObjectsAreHiddenPM";

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

@@ -10,6 +10,8 @@ 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("./ActiveModelObjectListPM"), exports);
 __exportStar(require("./ActiveModelPM"), exports);
 __exportStar(require("./ChannelModelObjectPM"), exports);
 __exportStar(require("./ChannelModelPM"), exports);
+__exportStar(require("./ModelObjectsAreHiddenPM"), exports);

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

@@ -36,6 +36,9 @@ class SelectChannelModelUCImp extends SelectChannelModelUC {
                 sceneRoot.rotation = channelModel.defaultRotation;
                 sceneRoot.scale = channelModel.defaultScale;
                 repo.activeModel = channelModel.id;
+                repo.getAll().forEach((model) => {
+                    model.enabled = model.id === channelModel.id;
+                });
                 return channelModel.id;
             });
         };

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

@@ -0,0 +1,10 @@
+import { AppObjectRepo } from "../../../AppObject";
+import { UndoRedoAction } from "../../UndoRedo/Entities/UndoRedoEntity";
+export declare class UnhideAllAppObjectsUndoRedo implements UndoRedoAction {
+    private appObjectIDs;
+    private appObjects;
+    undoAction: () => void;
+    redoAction: () => void;
+    private setIsHiddenOnAppObject;
+    constructor(appObjectIDs: string[], appObjects: AppObjectRepo);
+}

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

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnhideAllAppObjectsUndoRedo = void 0;
+const DispatchStateChangeUC_1 = require("../../Dispatcher/UC/DispatchStateChangeUC");
+const Hideable_1 = require("../../Hideable/Entities/Hideable");
+const UndoRedoEntity_1 = require("../../UndoRedo/Entities/UndoRedoEntity");
+class UnhideAllAppObjectsUndoRedo {
+    constructor(appObjectIDs, appObjects) {
+        this.appObjectIDs = appObjectIDs;
+        this.appObjects = appObjects;
+        this.undoAction = () => {
+            const appObjectIDs = this.appObjectIDs;
+            appObjectIDs.forEach((appObjID) => {
+                this.setIsHiddenOnAppObject(true, appObjID);
+            });
+            DispatchStateChangeUC_1.dispatchStateChange(this.appObjects);
+        };
+        this.redoAction = () => {
+            const appObjectIDs = this.appObjectIDs;
+            appObjectIDs.forEach((appObjID) => {
+                this.setIsHiddenOnAppObject(false, appObjID);
+            });
+            DispatchStateChangeUC_1.dispatchStateChange(this.appObjects);
+        };
+        const undoRedo = UndoRedoEntity_1.UndoRedoEntity.get(this.appObjects);
+        if (!undoRedo) {
+            this.appObjects.submitWarning("UnhideAllAppObjectsUndoRedoDTO", "Unable to find UndoRedoEntity");
+            return;
+        }
+        undoRedo.submitAction(this);
+    }
+    setIsHiddenOnAppObject(isHidden, appObjID) {
+        const hideable = Hideable_1.Hideable.get(appObjID, this.appObjects);
+        if (!hideable)
+            return;
+        hideable.isHidden = isHidden;
+    }
+}
+exports.UnhideAllAppObjectsUndoRedo = UnhideAllAppObjectsUndoRedo;