@vived/app 4.1.0 → 4.3.0

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/FramedScreen.d.ts

@@ -0,0 +1,15 @@
+import { FramedScreenContainer } from "./FramedScreenContainer";
+import { ObservableEntity } from "./ObservableEntity";
+export declare abstract class FramedScreen extends ObservableEntity {
+    abstract get containers(): FramedScreenContainer[];
+    abstract addContainer(container: FramedScreenContainer): void;
+    abstract addContainerByID(id: string): FramedScreenContainer;
+    abstract removeContainer(id: string): void;
+    abstract hasContainer(id: string): boolean;
+    abstract getContainerByID(id: string): FramedScreenContainer | undefined;
+    abstract get screenWidth(): number;
+    abstract set screenWidth(width: number);
+    abstract get screenHeight(): number;
+    abstract set screenHeight(height: number);
+}
+export declare function makeFramedScreen(): FramedScreen;

package/lib/Entities/FramedScreen.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeFramedScreen = exports.FramedScreen = void 0;
+const FramedScreenContainer_1 = require("./FramedScreenContainer");
+const MemoizedNumber_1 = require("./Memoized/MemoizedNumber");
+const ObservableEntity_1 = require("./ObservableEntity");
+class FramedScreen extends ObservableEntity_1.ObservableEntity {
+}
+exports.FramedScreen = FramedScreen;
+function makeFramedScreen() {
+    return new FramedScreenImp();
+}
+exports.makeFramedScreen = makeFramedScreen;
+class FramedScreenImp extends FramedScreen {
+    constructor() {
+        super(...arguments);
+        this.memoizeWidth = new MemoizedNumber_1.MemoizedNumber(0, this.notify);
+        this.memoizeHeight = new MemoizedNumber_1.MemoizedNumber(0, this.notify);
+        this._containerLookup = new Map();
+    }
+    get screenWidth() {
+        return this.memoizeWidth.val;
+    }
+    set screenWidth(val) {
+        this.memoizeWidth.val = val;
+    }
+    get screenHeight() {
+        return this.memoizeHeight.val;
+    }
+    set screenHeight(val) {
+        this.memoizeHeight.val = val;
+    }
+    get containers() {
+        return Array.from(this._containerLookup.values());
+    }
+    addContainer(container) {
+        this._containerLookup.set(container.id, container);
+        this.notify();
+    }
+    addContainerByID(id) {
+        const newContainer = FramedScreenContainer_1.makeFramedScreenContainer(id);
+        this.addContainer(newContainer);
+        return newContainer;
+    }
+    removeContainer(id) {
+        const container = this._containerLookup.get(id);
+        if (container) {
+            this._containerLookup.delete(id);
+            this.notify();
+        }
+    }
+    hasContainer(id) {
+        return this._containerLookup.has(id);
+    }
+    getContainerByID(id) {
+        return this._containerLookup.get(id);
+    }
+}

package/lib/Entities/FramedScreenContainer.d.ts

@@ -0,0 +1,12 @@
+import { Vector2 } from "../ValueObjects";
+import { ObservableEntity } from "./ObservableEntity";
+export declare abstract class FramedScreenContainer extends ObservableEntity {
+    abstract readonly id: string;
+    abstract get position(): Vector2;
+    abstract set position(p: Vector2);
+    abstract get size(): Vector2;
+    abstract set size(s: Vector2);
+    abstract get show(): boolean;
+    abstract set show(s: boolean);
+}
+export declare function makeFramedScreenContainer(id: string): FramedScreenContainer;

