@vived/app 4.26.2 → 4.27.1

package/lib/AppObjectComponents/Dispatcher/UC/HasPreviousStateUC.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeHasPreviousStateUC = exports.HasPreviousStateUC = void 0;
+const AppObjectUC_1 = require("../../../AppObject/AppObjectUC");
+const AppDispatcher_1 = require("../Entities/AppDispatcher");
+class HasPreviousStateUC extends AppObjectUC_1.AppObjectUC {
+    constructor() {
+        super(...arguments);
+        this.requestType = "HAS_PREVIOUS_STATE";
+    }
+    static get(appObjects) {
+        const selectionEntities = appObjects.getAllComponents(HasPreviousStateUC.type);
+        if (selectionEntities.length === 0) {
+            console.warn("Unable to find a HasPreviousStateUC. Add one on Mount");
+            return undefined;
+        }
+        else if (selectionEntities.length > 1) {
+            console.warn("Multiple HasPreviousStateUC have been found. There should only be one. Using the first one");
+        }
+        return selectionEntities[0];
+    }
+}
+exports.HasPreviousStateUC = HasPreviousStateUC;
+HasPreviousStateUC.type = "HasPreviousStateUC";
+function makeHasPreviousStateUC(appObject) {
+    return new DispatchStateChangeUCImp(appObject);
+}
+exports.makeHasPreviousStateUC = makeHasPreviousStateUC;
+class DispatchStateChangeUCImp extends HasPreviousStateUC {
+    constructor(appObject) {
+        super(appObject, HasPreviousStateUC.type);
+        this.requestVersion = 1;
+        this.appDispatcher = appObject.getComponent(AppDispatcher_1.AppDispatcher.type);
+        if (!this.appDispatcher) {
+            console.warn("HasPreviousStateUC has been added to an App Object that does not have a AppDispatcher. Add a dispatcher first");
+            this.dispose();
+        }
+    }
+    doDispatch() {
+        return new Promise((resolve, reject) => {
+            const callback = (hasNextState) => {
+                resolve(hasNextState);
+            };
+            const payload = {
+                callback,
+            };
+            if (!this.appDispatcher)
+                return reject(new Error("No host handler has been registered"));
+            else {
+                this.appDispatcher.formRequestAndDispatch(this.requestType, this.requestVersion, payload);
+            }
+        });
+    }
+}

package/lib/AppObjectComponents/Dispatcher/UC/IsZSpaceAvailableUC.d.ts

@@ -0,0 +1,10 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectRepo } from "../../../AppObject/AppObjectRepo";
+import { AppObjectUC } from "../../../AppObject/AppObjectUC";
+export declare abstract class IsZSpaceAvailableUC extends AppObjectUC {
+    static readonly type = "IsZSpaceAvailableUC";
+    readonly requestType = "IS_ZSPACE_AVAILABLE";
+    abstract doDispatch(): Promise<boolean>;
+    static get(appObjects: AppObjectRepo): IsZSpaceAvailableUC | undefined;
+}
+export declare function makeIsZSpaceAvailableUC(appObject: AppObject): IsZSpaceAvailableUC;

