@vived/app 2.51.0 → 3.0.0

package/lib/AppObject/AppObject.d.ts

@@ -0,0 +1,15 @@
+import { ObservableEntity } from "../Entities";
+import { AppObjectComponent } from "./AppObjectComponent";
+import { AppObjectRepo } from "./AppObjectRepo";
+export declare abstract class AppObject extends ObservableEntity {
+    abstract readonly id: string;
+    abstract get enabled(): boolean;
+    abstract set enabled(val: boolean);
+    abstract hasComponent(type: string): boolean;
+    abstract addComponent(component: AppObjectComponent): void;
+    abstract getComponent<T extends AppObjectComponent>(type: string): T | undefined;
+    abstract removeComponent(type: string): void;
+    abstract allComponents(): AppObjectComponent[];
+    abstract dispose(): void;
+}
+export declare function makeAppObject(id: string, repo: AppObjectRepo): AppObject;

package/lib/AppObject/AppObject.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeAppObject = exports.AppObject = void 0;
+const Entities_1 = require("../Entities");
+class AppObject extends Entities_1.ObservableEntity {
+}
+exports.AppObject = AppObject;
+function makeAppObject(id, repo) {
+    return new AppObjectImp(id, repo);
+}
+exports.makeAppObject = makeAppObject;
+class AppObjectImp extends AppObject {
+    constructor(id, repo) {
+        super();
+        this.repo = repo;
+        this.memoizedEnabled = new Entities_1.MemoizedBoolean(true, this.notify);
+        this.componentLookup = new Map();
+        this.dispose = () => {
+            const components = Array.from(this.componentLookup.values());
+            this.componentLookup.clear();
+            components.forEach(c => c.dispose());
+            if (this.repo.has(this.id)) {
+                this.repo.remove(this.id);
+            }
+        };
+        this.id = id;
+        this.repo.add(this);
+    }
+    get enabled() {
+        return this.memoizedEnabled.val;
+    }
+    set enabled(val) {
+        this.memoizedEnabled.val = val;
+    }
+    hasComponent(type) {
+        return this.componentLookup.has(type);
+    }
+    addComponent(component) {
+        const currentComponent = this.componentLookup.get(component.type);
+        if (currentComponent) {
+            console.warn(`[AppObject] Component ${component.type} is being replaced on ${this.id}`);
+            currentComponent.dispose();
+        }
+        this.componentLookup.set(component.type, component);
+        this.notify();
+    }
+    getComponent(type) {
+        if (this.componentLookup.has(type)) {
+            return this.componentLookup.get(type);
+        }
+        else {
+            return undefined;
+        }
+    }
+    removeComponent(type) {
+        const component = this.componentLookup.get(type);
+        if (!component)
+            return;
+        this.componentLookup.delete(type);
+        this.notify();
+    }
+    allComponents() {
+        return Array.from(this.componentLookup.values());
+    }
+}

package/lib/AppObject/AppObjectComponent.d.ts

@@ -0,0 +1,6 @@
+import { AppObject } from "./AppObject";
+export interface AppObjectComponent {
+    readonly type: string;
+    readonly appObject: AppObject;
+    dispose: () => void;
+}

package/lib/AppObject/AppObjectComponent.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/AppObject/AppObjectEntity.d.ts

@@ -0,0 +1,16 @@
+import { AppObject } from "./AppObject";
+import { AppObjectComponent } from "./AppObjectComponent";
+export declare type EntityObserver = () => void;
+export declare class AppObjectEntity implements AppObjectComponent {
+    readonly type: string;
+    readonly appObject: AppObject;
+    private onDisposeObserverList;
+    addOnDisposeObserver: (observer: EntityObserver) => void;
+    removeOnDisposeObserver: (observer: EntityObserver) => void;
+    private onChangeObserverList;
+    addChangeObserver: (observer: EntityObserver) => void;
+    removeChangeObserver: (observer: EntityObserver) => void;
+    notifyOnChange: () => void;
+    dispose(): void;
+    constructor(appObject: AppObject, type: string);
+}