package/lib/Entities/FramedScreenContainer.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeFramedScreenContainer = exports.FramedScreenContainer = void 0;
+const ValueObjects_1 = require("../ValueObjects");
+const MemoizedBoolean_1 = require("./Memoized/MemoizedBoolean");
+const MemoizedVector2_1 = require("./Memoized/MemoizedVector2");
+const ObservableEntity_1 = require("./ObservableEntity");
+class FramedScreenContainer extends ObservableEntity_1.ObservableEntity {
+}
+exports.FramedScreenContainer = FramedScreenContainer;
+function makeFramedScreenContainer(id) {
+    return new FramedScreenContainerImp(id);
+}
+exports.makeFramedScreenContainer = makeFramedScreenContainer;
+class FramedScreenContainerImp extends FramedScreenContainer {
+    constructor(id) {
+        super();
+        this.memozedPos = new MemoizedVector2_1.MemoizedVector2(ValueObjects_1.Vector2.Zero(), this.notify);
+        this.memozedSize = new MemoizedVector2_1.MemoizedVector2(ValueObjects_1.Vector2.Zero(), this.notify);
+        this.memoizedShow = new MemoizedBoolean_1.MemoizedBoolean(true, this.notify);
+        this.id = id;
+    }
+    get position() {
+        return this.memozedPos.val;
+    }
+    set position(p) {
+        this.memozedPos.val = p;
+    }
+    get size() {
+        return this.memozedSize.val;
+    }
+    set size(s) {
+        this.memozedSize.val = s;
+    }
+    get show() {
+        return this.memoizedShow.val;
+    }
+    set show(s) {
+        this.memoizedShow.val = s;
+    }
+}

package/lib/Entities/HoverLabels.d.ts

@@ -0,0 +1,42 @@
+import { Vector2 } from "../ValueObjects";
+import { ObservableEntity } from "./ObservableEntity";
+export declare abstract class HoverLabels extends ObservableEntity {
+    /**
+     * Should the label be shown
+     */
+    abstract get show(): boolean;
+    /**
+     * Pixel coordinates of the label
+     */
+    abstract get position(): Vector2;
+    /**
+     * String to display
+     */
+    abstract get label(): string;
+    /**
+     * Gets if hover labels should be allowed
+     */
+    abstract get allowHoverLabels(): boolean;
+    /**
+     * Sets if hover labels should be shown. Will notify
+     */
+    abstract set allowHoverLabels(allow: boolean);
+    /**
+     * Sets up a label for a scene object by id
+     */
+    abstract setLabelForSceneObject: (sceneObjectID: string, label: string) => void;
+    /**
+     * Removes the labels for a scene object by id
+     */
+    abstract removeLabelForSceneObject: (sceneObjectID: string) => void;
+    /**
+     * Tries to get a label for a scene object by id. Returns undefined if one does not exist
+     */
+    abstract getLabelFroSceneObject: (sceneObjectID: string) => string | undefined;
+    /**
+     * Sets up the system to show a label for a scene object at a given position
+     */
+    abstract showLabelForSceneObject: (sceneObjectID: string, position: Vector2) => void;
+    abstract hideHoverLabel: () => void;
+}
+export declare function makeHoverLabels(): HoverLabels;

package/lib/Entities/HoverLabels.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeHoverLabels = exports.HoverLabels = void 0;
+const ValueObjects_1 = require("../ValueObjects");
+const MemoizedBoolean_1 = require("./Memoized/MemoizedBoolean");
+const ObservableEntity_1 = require("./ObservableEntity");
+class HoverLabels extends ObservableEntity_1.ObservableEntity {
+}
+exports.HoverLabels = HoverLabels;
+function makeHoverLabels() {
+    return new HoverLabelsImp();
+}
+exports.makeHoverLabels = makeHoverLabels;
+class HoverLabelsImp extends HoverLabels {
+    constructor() {
+        super(...arguments);
+        this.labelLookup = new Map();
+        this._show = false;
+        this._position = ValueObjects_1.Vector2.Zero();
+        this._label = "";
+        this.memoizedAllow = new MemoizedBoolean_1.MemoizedBoolean(true, this.notify);
+        this.setLabelForSceneObject = (sceneObjectID, label) => {
+            this.labelLookup.set(sceneObjectID, label);
+        };
+        this.removeLabelForSceneObject = (sceneObjectID) => {
+            this.labelLookup.delete(sceneObjectID);
+        };
+        this.getLabelFroSceneObject = (sceneObjectID) => {
+            return this.labelLookup.get(sceneObjectID);
+        };
+        this.showLabelForSceneObject = (sceneObjectID, position) => {
+            var _a;
+            if (this.labelLookup.has(sceneObjectID)) {
+                this.doShow((_a = this.labelLookup.get(sceneObjectID)) !== null && _a !== void 0 ? _a : "", position);
+            }
+            else {
+                this.hideHoverLabel();
+            }
+        };
+        this.hideHoverLabel = () => {
+            if (!this._show)
+                return;
+            this._show = false;
+            this._label = "";
+            this._position = ValueObjects_1.Vector2.Zero();
+            this.notify();
+        };
+    }
+    get show() {
+        return this._show;
+    }
+    get position() {
+        return this._position;
+    }
+    get label() {
+        return this._label;
+    }
+    get allowHoverLabels() {
+        return this.memoizedAllow.val;
+    }
+    set allowHoverLabels(allow) {
+        if (allow === this.memoizedAllow.val)
+            return;
+        this.memoizedAllow.val = allow;
+        if (allow === false) {
+            this.hideHoverLabel();
+        }
+    }
+    doShow(label, pos) {
+        if (!this.allowHoverLabels)
+            return;
+        if (label === this._label &&
+            ValueObjects_1.Vector2.Equal(pos, this._position) &&
+            this.show) {
+            return;
+        }
+        this._label = label;
+        this._position = pos;
+        this._show = true;
+        this.notify();
+    }
+}