package/lib/AppObjectComponents/Dispatcher/UC/IsZSpaceAvailableUC.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeIsZSpaceAvailableUC = exports.IsZSpaceAvailableUC = void 0;
+const AppObjectUC_1 = require("../../../AppObject/AppObjectUC");
+const AppDispatcher_1 = require("../Entities/AppDispatcher");
+class IsZSpaceAvailableUC extends AppObjectUC_1.AppObjectUC {
+    constructor() {
+        super(...arguments);
+        this.requestType = "IS_ZSPACE_AVAILABLE";
+    }
+    static get(appObjects) {
+        const selectionEntities = appObjects.getAllComponents(IsZSpaceAvailableUC.type);
+        if (selectionEntities.length === 0) {
+            console.warn("Unable to find a IsZSpaceAvailableUC. Add one on Mount");
+            return undefined;
+        }
+        else if (selectionEntities.length > 1) {
+            console.warn("Multiple IsZSpaceAvailableUC have been found. There should only be one. Using the first one");
+        }
+        return selectionEntities[0];
+    }
+}
+exports.IsZSpaceAvailableUC = IsZSpaceAvailableUC;
+IsZSpaceAvailableUC.type = "IsZSpaceAvailableUC";
+function makeIsZSpaceAvailableUC(appObject) {
+    return new DispatchStateChangeUCImp(appObject);
+}
+exports.makeIsZSpaceAvailableUC = makeIsZSpaceAvailableUC;
+class DispatchStateChangeUCImp extends IsZSpaceAvailableUC {
+    constructor(appObject) {
+        super(appObject, IsZSpaceAvailableUC.type);
+        this.requestVersion = 1;
+        this.appDispatcher = appObject.getComponent(AppDispatcher_1.AppDispatcher.type);
+        if (!this.appDispatcher) {
+            console.warn("IsZSpaceAvailableUC has been added to an App Object that does not have a AppDispatcher. Add a dispatcher first");
+            this.dispose();
+        }
+    }
+    doDispatch() {
+        return new Promise((resolve, reject) => {
+            const callback = (IsZSpaceAvailable) => {
+                resolve(IsZSpaceAvailable);
+            };
+            const payload = {
+                callback,
+            };
+            if (!this.appDispatcher)
+                return reject(new Error("No host handler has been registered"));
+            else {
+                this.appDispatcher.formRequestAndDispatch(this.requestType, this.requestVersion, payload);
+            }
+        });
+    }
+}

package/lib/AppObjectComponents/Dispatcher/index.d.ts

@@ -0,0 +1,9 @@
+export * from "./Entities/AppDispatcher";
+export * from "./Factories/makeBasicDispatcher";
+export * from "./UC/DispatchStopZSpaceUC";
+export * from "./UC/DispatchStartZSpaceUC";
+export * from "./UC/GoToNextStateUC";
+export * from "./UC/GoToPreviousStateUC";
+export * from "./UC/HasNextStateUC";
+export * from "./UC/HasPreviousStateUC";
+export * from "./UC/IsZSpaceAvailableUC";

package/lib/AppObjectComponents/Dispatcher/index.js

@@ -0,0 +1,21 @@
+"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("./Entities/AppDispatcher"), exports);
+__exportStar(require("./Factories/makeBasicDispatcher"), exports);
+__exportStar(require("./UC/DispatchStopZSpaceUC"), exports);
+__exportStar(require("./UC/DispatchStartZSpaceUC"), exports);
+__exportStar(require("./UC/GoToNextStateUC"), exports);
+__exportStar(require("./UC/GoToPreviousStateUC"), exports);
+__exportStar(require("./UC/HasNextStateUC"), exports);
+__exportStar(require("./UC/HasPreviousStateUC"), exports);
+__exportStar(require("./UC/IsZSpaceAvailableUC"), exports);

package/lib/AppObjectComponents/Enablement/Entities/EnablablementEntity.d.ts

@@ -0,0 +1,16 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectEntity } from "../../../AppObject/AppObjectEntity";
+export declare abstract class EnablablementEntity extends AppObjectEntity {
+    static readonly type = "EnablablementEntity";
+    abstract get enabled(): boolean;
+    abstract set enabled(enabled: boolean);
+    static get(appObj: AppObject): EnablablementEntity | undefined;
+}
+export declare function makeEnablableEntity(appObject: AppObject): EnablableImp;
+declare class EnablableImp extends EnablablementEntity {
+    private memoizedEnabled;
+    get enabled(): boolean;
+    set enabled(enabled: boolean);
+    constructor(appObject: AppObject);
+}
+export {};