package/lib/AppObject/AppObjectEntity.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppObjectEntity = void 0;
+const Entities_1 = require("../Entities");
+class AppObjectEntity {
+    constructor(appObject, type) {
+        this.onDisposeObserverList = new Entities_1.ObserverList();
+        this.addOnDisposeObserver = (observer) => {
+            this.onDisposeObserverList.add(observer);
+        };
+        this.removeOnDisposeObserver = (observer) => {
+            this.onDisposeObserverList.remove(observer);
+        };
+        this.onChangeObserverList = new Entities_1.ObserverList();
+        this.addChangeObserver = (observer) => {
+            this.onChangeObserverList.add(observer);
+        };
+        this.removeChangeObserver = (observer) => {
+            this.onChangeObserverList.remove(observer);
+        };
+        this.notifyOnChange = () => {
+            this.onChangeObserverList.notify();
+        };
+        this.appObject = appObject;
+        this.type = type;
+        appObject.addComponent(this);
+        this.addChangeObserver(appObject.notify);
+    }
+    dispose() {
+        this.removeChangeObserver(this.appObject.notify);
+        this.onDisposeObserverList.notify();
+        this.onChangeObserverList.clear();
+        this.onDisposeObserverList.clear();
+        if (this.appObject.getComponent(this.type) === this) {
+            this.appObject.removeComponent(this.type);
+        }
+    }
+    ;
+}
+exports.AppObjectEntity = AppObjectEntity;

package/lib/AppObject/AppObjectEntityRepo.d.ts

@@ -0,0 +1,15 @@
+import { AppObjectEntity } from "./AppObjectEntity";
+export declare abstract class AppObjectEntityRepo<T extends AppObjectEntity> extends AppObjectEntity {
+    private entityLookup;
+    private onEntityAddedObservers;
+    addEntityAddedObserver: (observer: (addedEntity: T) => void) => void;
+    removeEntityAddedObserver: (observer: (addedEntity: T) => void) => void;
+    private onEntityRemovedObservers;
+    addEntityRemovedObserver: (observer: (removedEntity: T) => void) => void;
+    removeEntityRemovedObserver: (observer: (removedEntity: T) => void) => void;
+    hasForAppObject: (appObjectID: string) => boolean;
+    add: (entity: T) => void;
+    removeForAppObject: (id: string) => void;
+    getForAppObject: (appObjectID: string) => T | undefined;
+    getAll: () => T[];
+}

package/lib/AppObject/AppObjectEntityRepo.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppObjectEntityRepo = void 0;
+const Entities_1 = require("../Entities");
+const AppObjectEntity_1 = require("./AppObjectEntity");
+class AppObjectEntityRepo extends AppObjectEntity_1.AppObjectEntity {
+    constructor() {
+        super(...arguments);
+        this.entityLookup = new Map();
+        this.onEntityAddedObservers = new Entities_1.ObserverList();
+        this.addEntityAddedObserver = (observer) => {
+            this.onEntityAddedObservers.add(observer);
+        };
+        this.removeEntityAddedObserver = (observer) => {
+            this.onEntityAddedObservers.remove(observer);
+        };
+        this.onEntityRemovedObservers = new Entities_1.ObserverList();
+        this.addEntityRemovedObserver = (observer) => {
+            this.onEntityRemovedObservers.add(observer);
+        };
+        this.removeEntityRemovedObserver = (observer) => {
+            this.onEntityRemovedObservers.remove(observer);
+        };
+        this.hasForAppObject = (appObjectID) => {
+            return this.entityLookup.has(appObjectID);
+        };
+        this.add = (entity) => {
+            const existing = this.entityLookup.get(entity.appObject.id);
+            if (existing) {
+                existing.removeChangeObserver(this.notifyOnChange);
+            }
+            this.entityLookup.set(entity.appObject.id, entity);
+            entity.addChangeObserver(this.notifyOnChange);
+            this.notifyOnChange();
+            this.onEntityAddedObservers.notify(entity);
+        };
+        this.removeForAppObject = (id) => {
+            const existing = this.entityLookup.get(id);
+            if (!existing)
+                return;
+            this.entityLookup.delete(id);
+            existing.removeChangeObserver(this.notifyOnChange);
+            this.notifyOnChange();
+            this.onEntityRemovedObservers.notify(existing);
+        };
+        this.getForAppObject = (appObjectID) => {
+            return this.entityLookup.get(appObjectID);
+        };
+        this.getAll = () => {
+            return Array.from(this.entityLookup.values());
+        };
+    }
+}
+exports.AppObjectEntityRepo = AppObjectEntityRepo;

package/lib/AppObject/AppObjectPM.d.ts

