@vived/app 3.2.1 → 3.3.1

package/lib/AppObjectComponents/Dispatcher/Entities/AppDispatcher.d.ts

@@ -0,0 +1,16 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectEntity } from "../../../AppObject/AppObjectEntity";
+import { AppObjectRepo } from "../../../AppObject/AppObjectRepo";
+export declare type Handler = (request: Request) => void;
+export interface Request {
+    type: string;
+    version: number;
+    payload?: unknown;
+}
+export declare abstract class AppDispatcher extends AppObjectEntity {
+    static readonly type = "APP_DISPATCHER";
+    abstract dispatch: (request: Request) => void;
+    abstract formRequestAndDispatch: (type: string, version: number, payload?: object | undefined) => void;
+    static get(appObjects: AppObjectRepo): AppDispatcher | undefined;
+}
+export declare function makeAppDispatcher(appObject: AppObject, hostHandler: Handler): AppDispatcher;

package/lib/AppObjectComponents/Dispatcher/Entities/AppDispatcher.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeAppDispatcher = exports.AppDispatcher = void 0;
+const AppObjectEntity_1 = require("../../../AppObject/AppObjectEntity");
+class AppDispatcher extends AppObjectEntity_1.AppObjectEntity {
+    static get(appObjects) {
+        const selectionEntities = appObjects.getAllComponents(AppDispatcher.type);
+        if (selectionEntities.length === 0) {
+            console.warn("Unable to find a App Dispatcher. Add one on Mount");
+            return undefined;
+        }
+        else if (selectionEntities.length > 1) {
+            console.warn("Multiple App Dispatcher have been found. There should only be one. Using the first one");
+        }
+        return selectionEntities[0];
+    }
+}
+exports.AppDispatcher = AppDispatcher;
+AppDispatcher.type = "APP_DISPATCHER";
+function makeAppDispatcher(appObject, hostHandler) {
+    return new AppDispatcherImp(appObject, hostHandler);
+}
+exports.makeAppDispatcher = makeAppDispatcher;
+class AppDispatcherImp extends AppDispatcher {
+    constructor(appObject, hostHandler) {
+        super(appObject, AppDispatcher.type);
+        this.hostHandler = hostHandler;
+        this.dispatch = (request) => {
+            this.hostHandler(request);
+        };
+        this.formRequestAndDispatch = (type, version, payload) => {
+            const request = {
+                type,
+                version,
+                payload
+            };
+            this.hostHandler(request);
+        };
+    }
+}

package/lib/AppObjectComponents/Dispatcher/Factories/makeBasicDispatcher.d.ts

@@ -0,0 +1,4 @@
+import { AppObjectRepo } from "../../../AppObject/AppObjectRepo";
+import { Handler } from "../Entities/AppDispatcher";
+export declare const APP_DISPATCHER_ID = "AppDispatcher";
+export declare function makeBasicDispatcher(appObjects: AppObjectRepo, hostHandler: Handler): void;

package/lib/AppObjectComponents/Dispatcher/Factories/makeBasicDispatcher.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeBasicDispatcher = exports.APP_DISPATCHER_ID = void 0;
+const AppDispatcher_1 = require("../Entities/AppDispatcher");
+const DispatchStopZSpaceUC_1 = require("../UC/DispatchStopZSpaceUC");
+exports.APP_DISPATCHER_ID = "AppDispatcher";
+function makeBasicDispatcher(appObjects, hostHandler) {
+    const dispatcherAO = appObjects.getOrCreate(exports.APP_DISPATCHER_ID);
+    AppDispatcher_1.makeAppDispatcher(dispatcherAO, hostHandler);
+    DispatchStopZSpaceUC_1.makeDispatchStopZSpaceUC(dispatcherAO);
+}
+exports.makeBasicDispatcher = makeBasicDispatcher;