package/lib/AppObjectComponents/Enablement/Entities/EnablablementEntity.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeEnablableEntity = exports.EnablablementEntity = void 0;
+const AppObjectEntity_1 = require("../../../AppObject/AppObjectEntity");
+const Entities_1 = require("../../../Entities");
+class EnablablementEntity extends AppObjectEntity_1.AppObjectEntity {
+    static get(appObj) {
+        return appObj.getComponent(this.type);
+    }
+}
+exports.EnablablementEntity = EnablablementEntity;
+EnablablementEntity.type = "EnablablementEntity";
+function makeEnablableEntity(appObject) {
+    return new EnablableImp(appObject);
+}
+exports.makeEnablableEntity = makeEnablableEntity;
+class EnablableImp extends EnablablementEntity {
+    constructor(appObject) {
+        super(appObject, EnablablementEntity.type);
+        this.memoizedEnabled = new Entities_1.MemoizedBoolean(true, this.notifyOnChange);
+    }
+    get enabled() {
+        return this.memoizedEnabled.val;
+    }
+    set enabled(enabled) {
+        this.memoizedEnabled.val = enabled;
+    }
+}

package/lib/AppObjectComponents/Enablement/PM/EnablableStatePM.d.ts

@@ -0,0 +1,14 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectPM } from "../../../AppObject/AppObjectPM";
+export interface EnablableStateVM {
+    enabled: boolean;
+}
+export declare class EnablableStatePM extends AppObjectPM<EnablableStateVM> {
+    static readonly type = "EnablableStatePM";
+    private enablable?;
+    onEnablableStateChange: () => void;
+    vmsAreEqual(a: EnablableStateVM, b: EnablableStateVM): boolean;
+    dispose: () => void;
+    constructor(appObject: AppObject);
+    static defaultVM: EnablableStateVM;
+}

package/lib/AppObjectComponents/Enablement/PM/EnablableStatePM.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnablableStatePM = void 0;
+const AppObjectPM_1 = require("../../../AppObject/AppObjectPM");
+const EnablablementEntity_1 = require("../Entities/EnablablementEntity");
+class EnablableStatePM extends AppObjectPM_1.AppObjectPM {
+    constructor(appObject) {
+        super(appObject, EnablableStatePM.type);
+        this.onEnablableStateChange = () => {
+            if (!this.enablable)
+                return;
+            const vm = {
+                enabled: this.enablable.enabled
+            };
+            this.doUpdateView(vm);
+        };
+        this.dispose = () => {
+            var _a, _b;
+            super.dispose();
+            (_a = this.enablable) === null || _a === void 0 ? void 0 : _a.removeChangeObserver(this.onEnablableStateChange);
+            (_b = this.enablable) === null || _b === void 0 ? void 0 : _b.removeChangeObserver(this.dispose);
+        };
+        this.enablable = EnablablementEntity_1.EnablablementEntity.get(appObject);
+        if (!this.enablable) {
+            console.warn("[EnablableStatePM] App Object does not have a Enablable Entity");
+            this.dispose();
+            return;
+        }
+        this.enablable.addChangeObserver(this.onEnablableStateChange);
+        this.enablable.addOnDisposeObserver(this.dispose);
+        this.onEnablableStateChange();
+    }
+    vmsAreEqual(a, b) {
+        return a.enabled === b.enabled;
+    }
+}
+exports.EnablableStatePM = EnablableStatePM;
+EnablableStatePM.type = "EnablableStatePM";
+EnablableStatePM.defaultVM = {
+    enabled: false
+};

package/lib/AppObjectComponents/Enablement/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./Entities/EnablablementEntity";
+export * from "./PM/EnablableStatePM";

package/lib/AppObjectComponents/Enablement/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("./Entities/EnablablementEntity"), exports);
+__exportStar(require("./PM/EnablableStatePM"), exports);

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