@@ -0,0 +1,15 @@
+import { AppObject } from "./AppObject";
+import { AppObjectComponent } from "./AppObjectComponent";
+export declare abstract class AppObjectPM<T> implements AppObjectComponent {
+    readonly type: string;
+    readonly appObject: AppObject;
+    abstract vmsAreEqual(a: T, b: T): boolean;
+    private _lastVM?;
+    get lastVM(): T | undefined;
+    private observerList;
+    addView: (updateView: (vm: T) => void) => void;
+    removeView: (updateView: (vm: T) => void) => void;
+    doUpdateView: (vm: T) => void;
+    dispose(): void;
+    constructor(appObject: AppObject, type: string);
+}

package/lib/AppObject/AppObjectPM.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppObjectPM = void 0;
+const Entities_1 = require("../Entities");
+class AppObjectPM {
+    constructor(appObject, type) {
+        this.observerList = new Entities_1.ObserverList();
+        this.addView = (updateView) => {
+            this.observerList.add(updateView);
+            if (this._lastVM) {
+                updateView(this._lastVM);
+            }
+        };
+        this.removeView = (updateView) => {
+            this.observerList.remove(updateView);
+        };
+        this.doUpdateView = (vm) => {
+            if (this._lastVM && this.vmsAreEqual(this._lastVM, vm)) {
+                return;
+            }
+            this._lastVM = vm;
+            this.observerList.notify(vm);
+        };
+        this.type = type;
+        this.appObject = appObject;
+        appObject.addComponent(this);
+    }
+    get lastVM() {
+        return this._lastVM;
+    }
+    dispose() {
+        this.observerList.clear();
+        if (this.appObject.getComponent(this.type) === this) {
+            this.appObject.removeComponent(this.type);
+        }
+    }
+}
+exports.AppObjectPM = AppObjectPM;

package/lib/AppObject/AppObjectRepo.d.ts

@@ -0,0 +1,19 @@
+import { ObservableEntity } from "../Entities";
+import { AppObject } from "./AppObject";
+import { AppObjectComponent } from "./AppObjectComponent";
+export declare abstract class AppObjectRepo extends ObservableEntity {
+    abstract has(appObjectID: string): boolean;
+    abstract add(appObject: AppObject): void;
+    abstract remove(appObjectID: string): void;
+    abstract get(appObjectID: string): AppObject | undefined;
+    abstract getOrCreate(appObjectID: string): AppObject;
+    abstract getAll(): AppObject[];
+    abstract getAppObjectComponent<T extends AppObjectComponent>(appObjectID: string, type: string): T | undefined;
+    abstract getAllAppObjectsWithComponent(componentType: string): AppObject[];
+    abstract getAllComponents<T extends AppObjectComponent>(type: string): T[];
+    abstract addAppObjectAddedObserver: (observer: (addedEntity: AppObject) => void) => void;
+    abstract removeAppObjectAddedObserver: (observer: (addedEntity: AppObject) => void) => void;
+    abstract addAppObjectRemovedObserver: (observer: (addedEntity: AppObject) => void) => void;
+    abstract removeaddAppObjectRemovedObserver: (observer: (addedEntity: AppObject) => void) => void;
+}
+export declare function makeAppObjectRepo(): AppObjectRepo;