package/lib/AppObjectComponents/Dispatcher/UC/DispatchStopZSpaceUC.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 DispatchStopZSpaceUC extends AppObjectUC {
+    static readonly type = "DispatchStopZSpaceUC";
+    readonly requestType = "STOP_ZSPACE";
+    abstract doDispatch(): void;
+    static get(appObjects: AppObjectRepo): DispatchStopZSpaceUC | undefined;
+}
+export declare function makeDispatchStopZSpaceUC(appObject: AppObject): DispatchStopZSpaceUC;

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

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

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

@@ -0,0 +1,3 @@
+export * from "./Entities/AppDispatcher";
+export * from "./Factories/makeBasicDispatcher";
+export * from "./UC/DispatchStopZSpaceUC";

package/lib/AppObjectComponents/Dispatcher/index.js

@@ -0,0 +1,15 @@
+"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);

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

@@ -37,6 +37,7 @@ export declare class Transform3D extends AppObjectEntity {
     private lerpQuat?;
     private lerpScale?;
     private onLerpCompletedCallback?;
+    private previousTime;
     lerp: (duration: number, ease: EaseFn, desiredPosition?: Vector3 | undefined, desiredRotation?: Quaternion | undefined, desiredScale?: Vector3 | undefined, onCompletedCallback?: (() => void) | undefined) => void;
     private tickLerp;
     cancelLerp: () => void;

package/lib/AppObjectComponents/Transform3D/Entities/Transform3D.js

@@ -27,6 +27,7 @@ class Transform3D extends AppObject_1.AppObjectEntity {
         this.lerpDuration = 1;
         this.lerpEase = (p) => p;
         this.tickInterval = 10;
+        this.previousTime = 0;
         this.lerp = (duration, ease, desiredPosition, desiredRotation, desiredScale, onCompletedCallback) => {
             this.cancelLerp();
             this.chrono = 0;
@@ -55,12 +56,16 @@ class Transform3D extends AppObject_1.AppObjectEntity {
                 this.lerpScale = undefined;
             }
             this.onLerpCompletedCallback = onCompletedCallback;
+            this.previousTime = Date.now();
             this.interval = setInterval(() => {
                 this.tickLerp();
             }, this.tickInterval);
         };
         this.tickLerp = () => {
-            this.chrono = this.chrono + this.tickInterval;
+            const currentTime = Date.now();
+            const timeDiff = currentTime - this.previousTime;
+            this.previousTime = currentTime;
+            this.chrono = this.chrono + timeDiff;
             let nomralizedTime = this.chrono / this.lerpDuration;
             if (nomralizedTime > 1) {
                 nomralizedTime = 1;

package/lib/Entities/AppDispatcher.d.ts

@@ -58,7 +58,6 @@ export declare abstract class AppDispatcher {
     abstract getAssetsForOwner: (ownerID: string) => Promise<AssetMetaDTO[]>;
     abstract isAssetFetched: (data: IsAssetFetchedDTO) => void;
     abstract submitNewActivityAsset: (file: File) => Promise<string>;
-    abstract stopZSpace: () => void;
     abstract showAlert: (data: ShowAlertDTO) => void;
     abstract showConfirm: (data: ShowConfirmDTO) => void;
     abstract showMarkDownEditor: (data: ShowMarkDownEditorDTO) => void;

package/lib/Entities/AppDispatcher.js

@@ -268,9 +268,6 @@ class AppDistpatcherImp extends AppDispatcher {
         this.goToNextState = () => {
             this.formRequestAndDispatch("GO_TO_NEXT_STATE", 1);
         };
-        this.stopZSpace = () => {
-            this.formRequestAndDispatch("STOP_ZSPACE", 1);
-        };
         this.hasNextState = () => {
             return new Promise((resolve, reject) => {
                 const callback = (hasNextState) => {

package/lib/Entities/FocusCamera.d.ts

@@ -0,0 +1,70 @@
+import { Vector3 } from "../ValueObjects";
+export declare type OnFocusCameraChange = () => void;
+export interface FocusCameraLerper {
+    cancelLerp: () => void;
+}
+export interface FocusCameraData {
+    defaultAlpha?: number;
+    defaultBeta?: number;
+    defaultRadius?: number;
+    defaultTarget?: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    nearClip?: number;
+    farClip?: number;
+    alphaLimit?: {
+        min: number;
+        max: number;
+    };
+    betaLimit?: {
+        min: number;
+        max: number;
+    };
+    radiusLimit?: {
+        min: number;
+        max: number;
+    };
+    targetLimit?: {
+        min: {
+            x: number;
+            y: number;
+            z: number;
+        };
+        max: {
+            x: number;
+            y: number;
+            z: number;
+        };
+    };
+}
+export interface FocusCamera {
+    alpha: number;
+    beta: number;
+    radius: number;
+    target: Vector3;
+    direction: Vector3;
+    cameraPosition: Vector3;
+    nearClip: number;
+    farClip: number;
+    defaultAlpha: number;
+    defaultBeta: number;
+    defaultRadius: number;
+    defaultTarget: Vector3;
+    setAlphaLimits: (min: number, max: number) => void;
+    clearAlphaLimits: () => void;
+    setBetaLimits: (min: number, max: number) => void;
+    clearBetaLimits: () => void;
+    setRadiusLimits: (min: number, max: number) => void;
+    clearRadiusLimits: () => void;
+    setTargetLimits: (min: Vector3, max: Vector3) => void;
+    clearTargetLimits: () => void;
+    registerLerp: (lerper: FocusCameraLerper) => void;
+    lerpCompleted: () => void;
+    cancelLerp: () => void;
+    applyData: (data: FocusCameraData) => void;
+    addObserver: (observer: OnFocusCameraChange) => void;
+    removeObserver: (observer: OnFocusCameraChange) => void;
+}
+export declare function makeFocusCamera(): FocusCamera;

package/lib/Entities/FocusCamera.js

@@ -0,0 +1,272 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeFocusCamera = void 0;
+const _1 = require(".");
+const ValueObjects_1 = require("../ValueObjects");
+function makeFocusCamera() {
+    return new FocusCameraImp();
+}
+exports.makeFocusCamera = makeFocusCamera;
+class FocusCameraImp {
+    constructor() {
+        this.farClip = 100;
+        this.nearClip = 0.01;
+        this.defaultAlpha = 0;
+        this.defaultBeta = 30;
+        this.defaultRadius = 8;
+        this.defaultTarget = ValueObjects_1.Vector3.Zero();
+        this.limitRadius = false;
+        this.minRadius = 0;
+        this.maxRadius = 0;
+        this.limitAlpha = false;
+        this.minAlpha = 0;
+        this.maxAlpha = 0;
+        this.limitBeta = false;
+        this.minBeta = 0;
+        this.maxBeta = 0;
+        this.limitTarget = false;
+        this.maxTargetPosition = ValueObjects_1.Vector3.Zero();
+        this.minTargetPosition = ValueObjects_1.Vector3.Zero();
+        this.observers = new _1.ObserverList();
+        this.memoizedAlpha = new _1.MemoizedNumber(0, this.observers.notify);
+        this.memoizedBeta = new _1.MemoizedNumber(0, this.observers.notify);
+        this.memoizedRadius = new _1.MemoizedNumber(1, this.observers.notify);
+        this.memoizedTarget = new _1.MemoizedVector3(ValueObjects_1.Vector3.Zero(), this.observers.notify);
+        this.setRadiusLimits = (min, max) => {
+            let minToUse = min;
+            let maxToUse = max;
+            if (min < 0) {
+                console.warn("[Orbit Camera Entity] Mininum Radius must be greater >= 0, forcing to 0");
+                minToUse = 0;
+            }
+            if (max < minToUse) {
+                console.warn(`[Orbit Camera] Max radius must be >= min radius. Forcing to ${minToUse}`);
+                maxToUse = minToUse;
+            }
+            this.maxRadius = maxToUse;
+            this.minRadius = minToUse;
+            this.limitRadius = true;
+            this.radius = this.radius;
+        };
+        this.clearRadiusLimits = () => {
+            this.maxRadius = 0;
+            this.minRadius = 0;
+            this.limitRadius = false;
+        };
+        this.setAlphaLimits = (min, max) => {
+            let minToUse = min;
+            let maxToUse = max;
+            if (min < -180) {
+                minToUse = -180;
+                console.warn("[Orbit Camera] Min alpha must be >= -180. Forcing to -180");
+            }
+            if (max > 180) {
+                maxToUse = 180;
+                console.warn("[Orbit Camera] Max alpha must be <= 180. Forcing to 180");
+            }
+            if (minToUse > maxToUse) {
+                const absMin = Math.abs(minToUse);
+                const absMax = Math.abs(maxToUse);
+                const closestToZero = absMin < absMax ? minToUse : maxToUse;
+                minToUse = closestToZero;
+                maxToUse = closestToZero;
+                console.warn(`[Orbit Camera] Max alpha must be <= Min Alpha. Forcing to ${closestToZero}`);
+            }
+            this.maxAlpha = maxToUse;
+            this.minAlpha = minToUse;
+            this.limitAlpha = true;
+            this.alpha = this.alpha;
+        };
+        this.clearAlphaLimits = () => {
+            this.maxAlpha = 0;
+            this.minAlpha = 0;
+            this.limitAlpha = false;
+        };
+        this.setBetaLimits = (min, max) => {
+            let minToUse = min;
+            let maxToUse = max;
+            if (min < -180) {
+                minToUse = -180;
+                console.warn("[Orbit Camera] Min beta must be >= -180. Forcing to -180");
+            }
+            if (max > 180) {
+                maxToUse = 180;
+                console.warn("[Orbit Camera] Max beta must be <= 180. Forcing to 180");
+            }
+            if (minToUse > maxToUse) {
+                const absMin = Math.abs(minToUse);
+                const absMax = Math.abs(maxToUse);
+                const closestToZero = absMin < absMax ? minToUse : maxToUse;
+                minToUse = closestToZero;
+                maxToUse = closestToZero;
+                console.warn(`[Orbit Camera] Max beta must be <= Min beta. Forcing to ${closestToZero}`);
+            }
+            this.maxBeta = maxToUse;
+            this.minBeta = minToUse;
+            this.limitBeta = true;
+            this.beta = this.beta;
+        };
+        this.clearBetaLimits = () => {
+            this.maxBeta = 0;
+            this.minBeta = 0;
+            this.limitBeta = false;
+        };
+        this.setTargetLimits = (min, max) => {
+            const minArray = min.array;
+            const maxArray = max.array;
+            for (let i = 0; i < 3; i++) {
+                if (minArray[i] > maxArray[i]) {
+                    console.warn("[Orbit Camera] Target limit min's components must all be <= the max. Limits not set");
+                    return;
+                }
+            }
+            this.maxTargetPosition = max;
+            this.minTargetPosition = min;
+            this.limitTarget = true;
+            this.target = this.target;
+        };
+        this.clearTargetLimits = () => {
+            this.maxTargetPosition = ValueObjects_1.Vector3.Zero();
+            this.minTargetPosition = ValueObjects_1.Vector3.Zero();
+            this.limitTarget = false;
+        };
+        this.registerLerp = (lerper) => {
+            if (this.currentLerp) {
+                this.currentLerp.cancelLerp();
+            }
+            this.currentLerp = lerper;
+        };
+        this.lerpCompleted = () => {
+            this.currentLerp = undefined;
+        };
+        this.cancelLerp = () => {
+            var _a;
+            (_a = this.currentLerp) === null || _a === void 0 ? void 0 : _a.cancelLerp();
+            this.currentLerp = undefined;
+        };
+        this.applyData = (data) => {
+            if (data.defaultAlpha !== undefined) {
+                this.defaultAlpha = data.defaultAlpha;
+            }
+            if (data.defaultBeta !== undefined) {
+                this.defaultBeta = data.defaultBeta;
+            }
+            if (data.defaultRadius !== undefined) {
+                this.defaultRadius = data.defaultRadius;
+            }
+            if (data.defaultTarget !== undefined) {
+                const { x, y, z } = data.defaultTarget;
+                this.defaultTarget = new ValueObjects_1.Vector3(x, y, z);
+            }
+            if (data.nearClip !== undefined) {
+                this.nearClip = data.nearClip;
+            }
+            if (data.farClip !== undefined) {
+                this.farClip = data.farClip;
+            }
+            if (data.alphaLimit !== undefined) {
+                this.setAlphaLimits(data.alphaLimit.min, data.alphaLimit.max);
+            }
+            if (data.betaLimit !== undefined) {
+                this.setBetaLimits(data.betaLimit.min, data.betaLimit.max);
+            }
+            if (data.radiusLimit !== undefined) {
+                this.setRadiusLimits(data.radiusLimit.min, data.radiusLimit.max);
+            }
+            if (data.targetLimit !== undefined) {
+                const { max, min } = data.targetLimit;
+                this.setTargetLimits(new ValueObjects_1.Vector3(min.x, min.y, min.z), new ValueObjects_1.Vector3(max.x, max.y, max.z));
+            }
+        };
+        this.addObserver = (observer) => {
+            this.observers.add(observer);
+        };
+        this.removeObserver = (observer) => {
+            this.observers.remove(observer);
+        };
+    }
+    get alpha() {
+        return this.memoizedAlpha.val;
+    }
+    set alpha(val) {
+        let valToUse = val;
+        if (this.limitAlpha) {
+            valToUse = Math.min(valToUse, this.maxAlpha);
+            valToUse = Math.max(valToUse, this.minAlpha);
+        }
+        else {
+            valToUse = this.clampAngle(val);
+        }
+        this.memoizedAlpha.val = valToUse;
+    }
+    get beta() {
+        return this.memoizedBeta.val;
+    }
+    set beta(val) {
+        let valToUse = val;
+        if (this.limitBeta) {
+            valToUse = Math.min(valToUse, this.maxBeta);
+            valToUse = Math.max(valToUse, this.minBeta);
+        }
+        else {
+            valToUse = this.clampAngle(val);
+        }
+        this.memoizedBeta.val = valToUse;
+    }
+    get radius() {
+        return this.memoizedRadius.val;
+    }
+    set radius(val) {
+        let clampedVal = Math.max(val, 0);
+        if (this.limitRadius) {
+            clampedVal = Math.min(clampedVal, this.maxRadius);
+            clampedVal = Math.max(clampedVal, this.minRadius);
+        }
+        this.memoizedRadius.val = clampedVal;
+    }
+    get target() {
+        return this.memoizedTarget.val;
+    }
+    set target(val) {
+        const targetVals = val.array;
+        if (this.limitTarget) {
+            const maxVals = this.maxTargetPosition.array;
+            const minVals = this.minTargetPosition.array;
+            for (let i = 0; i < 3; i++) {
+                let v = targetVals[i];
+                v = Math.min(v, maxVals[i]);
+                v = Math.max(v, minVals[i]);
+                targetVals[i] = v;
+            }
+        }
+        this.memoizedTarget.val = ValueObjects_1.Vector3.FromArray(targetVals);
+    }
+    get direction() {
+        const yLength = -Math.sin(this.degToRad(this.beta));
+        const horizontalLenght = Math.cos(this.degToRad(this.beta));
+        const alphaRadians = this.degToRad(this.alpha);
+        const xLength = horizontalLenght * Math.sin(alphaRadians);
+        const zLength = horizontalLenght * Math.cos(alphaRadians);
+        return new ValueObjects_1.Vector3(xLength, yLength, zLength);
+    }
+    get cameraPosition() {
+        const localOffset = ValueObjects_1.Vector3.NewVectorOfLength(this.direction, -this.radius);
+        return ValueObjects_1.Vector3.Add(this.target, localOffset);
+    }
+    degToRad(degrees) {
+        return (degrees * Math.PI) / 180;
+    }
+    clampAngle(angle) {
+        const isNegative = angle < 0 ? true : false;
+        const absAngle = Math.abs(angle);
+        const revolutions = Math.floor(absAngle / 360);
+        let angleWithoutRevolutions = absAngle - revolutions * 360;
+        if (angleWithoutRevolutions > 180) {
+            angleWithoutRevolutions = angleWithoutRevolutions - 360;
+        }
+        if (isNegative) {
+            angleWithoutRevolutions *= -1;
+        }
+        return angleWithoutRevolutions;
+    }
+}

package/lib/Entities/MemoizedBoolean.d.ts

@@ -0,0 +1,8 @@
+export declare class MemoizedBoolean {
+    private _val;
+    get val(): boolean;
+    set val(b: boolean);
+    setValQuietly(val: boolean): void;
+    private onChangeCallback;
+    constructor(initialValue: boolean, onChangeCallback: () => void);
+}

package/lib/Entities/MemoizedBoolean.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoizedBoolean = void 0;
+class MemoizedBoolean {
+    constructor(initialValue, onChangeCallback) {
+        this._val = initialValue;
+        this.onChangeCallback = onChangeCallback;
+    }
+    get val() {
+        return this._val;
+    }
+    set val(b) {
+        if (this._val === b)
+            return;
+        this._val = b;
+        this.onChangeCallback();
+    }
+    setValQuietly(val) {
+        this._val = val;
+    }
+}
+exports.MemoizedBoolean = MemoizedBoolean;

package/lib/Entities/MemoizedNumber.d.ts

@@ -0,0 +1,8 @@
+export declare class MemoizedNumber {
+    private _val;
+    get val(): number;
+    set val(b: number);
+    setValQuietly(val: number): void;
+    private onChangeCallback;
+    constructor(initialValue: number, onChangeCallback: () => void);
+}

package/lib/Entities/MemoizedNumber.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoizedNumber = void 0;
+class MemoizedNumber {
+    constructor(initialValue, onChangeCallback) {
+        this._val = initialValue;
+        this.onChangeCallback = onChangeCallback;
+    }
+    get val() {
+        return this._val;
+    }
+    set val(b) {
+        if (this._val === b)
+            return;
+        this._val = b;
+        this.onChangeCallback();
+    }
+    setValQuietly(val) {
+        this._val = val;
+    }
+}
+exports.MemoizedNumber = MemoizedNumber;

package/lib/Entities/MemoizedQuaternion.d.ts

@@ -0,0 +1,9 @@
+import { Quaternion } from "../ValueObjects";
+export declare class MemoizedQuaternion {
+    private _val;
+    get val(): Quaternion;
+    set val(v: Quaternion);
+    setValQuietly(val: Quaternion): void;
+    private onChangeCallback;
+    constructor(initialValue: Quaternion, onChangeCallback: () => void);
+}

package/lib/Entities/MemoizedQuaternion.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoizedQuaternion = void 0;
+const ValueObjects_1 = require("../ValueObjects");
+class MemoizedQuaternion {
+    constructor(initialValue, onChangeCallback) {
+        this._val = initialValue;
+        this.onChangeCallback = onChangeCallback;
+    }
+    get val() {
+        return this._val;
+    }
+    set val(v) {
+        if (ValueObjects_1.Quaternion.Equal(v, this._val))
+            return;
+        this._val = v;
+        this.onChangeCallback();
+    }
+    setValQuietly(val) {
+        this._val = val;
+    }
+}
+exports.MemoizedQuaternion = MemoizedQuaternion;

package/lib/Entities/MemoizedString.d.ts

@@ -0,0 +1,8 @@
+export declare class MemoizedString {
+    private _val;
+    get val(): string;
+    set val(b: string);
+    setValQuietly(val: string): void;
+    private onChangeCallback;
+    constructor(initialValue: string, onChangeCallback: () => void);
+}