@@ -0,0 +1,10 @@
+import { AppObject, AppObjectEntity } from "../../../AppObject";
+export declare class Hideable extends AppObjectEntity {
+    static readonly type = "HIDEABLE";
+    static addIfMissing(appObj: AppObject): Hideable;
+    static get(appObj: AppObject): Hideable | undefined;
+    private memoizedIsHidden;
+    get isHidden(): boolean;
+    set isHidden(val: boolean);
+    constructor(appObject: AppObject);
+}

package/lib/AppObjectComponents/Hideable/Entities/Hideable.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Hideable = void 0;
+const AppObject_1 = require("../../../AppObject");
+const Entities_1 = require("../../../Entities");
+class Hideable extends AppObject_1.AppObjectEntity {
+    constructor(appObject) {
+        super(appObject, Hideable.type);
+        this.memoizedIsHidden = new Entities_1.MemoizedBoolean(false, this.notifyOnChange);
+    }
+    static addIfMissing(appObj) {
+        const existing = appObj.getComponent(this.type);
+        if (existing) {
+            return existing;
+        }
+        else {
+            return new Hideable(appObj);
+        }
+    }
+    static get(appObj) {
+        return appObj.getComponent(this.type);
+    }
+    get isHidden() {
+        return this.memoizedIsHidden.val;
+    }
+    set isHidden(val) {
+        this.memoizedIsHidden.val = val;
+    }
+}
+exports.Hideable = Hideable;
+Hideable.type = "HIDEABLE";

package/lib/AppObjectComponents/Hideable/PresentationManagers/IsHiddenPM.d.ts

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

package/lib/AppObjectComponents/Hideable/PresentationManagers/IsHiddenPM.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IsHiddenPM = void 0;
+const AppObjectPM_1 = require("../../../AppObject/AppObjectPM");
+const Hideable_1 = require("../Entities/Hideable");
+class IsHiddenPM extends AppObjectPM_1.AppObjectPM {
+    constructor(appObject) {
+        super(appObject, IsHiddenPM.type);
+        this.onIsHiddenChange = () => {
+            if (!this.hideable)
+                return;
+            this.doUpdateView(this.hideable.isHidden);
+        };
+        this.dispose = () => {
+            var _a, _b;
+            super.dispose();
+            (_a = this.hideable) === null || _a === void 0 ? void 0 : _a.removeChangeObserver(this.onIsHiddenChange);
+            (_b = this.hideable) === null || _b === void 0 ? void 0 : _b.removeOnDisposeObserver(this.dispose);
+        };
+        this.hideable = Hideable_1.Hideable.get(appObject);
+        if (!this.hideable) {
+            console.warn("[CanBeStuckPM] Unable to find Transform3D Entity");
+            return;
+        }
+        else {
+            this.hideable.addChangeObserver(this.onIsHiddenChange);
+            this.hideable.addOnDisposeObserver(this.dispose);
+            this.onIsHiddenChange();
+        }
+    }
+    vmsAreEqual(a, b) {
+        return a === b;
+    }
+    static getForID(appObjID, appObjects) {
+        const appObj = appObjects.get(appObjID);
+        if (appObj === undefined) {
+            return undefined;
+        }
+        return appObj.getComponent(IsHiddenPM.type);
+    }
+}
+exports.IsHiddenPM = IsHiddenPM;
+IsHiddenPM.type = "IsHiddenPM";

package/lib/AppObjectComponents/Hideable/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./Entities/Hideable";
+export * from "./PresentationManagers/IsHiddenPM";

package/lib/AppObjectComponents/Hideable/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("./Entities/Hideable"), exports);
+__exportStar(require("./PresentationManagers/IsHiddenPM"), exports);

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

@@ -0,0 +1,17 @@
+import { AppObject, AppObjectEntity } from "../../../AppObject";
+export declare class Label extends AppObjectEntity {
+    static maxLabelLength: number;
+    static readonly type = "LABEL";
+    static addIfMissing(appObj: AppObject): Label;
+    static get(appObj: AppObject): Label | undefined;
+    private memoizedDefault;
+    get default(): string;
+    set default(val: string);
+    private memoizedCustom;
+    get custom(): string;
+    set custom(val: string);
+    get display(): string;
+    get hasCustomLabel(): boolean;
+    get labelValidationMessage(): string | null;
+    constructor(appObject: AppObject);
+}