package/lib/AppObject/AppObjectRepo.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeAppObjectRepo = exports.AppObjectRepo = void 0;
+const Entities_1 = require("../Entities");
+const AppObject_1 = require("./AppObject");
+class AppObjectRepo extends Entities_1.ObservableEntity {
+}
+exports.AppObjectRepo = AppObjectRepo;
+function makeAppObjectRepo() {
+    return new AppObjectRepoImp();
+}
+exports.makeAppObjectRepo = makeAppObjectRepo;
+class AppObjectRepoImp extends AppObjectRepo {
+    constructor() {
+        super(...arguments);
+        this.appObjectLookup = new Map();
+        this.onAppObjectAddedObserver = new Entities_1.ObserverList();
+        this.addAppObjectAddedObserver = (observer) => {
+            this.onAppObjectAddedObserver.add(observer);
+        };
+        this.removeAppObjectAddedObserver = (observer) => {
+            this.onAppObjectAddedObserver.remove(observer);
+        };
+        this.onAppObjectRemovedObservers = new Entities_1.ObserverList();
+        this.addAppObjectRemovedObserver = (observer) => {
+            this.onAppObjectRemovedObservers.add(observer);
+        };
+        this.removeaddAppObjectRemovedObserver = (observer) => {
+            this.onAppObjectRemovedObservers.remove(observer);
+        };
+        this.has = (id) => {
+            return this.appObjectLookup.has(id);
+        };
+        this.add = (appObject) => {
+            const existing = this.appObjectLookup.get(appObject.id);
+            if (existing) {
+                existing.removeObserver(this.notify);
+            }
+            this.appObjectLookup.set(appObject.id, appObject);
+            appObject.addObserver(this.notify);
+            this.notify();
+            this.onAppObjectAddedObserver.notify(appObject);
+        };
+        this.remove = (id) => {
+            const existing = this.appObjectLookup.get(id);
+            if (!existing)
+                return;
+            this.appObjectLookup.delete(id);
+            existing.removeObserver(this.notify);
+            this.notify();
+            this.onAppObjectRemovedObservers.notify(existing);
+        };
+        this.get = (id) => {
+            return this.appObjectLookup.get(id);
+        };
+        this.getOrCreate = (id) => {
+            const existing = this.appObjectLookup.get(id);
+            if (!existing) {
+                return AppObject_1.makeAppObject(id, this);
+            }
+            else {
+                return existing;
+            }
+        };
+        this.getAll = () => {
+            return Array.from(this.appObjectLookup.values());
+        };
+    }
+    getAllAppObjectsWithComponent(componentType) {
+        const rArray = [];
+        this.appObjectLookup.forEach(appObj => {
+            if (appObj.hasComponent(componentType)) {
+                rArray.push(appObj);
+            }
+        });
+        return rArray;
+    }
+    getAllComponents(type) {
+        const rArray = [];
+        this.appObjectLookup.forEach(appObj => {
+            const aoEntity = appObj.getComponent(type);
+            if (aoEntity) {
+                rArray.push(aoEntity);
+            }
+        });
+        return rArray;
+    }
+    getAppObjectComponent(id, entityType) {
+        const ao = this.appObjectLookup.get(id);
+        if (!ao) {
+            return undefined;
+        }
+        return ao.getComponent(entityType);
+    }
+}

package/lib/AppObject/AppObjectUC.d.ts

@@ -0,0 +1,8 @@
+import { AppObject } from "./AppObject";
+import { AppObjectComponent } from "./AppObjectComponent";
+export declare class AppObjectUC implements AppObjectComponent {
+    readonly type: string;
+    readonly appObject: AppObject;
+    dispose(): void;
+    constructor(appObject: AppObject, type: string);
+}

package/lib/AppObject/AppObjectUC.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppObjectUC = void 0;
+class AppObjectUC {
+    constructor(appObject, type) {
+        this.appObject = appObject;
+        this.type = type;
+        appObject.addComponent(this);
+    }
+    dispose() {
+        if (this.appObject.getComponent(this.type) === this) {
+            this.appObject.removeComponent(this.type);
+        }
+    }
+    ;
+}
+exports.AppObjectUC = AppObjectUC;

package/lib/AppObject/IsEnabledPM.d.ts

@@ -0,0 +1,11 @@
+import { AppObject } from "./AppObject";
+import { AppObjectPM } from "./AppObjectPM";
+import { AppObjectRepo } from "./AppObjectRepo";
+export declare class IsEnabledPM extends AppObjectPM<boolean> {
+    static readonly type = "IsEnabledPM";
+    onEnabledChange: () => void;
+    dispose: () => void;
+    vmsAreEqual(a: boolean, b: boolean): boolean;
+    constructor(appObject: AppObject);
+    static getForID(appObjID: string, appObjects: AppObjectRepo): IsEnabledPM | undefined;
+}

package/lib/AppObject/IsEnabledPM.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IsEnabledPM = void 0;
+const AppObjectPM_1 = require("./AppObjectPM");
+class IsEnabledPM extends AppObjectPM_1.AppObjectPM {
+    constructor(appObject) {
+        super(appObject, IsEnabledPM.type);
+        this.onEnabledChange = () => {
+            this.doUpdateView(this.appObject.enabled);
+        };
+        this.dispose = () => {
+            this.appObject.removeObserver(this.onEnabledChange);
+        };
+        appObject.addObserver(this.onEnabledChange);
+        this.onEnabledChange();
+    }
+    vmsAreEqual(a, b) {
+        return a === b;
+    }
+    static getForID(appObjID, appObjects) {
+        const appObj = appObjects.get(appObjID);
+        if (appObj === undefined) {
+            return undefined;
+        }
+        return appObj.getComponent(IsEnabledPM.type);
+    }
+}
+exports.IsEnabledPM = IsEnabledPM;
+IsEnabledPM.type = "IsEnabledPM";

