@vived/app 4.17.4 → 4.18.0

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

@@ -0,0 +1,3 @@
+import { PmAdapter } from "../../../Types";
+import { ChannelModelVM } from "../PMs/ChannelModelPM";
+export declare const channelModelAdapter: PmAdapter<ChannelModelVM>;

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

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

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

@@ -0,0 +1,3 @@
+import { PmAdapter } from "../../../Types";
+import { ChannelModelObjectVM } from "../PMs/ChannelModelObjectPM";
+export declare const channelModelObjectAdapter: PmAdapter<ChannelModelObjectVM>;

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

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

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

@@ -0,0 +1,2 @@
+export * from "./channelModelAdapter";
+export * from "./channelModelObjectAdapter";

package/lib/Components/ChannelModel/Adapters/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("./channelModelAdapter"), exports);
+__exportStar(require("./channelModelObjectAdapter"), exports);

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

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

package/lib/Components/ChannelModel/Controllers/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("./setModelObjectLabel"), exports);

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

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

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

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setModelObjectLabel = void 0;
+const Entities_1 = require("../Entities");
+function setModelObjectLabel(label, id, appObjects) {
+    const entity = Entities_1.ChannelModelObject.get(id, appObjects);
+    if (entity) {
+        entity.label = label;
+    }
+    else {
+        appObjects.submitWarning("setModelObjectLabel", "Unable to find object by ID");
+    }
+}
+exports.setModelObjectLabel = setModelObjectLabel;

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

@@ -1,42 +1,140 @@
-import { AppObject, AppObjectEntity } from "../../../AppObject";
+import { AppObject, AppObjectEntity, AppObjectRepo } from "../../../AppObject";
 import { Quaternion, Vector3 } from "../../../ValueObjects";
+import { ChannelModelObject } from "./ChannelModelObject";
 export declare enum ChannelModelState {
     INIT = "Initialized",
     LOADING = "Loading",
     READY = "Ready",
     ERROR = "Error"
 }