package/lib/AppObjectComponents/Label/Entities/Label.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Label = void 0;
+const AppObject_1 = require("../../../AppObject");
+const Entities_1 = require("../../../Entities");
+class Label extends AppObject_1.AppObjectEntity {
+    constructor(appObject) {
+        super(appObject, Label.type);
+        this.memoizedDefault = new Entities_1.MemoizedString("", this.notifyOnChange);
+        this.memoizedCustom = new Entities_1.MemoizedString("", this.notifyOnChange);
+    }
+    static addIfMissing(appObj) {
+        const existing = appObj.getComponent(this.type);
+        if (existing) {
+            return existing;
+        }
+        else {
+            return new Label(appObj);
+        }
+    }
+    static get(appObj) {
+        return appObj.getComponent(this.type);
+    }
+    get default() {
+        return this.memoizedDefault.val;
+    }
+    set default(val) {
+        this.memoizedDefault.val = val;
+    }
+    get custom() {
+        return this.memoizedCustom.val;
+    }
+    set custom(val) {
+        this.memoizedCustom.val = val;
+    }
+    get display() {
+        if (this.memoizedCustom.val) {
+            return this.memoizedCustom.val;
+        }
+        else {
+            return this.memoizedDefault.val;
+        }
+    }
+    get hasCustomLabel() {
+        return this.memoizedCustom.val ? true : false;
+    }
+    get labelValidationMessage() {
+        if (this.memoizedCustom.val.length > Label.maxLabelLength) {
+            return `Label is limited to ${Label.maxLabelLength} characters.`;
+        }
+        else {
+            return null;
+        }
+    }
+}
+exports.Label = Label;
+Label.maxLabelLength = 40;
+Label.type = "LABEL";

package/lib/AppObjectComponents/Label/PresentationManagers/LabelPM.d.ts

@@ -0,0 +1,19 @@
+import { AppObject, AppObjectPM } from "../../../AppObject";
+import { AppObjectRepo } from "../../../AppObject/AppObjectRepo";
+export interface LabelVM {
+    customLabel: string;
+    defaultLabel: string;
+    labelValidation: string | null;
+    hasCustomLabel: boolean;
+    displayLabel: string;
+}
+export declare class LabelPM extends AppObjectPM<LabelVM> {
+    static readonly type = "LabelPM";
+    private label?;
+    vmsAreEqual(a: LabelVM, b: LabelVM): boolean;
+    onLabelChange: () => void;
+    dispose: () => void;
+    constructor(appObject: AppObject);
+    static defaultVM: LabelVM;
+    static getForID(appObjID: string, appObjects: AppObjectRepo): LabelPM | undefined;
+}