package/lib/AppObject/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./AppObject";
+export * from "./AppObjectEntity";
+export * from "./AppObjectEntityRepo";
+export * from "./AppObjectPM";
+export * from "./AppObjectRepo";
+export * from "./AppObjectUC";
+export * from "./IsEnabledPM";

package/lib/AppObject/index.js

@@ -0,0 +1,19 @@
+"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("./AppObject"), exports);
+__exportStar(require("./AppObjectEntity"), exports);
+__exportStar(require("./AppObjectEntityRepo"), exports);
+__exportStar(require("./AppObjectPM"), exports);
+__exportStar(require("./AppObjectRepo"), exports);
+__exportStar(require("./AppObjectUC"), exports);
+__exportStar(require("./IsEnabledPM"), exports);

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

@@ -0,0 +1,42 @@
+import { AppObject, AppObjectEntity } from "../../../AppObject";
+import { Quaternion, Vector3 } from "../../../ValueObjects";
+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 error(): Error | undefined;
+    set error(val: Error | undefined);
+    private _meshList;
+    get meshList(): string[];
+    set meshList(val: string[]);
+    dispose: () => void;
+    constructor(appObject: AppObject);
+}

package/lib/AppObjectComponents/ChannelModel/Entities/ChannelModel.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChannelModel = exports.ChannelModelState = void 0;
+const AppObject_1 = require("../../../AppObject");
+const Entities_1 = require("../../../Entities");
+const ValueObjects_1 = require("../../../ValueObjects");
+var ChannelModelState;
+(function (ChannelModelState) {
+    ChannelModelState["INIT"] = "Initialized";
+    ChannelModelState["LOADING"] = "Loading";
+    ChannelModelState["READY"] = "Ready";
+    ChannelModelState["ERROR"] = "Error";
+})(ChannelModelState = exports.ChannelModelState || (exports.ChannelModelState = {}));
+class ChannelModel extends AppObject_1.AppObjectEntity {
+    constructor(appObject) {
+        super(appObject, ChannelModel.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);
+        this._defaultPosition = new Entities_1.MemoizedVector3(ValueObjects_1.Vector3.Zero(), this.notifyOnChange);
+        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();
+        };
+    }
+    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 name() {
+        return this._name.val;
+    }
+    set name(name) {
+        this._name.val = name;
+    }
+    get bounds_min() {
+        return this._boundsMin.val;
+    }
+    set bounds_min(bounds_min) {
+        this._boundsMin.val = bounds_min;
+    }
+    get bounds_max() {
+        return this._boundsMax.val;
+    }
+    set bounds_max(bounds_max) {
+        this._boundsMax.val = bounds_max;
+    }
+    get defaultPosition() {
+        return this._defaultPosition.val;
+    }
+    set defaultPosition(position) {
+        this._defaultPosition.val = position;
+    }
+    get defaultRotation() {
+        return this._defaultRotation.val;
+    }
+    set defaultRotation(rotation) {
+        this._defaultRotation.val = rotation;
+    }
+    get defaultScale() {
+        return this._defaultScale.val;
+    }
+    set defaultScale(scale) {
+        this._defaultScale.val = scale;
+    }
+    get state() {
+        return this._state.val;
+    }
+    set state(val) {
+        this._state.val = val;
+    }
+    get error() {
+        return this._error;
+    }
+    set error(val) {
+        this._error = val;
+        this._state.val = ChannelModelState.ERROR;
+    }
+    get meshList() {
+        return [...this._meshList];
+    }
+    set meshList(val) {
+        this._meshList = [...val];
+        this.notifyOnChange();
+    }
+}
+exports.ChannelModel = ChannelModel;
+ChannelModel.type = "CHANNEL_MODEL";

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

@@ -0,0 +1,12 @@
+import { AppObject, AppObjectEntityRepo, AppObjectRepo } from "../../../AppObject";
+import { ChannelModel } from "./ChannelModel";
+export declare class ChannelModelRepo extends AppObjectEntityRepo<ChannelModel> {
+    static readonly type = "CHANNEL_MODEL_REPO";
+    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);
+}