package/lib/Entities/KeyboardInput.d.ts

@@ -0,0 +1,13 @@
+export interface KeyboardController {
+    onKeyDown?: (e: KeyboardEvent) => void;
+    onKeyUp?: (e: KeyboardEvent) => void;
+}
+export interface KeyboardInput {
+    eventElement: HTMLElement | undefined;
+    setEventElement: (eventElement: HTMLElement) => void;
+    clearInputElement: () => void;
+    registerController: (controller: KeyboardController) => void;
+    removeController: (controller: KeyboardController) => void;
+    isKeyPressed: (keyCode: string) => boolean;
+}
+export declare function makeKeyboardInput(): KeyboardInput;

package/lib/Entities/KeyboardInput.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeKeyboardInput = void 0;
+function makeKeyboardInput() {
+    return new KeyboardInputImp();
+}
+exports.makeKeyboardInput = makeKeyboardInput;
+class KeyboardInputImp {
+    constructor() {
+        this.controllers = [];
+        this._eventElement = undefined;
+        this._pressedKeyCodes = [];
+        this.setEventElement = (element) => {
+            this.clearInputElement();
+            element.addEventListener("keydown", this.submitKeyDown, false);
+            element.addEventListener("keyup", this.submitKeyUp, false);
+            this._eventElement = element;
+        };
+        this.clearInputElement = () => {
+            if (!this._eventElement)
+                return;
+            this._eventElement.removeEventListener("keydown", this.submitKeyDown);
+            this._eventElement.removeEventListener("keyup", this.submitKeyUp);
+            this._eventElement = undefined;
+        };
+        this.submitKeyDown = (e) => {
+            this._pressedKeyCodes.push(e.code);
+            this.controllers.forEach((c) => {
+                if (c.onKeyDown) {
+                    c.onKeyDown(e);
+                }
+            });
+        };
+        this.submitKeyUp = (e) => {
+            this._pressedKeyCodes = this._pressedKeyCodes.filter((keyCode) => {
+                if (keyCode === e.code) {
+                    return false;
+                }
+                return true;
+            });
+            this.controllers.forEach((c) => {
+                if (c.onKeyUp) {
+                    c.onKeyUp(e);
+                }
+            });
+        };
+        this.registerController = (controller) => {
+            this.controllers.push(controller);
+        };
+        this.removeController = (controller) => {
+            const index = this.controllers.indexOf(controller);
+            if (index >= 0) {
+                this.controllers.splice(index, 1);
+            }
+        };
+        this.isKeyPressed = (keyCode) => {
+            for (const code of this._pressedKeyCodes) {
+                if (code === keyCode) {
+                    return true;
+                }
+            }
+            return false;
+        };
+    }
+    get eventElement() {
+        return this._eventElement;
+    }
+}

package/lib/Entities/Memoized/MemoizedAngle.d.ts

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

package/lib/Entities/Memoized/MemoizedAngle.js

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

package/lib/Entities/Memoized/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/Memoized/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/Memoized/MemoizedColor.d.ts

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