package/lib/AppObjectComponents/Label/PresentationManagers/LabelPM.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LabelPM = void 0;
+const AppObject_1 = require("../../../AppObject");
+const Label_1 = require("../Entities/Label");
+class LabelPM extends AppObject_1.AppObjectPM {
+    constructor(appObject) {
+        super(appObject, LabelPM.type);
+        this.onLabelChange = () => {
+            if (!this.label)
+                return;
+            const { custom: customLabel, display: displayLabel, hasCustomLabel, labelValidationMessage: labelValidation, default: defaultLabel } = this.label;
+            const vm = {
+                customLabel,
+                displayLabel,
+                hasCustomLabel,
+                labelValidation,
+                defaultLabel
+            };
+            this.doUpdateView(vm);
+        };
+        this.dispose = () => {
+            var _a, _b;
+            super.dispose();
+            (_a = this.label) === null || _a === void 0 ? void 0 : _a.removeChangeObserver(this.onLabelChange);
+            (_b = this.label) === null || _b === void 0 ? void 0 : _b.removeOnDisposeObserver(this.dispose);
+        };
+        this.label = Label_1.Label.get(appObject);
+        if (this.label) {
+            this.label.addChangeObserver(this.onLabelChange);
+            this.label.addOnDisposeObserver(this.dispose);
+            this.onLabelChange();
+        }
+        else {
+            console.warn("[LabelPM] App Object does not have a Label Entity");
+        }
+    }
+    vmsAreEqual(a, b) {
+        if (a.customLabel !== b.customLabel)
+            return false;
+        if (a.defaultLabel !== b.defaultLabel)
+            return false;
+        // Note the rest of the VM is derived from these two values
+        return true;
+    }
+    static getForID(appObjID, appObjects) {
+        const appObj = appObjects.get(appObjID);
+        if (appObj === undefined) {
+            return undefined;
+        }
+        return appObj.getComponent(LabelPM.type);
+    }
+}
+exports.LabelPM = LabelPM;
+LabelPM.type = "LabelPM";
+LabelPM.defaultVM = {
+    customLabel: "",
+    defaultLabel: "",
+    displayLabel: "",
+    hasCustomLabel: false,
+    labelValidation: null
+};

package/lib/AppObjectComponents/Label/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./Entities/Label";
+export * from "./PresentationManagers/LabelPM";

package/lib/AppObjectComponents/Label/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("./Entities/Label"), exports);
+__exportStar(require("./PresentationManagers/LabelPM"), exports);

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

@@ -0,0 +1,21 @@
+import { AppObject, AppObjectEntity } from "../../../AppObject";
+import { Quaternion, Vector3 } from "../../../ValueObjects";
+export interface SubMesh {
+    meshPath: string;
+    neutralPosition: Vector3;
+    neutralRotation: Quaternion;
+    neutralScale: Vector3;
+    meshObject?: unknown;
+}
+export declare class Mesh extends AppObjectEntity {
+    static readonly type = "MESH";
+    static addIfMissing(appObj: AppObject): Mesh;
+    static get(appObj: AppObject): Mesh | undefined;
+    private subMeshLookup;
+    get subMeshes(): SubMesh[];
+    addSubMesh(subMesh: SubMesh): void;
+    getSubMeshForPath(path: string): SubMesh | undefined;
+    hasMeshPath: (path: string) => boolean;
+    removeMeshPath(path: string): void;
+    constructor(appObject: AppObject);
+}

package/lib/AppObjectComponents/Mesh/Entities/Mesh.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Mesh = void 0;
+const AppObject_1 = require("../../../AppObject");
+class Mesh extends AppObject_1.AppObjectEntity {
+    constructor(appObject) {
+        super(appObject, Mesh.type);
+        this.subMeshLookup = new Map();
+        this.hasMeshPath = (path) => {
+            return this.subMeshLookup.has(path);
+        };
+    }
+    static addIfMissing(appObj) {
+        const existing = appObj.getComponent(this.type);
+        if (existing) {
+            return existing;
+        }
+        else {
+            return new Mesh(appObj);
+        }
+    }
+    static get(appObj) {
+        return appObj.getComponent(this.type);
+    }
+    get subMeshes() {
+        return Array.from(this.subMeshLookup.values());
+    }
+    addSubMesh(subMesh) {
+        if (this.subMeshLookup.has(subMesh.meshPath))
+            return;
+        this.subMeshLookup.set(subMesh.meshPath, subMesh);
+        this.notifyOnChange();
+    }
+    getSubMeshForPath(path) {
+        return this.subMeshLookup.get(path);
+    }
+    removeMeshPath(path) {
+        if (!this.subMeshLookup.has(path))
+            return;
+        this.subMeshLookup.delete(path);
+        this.notifyOnChange();
+    }
+}
+exports.Mesh = Mesh;
+Mesh.type = "MESH";

package/lib/AppObjectComponents/Mesh/index.d.ts

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