@vived/app 2.50.1 → 3.0.0

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

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChannelModelRepo = void 0;
+const AppObject_1 = require("../../../AppObject");
+const Entities_1 = require("../../../Entities");
+const ChannelModel_1 = require("./ChannelModel");
+class ChannelModelRepo extends AppObject_1.AppObjectEntityRepo {
+    constructor(appObject) {
+        super(appObject, ChannelModelRepo.type);
+        this.memoizedIsLoading = new Entities_1.MemoizedBoolean(false, this.notifyOnChange);
+    }
+    static get(appObjects) {
+        const repo = appObjects.getAllComponents(ChannelModelRepo.type);
+        if (repo.length === 0) {
+            console.warn("[ChannelModelRepo] Unable to find a repo. Add one on Mount");
+            return undefined;
+        }
+        else if (repo.length > 1) {
+            console.warn("[ChannelModelRepo]Multiple Repos have been found. There should only be one. Using the first one");
+        }
+        return repo[0];
+    }
+    static addToAO(appObj) {
+        return new ChannelModelRepo(appObj);
+    }
+    get isLoadingChannelModel() {
+        return this.memoizedIsLoading.val;
+    }
+    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";

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

@@ -0,0 +1,2 @@
+export * from "./Entities/ChannelModel";
+export * from "./Entities/ChannelModelRepo";

package/lib/AppObjectComponents/ChannelModel/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/ChannelModel"), exports);
+__exportStar(require("./Entities/ChannelModelRepo"), 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,42 @@
+"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;
+            (_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";

package/lib/{UseCases/SceneObjects → AppObjectComponents/Mesh}/index.js

@@ -10,4 +10,4 @@ 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("./PeelSceneObject"), exports);
+__exportStar(require("./Entities/Mesh"), exports);

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

@@ -0,0 +1,25 @@
+import { AppObject, AppObjectEntity } from "../../../AppObject";
+import { Color } from "../../../ValueObjects";
+export declare enum OverlayColorEmums {
+    GREEN = "Green",
+    PINK = "Pink",
+    YELLOW = "Yellow",
+    RED = "Red",
+    BLUE = "Blue",
+    WHITE = "White",
+    PURPLE = "Purple",
+    BLACK = "Black",
+    ORANGE = "Orange",
+    NONE = "None"
+}
+export declare class OverlayColor extends AppObjectEntity {
+    static readonly type = "OVERLAY_COLOR";
+    static enumToColorLookup: Map<OverlayColorEmums, Color>;
+    static overlayColorEnumToColor(colorEnum: OverlayColorEmums): Color | undefined;
+    static addIfMissing(appObj: AppObject): OverlayColor;
+    static get(appObj: AppObject): OverlayColor | undefined;
+    private memoizedColor;
+    get overlayColor(): OverlayColorEmums;
+    set overlayColor(val: OverlayColorEmums);
+    constructor(appObject: AppObject);
+}

package/lib/AppObjectComponents/OverlayColor/Entities/OverlayColor.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OverlayColor = exports.OverlayColorEmums = void 0;
+const AppObject_1 = require("../../../AppObject");
+const Entities_1 = require("../../../Entities");
+const ValueObjects_1 = require("../../../ValueObjects");
+var OverlayColorEmums;
+(function (OverlayColorEmums) {
+    OverlayColorEmums["GREEN"] = "Green";
+    OverlayColorEmums["PINK"] = "Pink";
+    OverlayColorEmums["YELLOW"] = "Yellow";
+    OverlayColorEmums["RED"] = "Red";
+    OverlayColorEmums["BLUE"] = "Blue";
+    OverlayColorEmums["WHITE"] = "White";
+    OverlayColorEmums["PURPLE"] = "Purple";
+    OverlayColorEmums["BLACK"] = "Black";
+    OverlayColorEmums["ORANGE"] = "Orange";
+    OverlayColorEmums["NONE"] = "None";
+})(OverlayColorEmums = exports.OverlayColorEmums || (exports.OverlayColorEmums = {}));
+class OverlayColor extends AppObject_1.AppObjectEntity {
+    constructor(appObject) {
+        super(appObject, OverlayColor.type);
+        this.memoizedColor = new Entities_1.MemoizedString(OverlayColorEmums.NONE, this.notifyOnChange);
+    }
+    static overlayColorEnumToColor(colorEnum) {
+        return this.enumToColorLookup.get(colorEnum);
+    }
+    static addIfMissing(appObj) {
+        const existing = appObj.getComponent(this.type);
+        if (existing) {
+            return existing;
+        }
+        else {
+            return new OverlayColor(appObj);
+        }
+    }
+    static get(appObj) {
+        return appObj.getComponent(this.type);
+    }
+    get overlayColor() {
+        return this.memoizedColor.val;
+    }
+    set overlayColor(val) {
+        this.memoizedColor.val = val;
+    }
+}
+exports.OverlayColor = OverlayColor;
+OverlayColor.type = "OVERLAY_COLOR";
+OverlayColor.enumToColorLookup = new Map([
+    [OverlayColorEmums.GREEN, ValueObjects_1.Color.Hex("#008000")],
+    [OverlayColorEmums.PINK, ValueObjects_1.Color.Hex("#FFC0CB")],
+    [OverlayColorEmums.YELLOW, ValueObjects_1.Color.Hex("#FFFF00")],
+    [OverlayColorEmums.RED, ValueObjects_1.Color.Hex("#FF0000")],
+    [OverlayColorEmums.BLUE, ValueObjects_1.Color.Hex("#0000FF")],
+    [OverlayColorEmums.WHITE, ValueObjects_1.Color.Hex("#FFFFFF")],
+    [OverlayColorEmums.PURPLE, ValueObjects_1.Color.Hex("#800080")],
+    [OverlayColorEmums.BLACK, ValueObjects_1.Color.Hex("#000000")],
+    [OverlayColorEmums.ORANGE, ValueObjects_1.Color.Hex("#FFA500")]
+]);

package/lib/AppObjectComponents/OverlayColor/PresentationManagers/OverlayColorPM.d.ts

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

package/lib/AppObjectComponents/OverlayColor/PresentationManagers/OverlayColorPM.js

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

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

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

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

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

@@ -0,0 +1,44 @@
+import { AppObject, AppObjectEntity } from "../../../AppObject";
+import { EaseFn } from "../../../Entities";
+import { Matrix, Quaternion, Vector3 } from "../../../ValueObjects";
+export declare class Transform3D extends AppObjectEntity {
+    static readonly type = "TRANSFORM_3D";
+    static addIfMissing(appObj: AppObject): Transform3D;
+    static get(appObj: AppObject): Transform3D | undefined;
+    private _transformationMatrix;
+    get localMatrix(): Matrix;
+    set localMatrix(val: Matrix);
+    get worldMatrix(): Matrix;
+    get localPosition(): Vector3;
+    set localPosition(val: Vector3);
+    get worldPosition(): Vector3;
+    set worldPosition(val: Vector3);
+    get localRotation(): Quaternion;
+    set localRotation(val: Quaternion);
+    get worldRotation(): Quaternion;
+    set worldRotation(val: Quaternion);
+    get localScale(): Vector3;
+    set localScale(val: Vector3);
+    get worldScale(): Vector3;
+    set worldScale(val: Vector3);
+    private _parent?;
+    get parent(): Transform3D | undefined;
+    set parent(val: Transform3D | undefined);
+    localPointToWorld: (point: Vector3) => Vector3;
+    worldPointToLocal: (point: Vector3) => Vector3;
+    localDirectionToWorld: (point: Vector3) => Vector3;
+    worldDirectionToLocal: (point: Vector3) => Vector3;
+    private interval?;
+    private chrono;
+    private lerpDuration;
+    private lerpEase;
+    private tickInterval;
+    private lerpPos?;
+    private lerpQuat?;
+    private lerpScale?;
+    private onLerpCompletedCallback?;
+    lerp: (duration: number, ease: EaseFn, desiredPosition?: Vector3 | undefined, desiredRotation?: Quaternion | undefined, desiredScale?: Vector3 | undefined, onCompletedCallback?: (() => void) | undefined) => void;
+    private tickLerp;
+    cancelLerp: () => void;
+    constructor(appObject: AppObject);
+}