-export declare class ChannelModel extends AppObjectEntity {
-    static readonly type = "CHANNEL_MODEL";
-    static addIfMissing(appObj: AppObject): ChannelModel;
-    static get(appObj: AppObject): ChannelModel | undefined;
-    private _name;
-    get name(): string;
-    set name(name: string);
-    private _boundsMin;
-    get bounds_min(): Vector3;
-    set bounds_min(bounds_min: Vector3);
-    private _boundsMax;
-    get bounds_max(): Vector3;
-    set bounds_max(bounds_max: Vector3);
-    private _defaultPosition;
-    get defaultPosition(): Vector3;
-    set defaultPosition(position: Vector3);
-    private _defaultRotation;
-    get defaultRotation(): Quaternion;
-    set defaultRotation(rotation: Quaternion);
-    private _defaultScale;
-    get defaultScale(): number;
-    set defaultScale(scale: number);
-    private _state;
-    get state(): ChannelModelState;
-    set state(val: ChannelModelState);
-    private _error;
-    get modelError(): Error | undefined;
-    set modelError(val: Error | undefined);
-    private _meshList;
-    get meshList(): string[];
-    set meshList(val: string[]);
-    dispose: () => void;
-    constructor(appObject: AppObject);
+export declare abstract class ChannelModelEntity extends AppObjectEntity {
+    static readonly type = "ChannelModelEntity";
+    abstract get id(): string;
+    abstract get name(): string;
+    abstract set name(val: string);
+    abstract get bounds_min(): Vector3;
+    abstract set bounds_min(val: Vector3);
+    abstract get bounds_max(): Vector3;
+    abstract set bounds_max(val: Vector3);
+    abstract get defaultPosition(): Vector3;
+    abstract set defaultPosition(val: Vector3);
+    abstract get defaultRotation(): Quaternion;
+    abstract set defaultRotation(val: Quaternion);
+    abstract get defaultScale(): number;
+    abstract set defaultScale(val: number);
+    abstract get state(): ChannelModelState;
+    abstract set state(val: ChannelModelState);
+    abstract get modelError(): Error | undefined;
+    abstract set modelError(val: Error | undefined);
+    abstract get modelObjectIds(): string[];
+    abstract get data(): ChannelModelDTOv2;
+    abstract setupFromData(data: ChannelModelDTOv0 | ChannelModelDTOv1 | ChannelModelDTOv2): void;
+    abstract originalCollectionID?: string;
+    abstract modelObjectFactory(id: string): ChannelModelObject;
+    abstract addModelObject(id?: string): ChannelModelObject;
+    abstract hasModelObject(id: string): boolean;
+    abstract getModelObject(id: string): ChannelModelObject | undefined;
+    abstract modelObjects(): ChannelModelObject[];
+    static get(id: string, appObjects: AppObjectRepo): ChannelModelEntity | undefined;
+}
+export declare function makeChannelModelEntity(appObject: AppObject): ChannelModelEntity;
+export interface ChannelModelDTOv2 {
+    version: 2;
+    objects: ChannelModelDataMeshDTOv2[];
+    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;
+    originalCollectionID?: string;
+}
+export interface ChannelModelDTOv1 {
+    version: number;
+    objects: ChannelModelDataMeshDTOv1[];
+    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;
+}
+export interface ChannelModelDTOv0 {
+    version: number;
+    objects: ChannelModelDataMeshDTOv0[];
+    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 ChannelModelDataMeshDTOv2 {
+    id: string;
+    meshPaths: string[];
+    label: string;
+    tags: string[];
+}
+export interface ChannelModelDataMeshDTOv1 {
+    version: number;
+    id: string;
+    meshPaths: string[];
+    label: string;
+}
+export interface ChannelModelDataMeshDTOv0 {
+    id: string;
+    meshPaths: string[];
+    label: string;
 }

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

@@ -1,9 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ChannelModel = exports.ChannelModelState = void 0;
+exports.makeChannelModelEntity = exports.ChannelModelEntity = exports.ChannelModelState = void 0;
 const AppObject_1 = require("../../../AppObject");
 const Entities_1 = require("../../../Entities");
+const Utilities_1 = require("../../../Utilities");
 const ValueObjects_1 = require("../../../ValueObjects");
+const ChannelModelObject_1 = require("./ChannelModelObject");
 var ChannelModelState;
 (function (ChannelModelState) {
     ChannelModelState["INIT"] = "Initialized";
@@ -11,9 +13,25 @@ var ChannelModelState;
     ChannelModelState["READY"] = "Ready";
     ChannelModelState["ERROR"] = "Error";
 })(ChannelModelState = exports.ChannelModelState || (exports.ChannelModelState = {}));
-class ChannelModel extends AppObject_1.AppObjectEntity {
+class ChannelModelEntity extends AppObject_1.AppObjectEntity {
+    static get(id, appObjects) {
+        const appObject = appObjects.get(id);
+        if (!appObject) {
+            appObjects.submitWarning("ChannelModel.get", "Unable to find app object by ID");
+            return;
+        }
+        return appObject.getComponent(ChannelModelEntity.type);
+    }
+}
+exports.ChannelModelEntity = ChannelModelEntity;
+ChannelModelEntity.type = "ChannelModelEntity";
+function makeChannelModelEntity(appObject) {
+    return new ChannelModelEntityImp(appObject);
+}
+exports.makeChannelModelEntity = makeChannelModelEntity;
+class ChannelModelEntityImp extends ChannelModelEntity {
     constructor(appObject) {
-        super(appObject, ChannelModel.type);
+        super(appObject, ChannelModelEntity.type);
         this._name = new Entities_1.MemoizedString("", this.notifyOnChange);
         this._boundsMin = new Entities_1.MemoizedVector3(ValueObjects_1.Vector3.Zero(), this.notifyOnChange);
         this._boundsMax = new Entities_1.MemoizedVector3(ValueObjects_1.Vector3.Zero(), this.notifyOnChange);
@@ -21,22 +39,21 @@ class ChannelModel extends AppObject_1.AppObjectEntity {
         this._defaultRotation = new Entities_1.MemoizedQuaternion(ValueObjects_1.Quaternion.Identity(), this.notifyOnChange);
         this._defaultScale = new Entities_1.MemoizedNumber(1, this.notifyOnChange);
         this._state = new Entities_1.MemoizedString(ChannelModelState.INIT, this.notifyOnChange);
-        this._meshList = [];
-        this.dispose = () => {
-            super.dispose();
+        this.modelObjectLookup = new Map();
+        this.setupFromData = (data) => {
+            if (data.version === 2) {
+                this.setupDataV2(data);
+            }
+            else if (data.version === 1) {
+                this.setupDataV2(this.mapDataV1toV2(data));
+            }
+            else if (data.version === 0) {
+                this.setupDataV2(this.mapDataV0toV2(data));
+            }
         };
     }
-    static addIfMissing(appObj) {
-        const existing = appObj.getComponent(this.type);
-        if (existing) {
-            return existing;
-        }
-        else {
-            return new ChannelModel(appObj);
-        }
-    }
-    static get(appObj) {
-        return appObj.getComponent(this.type);
+    get id() {
+        return this.appObject.id;
     }
     get name() {
         return this._name.val;
@@ -87,13 +104,111 @@ class ChannelModel extends AppObject_1.AppObjectEntity {
         this._error = val;
         this._state.val = ChannelModelState.ERROR;
     }
-    get meshList() {
-        return [...this._meshList];
+    modelObjectFactory(id) {
+        const ao = this.appObjects.getOrCreate(id);
+        return ChannelModelObject_1.makeChannelModelObject(ao);
     }
-    set meshList(val) {
-        this._meshList = [...val];
+    addModelObject(id) {
+        const idToUse = id !== null && id !== void 0 ? id : Utilities_1.generateUniqueID();
+        const obj = this.modelObjectFactory(idToUse);
+        this.modelObjectLookup.set(idToUse, obj);
+        obj.addChangeObserver(this.notifyOnChange);
         this.notifyOnChange();
+        return obj;
+    }
+    getModelObject(id) {
+        return this.modelObjectLookup.get(id);
+    }
+    hasModelObject(id) {
+        return this.modelObjectLookup.has(id);
+    }
+    modelObjects() {
+        return Array.from(this.modelObjectLookup.values());
+    }
+    get modelObjectIds() {
+        return Array.from(this.modelObjectLookup.keys());
+    }
+    get data() {
+        const modelObjects = Array.from(this.modelObjectLookup.values());
+        const objects = modelObjects.map((obj) => {
+            return {
+                id: obj.id,
+                label: obj.label,
+                meshPaths: [...obj.subMeshPaths],
+                tags: [...obj.tags],
+            };
+        });
+        return {
+            bounds_max: this._boundsMax.val.dto,
+            bounds_min: this._boundsMin.val.dto,
+            defaultPosition: this._defaultPosition.val.dto,
+            defaultRotation: this._defaultRotation.val.dto,
+            defaultScale: this._defaultScale.val,
+            name: this._name.val,
+            objects,
+            version: 2,
+            originalCollectionID: this.originalCollectionID,
+        };
+    }
+    setupDataV2(data) {
+        const { bounds_max, bounds_min, defaultPosition, defaultRotation, defaultScale, name, objects, originalCollectionID, } = data;
+        this.bounds_max = ValueObjects_1.Vector3.FromDTO(bounds_max);
+        this.bounds_min = ValueObjects_1.Vector3.FromDTO(bounds_min);
+        this.defaultPosition = ValueObjects_1.Vector3.FromDTO(defaultPosition);
+        this.defaultRotation = ValueObjects_1.Quaternion.FromDTO(defaultRotation);
+        this.defaultScale = defaultScale;
+        this.name = name;
+        this.originalCollectionID = originalCollectionID;
+        objects.forEach((obj) => {
+            const { id, label, meshPaths, tags } = obj;
+            const modelObj = this.addModelObject(id);
+            modelObj.label = label;
+            modelObj.subMeshPaths = meshPaths;
+            modelObj.tags = tags;
+        });
+    }
+    mapDataV1toV2(data) {
+        const { bounds_max, bounds_min, defaultPosition, defaultRotation, defaultScale, name, objects, } = data;
+        const mappedObject = objects.map((obj) => {
+            const { id, label, meshPaths } = obj;
+            return {
+                id,
+                label,
+                meshPaths,
+                tags: [],
+            };
+        });
+        return {
+            bounds_max,
+            bounds_min,
+            defaultPosition,
+            defaultRotation,
+            defaultScale,
+            name,
+            objects: mappedObject,
+            version: 2,
+        };
+    }
+    mapDataV0toV2(data) {
+        const { bounds_max, bounds_min, defaultPosition, defaultRotation, defaultScale, name, objects, } = data;
+        const mappedObject = objects.map((obj) => {
+            const { id, label, meshPaths } = obj;
+            return {
+                id,
+                label,
+                meshPaths,
+                tags: [],
+            };
+        });
+        return {
+            bounds_max,
+            bounds_min,
+            defaultPosition,
+            defaultRotation,
+            defaultScale,
+            name,
+            objects: mappedObject,
+            version: 2,
+        };
     }
 }
-exports.ChannelModel = ChannelModel;
-ChannelModel.type = "CHANNEL_MODEL";

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

@@ -0,0 +1,15 @@
+import { AppObject, AppObjectEntity, AppObjectRepo } from "../../../AppObject";
+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 get tags(): string[];
+    abstract set tags(val: string[]);
+    abstract get subMeshPaths(): string[];
+    abstract set subMeshPaths(val: string[]);
+    static get(id: string, appObjects: AppObjectRepo): ChannelModelObject | undefined;
+}
+export declare function makeChannelModelObject(appObject: AppObject): ChannelModelObject;

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

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeChannelModelObject = exports.ChannelModelObject = void 0;
+const AppObject_1 = require("../../../AppObject");
+const Entities_1 = require("../../../Entities");
+class ChannelModelObject extends AppObject_1.AppObjectEntity {
+    static get(id, appObjects) {
+        const appObject = appObjects.get(id);
+        if (!appObject) {
+            appObjects.submitWarning("ChannelModelObject.get", "Unable to find app object by ID");
+            return;
+        }
+        return appObject.getComponent(ChannelModelObject.type);
+    }
+}
+exports.ChannelModelObject = ChannelModelObject;
+ChannelModelObject.type = "ChannelModelObject";
+function makeChannelModelObject(appObject) {
+    return new ChannelModelObjectImp(appObject);
+}
+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 = [];
+    }
+    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];
+    }
+    set tags(val) {
+        this._tags = [...val];
+        this.notifyOnChange();
+    }
+    get subMeshPaths() {
+        return [...this._subMeshes];
+    }
+    set subMeshPaths(val) {
+        this._subMeshes = [...val];
+        this.notifyOnChange();
+    }
+}

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

@@ -1,12 +1,12 @@
 import { AppObject, AppObjectEntityRepo, AppObjectRepo } from "../../../AppObject";
-import { ChannelModel } from "./ChannelModel";
-export declare class ChannelModelRepo extends AppObjectEntityRepo<ChannelModel> {
+import { ChannelModelEntity } from "./ChannelModel";
+export declare abstract class ChannelModelRepo extends AppObjectEntityRepo<ChannelModelEntity> {
     static readonly type = "CHANNEL_MODEL_REPO";
+    abstract get isLoadingChannelModel(): boolean;
+    abstract set isLoadingChannelModel(val: boolean);
+    abstract getChannelModel(id: string, createIfMissing: boolean): ChannelModelEntity | undefined;
+    abstract channelModelFactory(id: string): ChannelModelEntity;
+    abstract createChannelModel(id?: string): ChannelModelEntity;
     static get: (appObjects: AppObjectRepo) => ChannelModelRepo | undefined;
-    static addToAO(appObj: AppObject): ChannelModelRepo;
-    private memoizedIsLoading;
-    get isLoadingChannelModel(): boolean;
-    set isLoadingChannelModel(val: boolean);
-    makeIfMissing(appObject: AppObject): ChannelModel;
-    constructor(appObject: AppObject);
 }
+export declare function makeChannelModelRepo(appObject: AppObject): ChannelModelRepo;

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

@@ -1,16 +1,41 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ChannelModelRepo = void 0;
+exports.makeChannelModelRepo = exports.ChannelModelRepo = void 0;
 const AppObject_1 = require("../../../AppObject");
 const Entities_1 = require("../../../Entities");
+const Utilities_1 = require("../../../Utilities");
 const ChannelModel_1 = require("./ChannelModel");
 class ChannelModelRepo extends AppObject_1.AppObjectEntityRepo {
+}
+exports.ChannelModelRepo = ChannelModelRepo;
+ChannelModelRepo.type = "CHANNEL_MODEL_REPO";
+ChannelModelRepo.get = (appObjects) => AppObject_1.getSingletonComponent(ChannelModelRepo.type, appObjects);
+function makeChannelModelRepo(appObject) {
+    return new ChannelModelRepoImp(appObject);
+}
+exports.makeChannelModelRepo = makeChannelModelRepo;
+class ChannelModelRepoImp extends ChannelModelRepo {
     constructor(appObject) {
         super(appObject, ChannelModelRepo.type);
         this.memoizedIsLoading = new Entities_1.MemoizedBoolean(false, this.notifyOnChange);
-    }
-    static addToAO(appObj) {
-        return new ChannelModelRepo(appObj);
+        this.getChannelModel = (id, createIfMissing) => {
+            let rVal = this.getForAppObject(id);
+            if (rVal === undefined && createIfMissing) {
+                rVal = this.channelModelFactory(id);
+                this.add(rVal);
+            }
+            return rVal;
+        };
+        this.createChannelModel = (id) => {
+            const idToUse = id !== null && id !== void 0 ? id : Utilities_1.generateUniqueID();
+            const object = this.channelModelFactory(idToUse);
+            this.add(object);
+            return object;
+        };
+        this.channelModelFactory = (id) => {
+            const ao = this.appObjects.getOrCreate(id);
+            return ChannelModel_1.makeChannelModelEntity(ao);
+        };
     }
     get isLoadingChannelModel() {
         return this.memoizedIsLoading.val;
@@ -18,18 +43,4 @@ class ChannelModelRepo extends AppObject_1.AppObjectEntityRepo {
     set isLoadingChannelModel(val) {
         this.memoizedIsLoading.val = val;
     }
-    makeIfMissing(appObject) {
-        const existing = this.getForAppObject(appObject.id);
-        if (existing) {
-            return existing;
-        }
-        else {
-            const newEntity = new ChannelModel_1.ChannelModel(appObject);
-            this.add(newEntity);
-            return newEntity;
-        }
-    }
 }
-exports.ChannelModelRepo = ChannelModelRepo;
-ChannelModelRepo.type = "CHANNEL_MODEL_REPO";
-ChannelModelRepo.get = (appObjects) => AppObject_1.getSingletonComponent(ChannelModelRepo.type, appObjects);

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

@@ -1,2 +1,3 @@
 export * from "./ChannelModel";
+export * from "./ChannelModelObject";
 export * from "./ChannelModelRepo";

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

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