@vived/app 3.9.2 → 4.0.0

package/lib/Components/StoredView/PM/HasStoredViewPM.d.ts

@@ -0,0 +1,6 @@
+import { AppObject, AppObjectPM, AppObjectRepo } from "../../../AppObject";
+export declare abstract class HasStoredViewPM extends AppObjectPM<boolean> {
+    static readonly type = "HasStoredViewPM";
+    static get: (appObjects: AppObjectRepo) => HasStoredViewPM | undefined;
+}
+export declare function makeHasStoredViewPM(appObject: AppObject): HasStoredViewPM;

package/lib/Components/StoredView/PM/HasStoredViewPM.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeHasStoredViewPM = exports.HasStoredViewPM = void 0;
+const AppObject_1 = require("../../../AppObject");
+const Entities_1 = require("../Entities");
+class HasStoredViewPM extends AppObject_1.AppObjectPM {
+}
+exports.HasStoredViewPM = HasStoredViewPM;
+HasStoredViewPM.type = "HasStoredViewPM";
+HasStoredViewPM.get = (appObjects) => AppObject_1.getSingletonComponent(HasStoredViewPM.type, appObjects);
+function makeHasStoredViewPM(appObject) {
+    return new HasStoredViewPMImp(appObject);
+}
+exports.makeHasStoredViewPM = makeHasStoredViewPM;
+class HasStoredViewPMImp extends HasStoredViewPM {
+    constructor(appObject) {
+        super(appObject, HasStoredViewPM.type);
+        this.onRepoChange = () => {
+            if (!this.storedView)
+                return;
+            this.doUpdateView(this.storedView.hasStoredView);
+        };
+        this.dispose = () => {
+            var _a, _b;
+            super.dispose();
+            (_a = this.storedView) === null || _a === void 0 ? void 0 : _a.removeChangeObserver(this.onRepoChange);
+            (_b = this.storedView) === null || _b === void 0 ? void 0 : _b.removeOnDisposeObserver(this.dispose);
+        };
+        this.storedView = appObject.getComponent(Entities_1.StoredView.type);
+        if (this.storedView) {
+            this.storedView.addChangeObserver(this.onRepoChange);
+            this.storedView.addOnDisposeObserver(() => this.dispose());
+            this.onRepoChange();
+        }
+        else {
+            console.warn("[HasStoredViewPMImp] App Object does not have a StoredView Entity");
+        }
+    }
+    vmsAreEqual(a, b) {
+        return a === b;
+    }
+}

package/lib/Components/StoredView/PM/index.d.ts

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

package/lib/Components/StoredView/PM/index.js

@@ -0,0 +1,13 @@
+"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("./HasStoredViewPM"), exports);

package/lib/Components/StoredView/UC/ClearStoredViewUC.d.ts

@@ -0,0 +1,8 @@
+import { AppObject, AppObjectRepo, AppObjectUC } from "../../../AppObject";
+export declare abstract class ClearStoredViewUC extends AppObjectUC {
+    static readonly type = "ClearStoredViewUC";
+    static get: (appObjects: AppObjectRepo) => ClearStoredViewUC | undefined;
+    abstract clearStoredView(): void;
+}
+export declare function makeClearStoredViewUC(appObject: AppObject): ClearStoredViewUC;
+export declare function clearStoredView(appObjects: AppObjectRepo): void;

package/lib/Components/StoredView/UC/ClearStoredViewUC.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clearStoredView = exports.makeClearStoredViewUC = exports.ClearStoredViewUC = void 0;
+const AppObject_1 = require("../../../AppObject");
+const ValueObjects_1 = require("../../../ValueObjects");
+const Dispatcher_1 = require("../../Dispatcher");
+const Entities_1 = require("../Entities");
+class ClearStoredViewUC extends AppObject_1.AppObjectUC {
+}
+exports.ClearStoredViewUC = ClearStoredViewUC;
+ClearStoredViewUC.type = "ClearStoredViewUC";
+ClearStoredViewUC.get = (appObjects) => AppObject_1.getSingletonComponent(ClearStoredViewUC.type, appObjects);
+function makeClearStoredViewUC(appObject) {
+    return new ClearStoredViewUCImp(appObject);
+}
+exports.makeClearStoredViewUC = makeClearStoredViewUC;
+function clearStoredView(appObjects) {
+    const uc = ClearStoredViewUC.get(appObjects);
+    if (uc) {
+        uc.clearStoredView();
+    }
+    else {
+        appObjects.submitWarning("clearStoredView", "Can't find ClearStoredViewUC");
+    }
+}
+exports.clearStoredView = clearStoredView;
+class ClearStoredViewUCImp extends ClearStoredViewUC {
+    constructor(appObject) {
+        super(appObject, ClearStoredViewUC.type);
+        this.clearStoredView = () => {
+            if (!this.storedView)
+                return;
+            this.storedView.position = ValueObjects_1.Vector3.Zero();
+            this.storedView.rotation = ValueObjects_1.Quaternion.Identity();
+            this.storedView.scale = 1;
+            this.storedView.hasStoredView = false;
+            Dispatcher_1.dispatchStateChange(this.appObject.appObjectRepo);
+        };
+        this.storedView = Entities_1.StoredView.get(appObject.appObjectRepo);
+        if (!this.storedView) {
+            this.warn("Unable to find stored view");
+        }
+    }
+}

package/lib/Components/StoredView/UC/RestoreStoredViewUC.d.ts

@@ -0,0 +1,10 @@
+import { AppObject, AppObjectRepo, AppObjectUC } from "../../../AppObject";
+import { EaseFn } from "../../../Types";
+export declare abstract class RestoreStoredViewUC extends AppObjectUC {
+    static readonly type = "RestoreStoredViewUC";
+    static get: (appObjects: AppObjectRepo) => RestoreStoredViewUC | undefined;
+    abstract restoreStoredView(): void;
+    abstract ease: EaseFn;
+}
+export declare function makeRestoreStoredViewUC(appObject: AppObject): RestoreStoredViewUC;
+export declare function restoreStoredView(appObjects: AppObjectRepo): void;

package/lib/Components/StoredView/UC/RestoreStoredViewUC.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.restoreStoredView = exports.makeRestoreStoredViewUC = exports.RestoreStoredViewUC = void 0;
+const AppObject_1 = require("../../../AppObject");
+const ValueObjects_1 = require("../../../ValueObjects");
+const SceneRoot_1 = require("../../SceneRoot");
+const Entities_1 = require("../Entities");
+class RestoreStoredViewUC extends AppObject_1.AppObjectUC {
+}
+exports.RestoreStoredViewUC = RestoreStoredViewUC;
+RestoreStoredViewUC.type = "RestoreStoredViewUC";
+RestoreStoredViewUC.get = (appObjects) => AppObject_1.getSingletonComponent(RestoreStoredViewUC.type, appObjects);
+function makeRestoreStoredViewUC(appObject) {
+    return new RestoreStoredViewUCImp(appObject);
+}
+exports.makeRestoreStoredViewUC = makeRestoreStoredViewUC;
+function restoreStoredView(appObjects) {
+    const uc = RestoreStoredViewUC.get(appObjects);
+    if (uc) {
+        uc.restoreStoredView();
+    }
+    else {
+        appObjects.submitWarning("restoreStoredView", "Can't find ClearStoredViewUC");
+    }
+}
+exports.restoreStoredView = restoreStoredView;
+class RestoreStoredViewUCImp extends RestoreStoredViewUC {
+    constructor(appObject) {
+        super(appObject, RestoreStoredViewUC.type);
+        this.ease = (val) => {
+            return val;
+        }; // Default to lineal
+        this.restoreStoredView = () => {
+            if (this.storedView && this.sceneRoot) {
+                if (!this.storedView.hasStoredView)
+                    return;
+                const scale = new ValueObjects_1.Vector3(this.storedView.scale, this.storedView.scale, this.storedView.scale);
+                const lerpDTO = {
+                    durationMS: 1000,
+                    ease: this.ease,
+                    desiredPosition: this.storedView.position,
+                    desiredRotation: this.storedView.rotation,
+                    desiredScale: scale,
+                };
+                this.sceneRoot.transform.lerp(lerpDTO);
+            }
+            else {
+                this.warn("Missing necessary entities");
+            }
+        };
+        this.sceneRoot = SceneRoot_1.SceneRootEntity.get(appObject.appObjectRepo);
+        if (!this.sceneRoot) {
+            this.error("Unable to find scene root");
+            return;
+        }
+        this.storedView = Entities_1.StoredView.get(appObject.appObjectRepo);
+        if (!this.storedView) {
+            this.error("Unable to find stored view");
+            return;
+        }
+    }
+}

package/lib/Components/StoredView/UC/SerializeStoredView.d.ts

@@ -0,0 +1,27 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectUC } from "../../../AppObject/AppObjectUC";
+import { SerializedSystem } from "../../StateMachine/Entities/StateMachineEntity";
+export declare abstract class SerializeStoredView extends AppObjectUC implements SerializedSystem {
+    static readonly type = "SerializeStoredView";
+    name: string;
+    abstract seriliziationVersion: number;
+    abstract getSystemState(): object;
+    abstract applySystemState(state: object, version: number): void;
+    abstract applyDefaultState(transitionDuration: number): void;
+}
+export declare function makeSerializeStoredView(appObject: AppObject): SerializeStoredView;
+export interface StoredViewDataV1 {
+    position: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    rotation: {
+        x: number;
+        y: number;
+        z: number;
+        w: number;
+    };
+    scale: number;
+    hasStoredView: boolean;
+}

package/lib/Components/StoredView/UC/SerializeStoredView.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeSerializeStoredView = exports.SerializeStoredView = void 0;
+const AppObjectUC_1 = require("../../../AppObject/AppObjectUC");
+const ValueObjects_1 = require("../../../ValueObjects");
+const StateMachineEntity_1 = require("../../StateMachine/Entities/StateMachineEntity");
+const StoredView_1 = require("../Entities/StoredView");
+class SerializeStoredView extends AppObjectUC_1.AppObjectUC {
+    constructor() {
+        super(...arguments);
+        this.name = "storedView";
+    }
+}
+exports.SerializeStoredView = SerializeStoredView;
+SerializeStoredView.type = "SerializeStoredView";
+function makeSerializeStoredView(appObject) {
+    return new SerializeStoredViewImp(appObject);
+}
+exports.makeSerializeStoredView = makeSerializeStoredView;
+class SerializeStoredViewImp extends SerializeStoredView {
+    constructor(appObject) {
+        super(appObject, SerializeStoredView.type);
+        this.seriliziationVersion = 1;
+        this.storedView = appObject.getComponent(StoredView_1.StoredView.type);
+        if (!this.storedView) {
+            console.warn("SerializeStoredView UC has been added to an App Object that does not have a StoredView Entity. Add one before adding the UC");
+            this.dispose();
+            return;
+        }
+        const stateMachine = StateMachineEntity_1.StateMachineEntity.get(appObject.appObjectRepo);
+        if (stateMachine) {
+            stateMachine.registerSerializedSystem(this);
+        }
+        else {
+            this.warn("Unable to find StateMachineEntity");
+        }
+    }
+    getSystemState() {
+        if (!this.storedView) {
+            console.warn("[SerializeStoredView] No stored view entity");
+            return {};
+        }
+        const data = {
+            position: this.storedView.position.dto,
+            rotation: this.storedView.rotation.dto,
+            scale: this.storedView.scale,
+            hasStoredView: this.storedView.hasStoredView,
+        };
+        return data;
+    }
+    applySystemState(serializedState, version) {
+        try {
+            if (version === 1) {
+                const castState = serializedState;
+                this.applyV1Data(castState);
+            }
+            else {
+                console.warn(`[SerializeStoredView] Unsupported version number ${version}. Defaulting`);
+                this.applyDefaultState();
+            }
+        }
+        catch (e) {
+            console.warn(`[SerializeStoredView] Caught when deserializing ${e}. Defaulting`);
+            this.applyDefaultState();
+        }
+    }
+    applyDefaultState() {
+        if (!this.storedView) {
+            console.warn("[SerializeStoredView] No stored view entity");
+            return;
+        }
+        this.storedView.position = ValueObjects_1.Vector3.Zero();
+        this.storedView.rotation = ValueObjects_1.Quaternion.Identity();
+        this.storedView.scale = 1;
+        this.storedView.hasStoredView = false;
+    }
+    applyV1Data(data) {
+        if (!this.storedView) {
+            console.warn("[SerializeStoredView] No stored view entity");
+            return;
+        }
+        const pos = ValueObjects_1.Vector3.FromDTO(data.position);
+        const rot = ValueObjects_1.Quaternion.FromDTO(data.rotation);
+        this.storedView.position = pos;
+        this.storedView.rotation = rot;
+        this.storedView.scale = data.scale;
+        this.storedView.hasStoredView = data.hasStoredView;
+    }
+}

package/lib/Components/StoredView/UC/SetInXRUC.d.ts

@@ -0,0 +1,8 @@
+import { AppObject, AppObjectRepo, AppObjectUC } from "../../../AppObject";
+export declare abstract class SetViewInXRUC extends AppObjectUC {
+    static readonly type = "SetViewInXRUC";
+    static get: (appObjects: AppObjectRepo) => SetViewInXRUC | undefined;
+    abstract setViewInXR(): void;
+}
+export declare function makeSetViewInXRUC(appObject: AppObject): SetViewInXRUC;
+export declare function setViewInXR(appObjects: AppObjectRepo): void;

package/lib/Components/StoredView/UC/SetInXRUC.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setViewInXR = exports.makeSetViewInXRUC = exports.SetViewInXRUC = void 0;
+const AppObject_1 = require("../../../AppObject");
+const Dispatcher_1 = require("../../Dispatcher");
+class SetViewInXRUC extends AppObject_1.AppObjectUC {
+}
+exports.SetViewInXRUC = SetViewInXRUC;
+SetViewInXRUC.type = "SetViewInXRUC";
+SetViewInXRUC.get = (appObjects) => AppObject_1.getSingletonComponent(SetViewInXRUC.type, appObjects);
+function makeSetViewInXRUC(appObject) {
+    return new SetViewInXRUCImp(appObject);
+}
+exports.makeSetViewInXRUC = makeSetViewInXRUC;
+function setViewInXR(appObjects) {
+    const uc = SetViewInXRUC.get(appObjects);
+    if (uc) {
+        uc.setViewInXR();
+    }
+    else {
+        appObjects.submitWarning("setViewInXR", "Can't find ClearStoredViewUC");
+    }
+}
+exports.setViewInXR = setViewInXR;
+class SetViewInXRUCImp extends SetViewInXRUC {
+    constructor(appObject) {
+        super(appObject, SetViewInXRUC.type);
+        this.setViewInXR = () => {
+            if (this.dispatchStartZSpace) {
+                this.dispatchStartZSpace.doDispatch();
+            }
+            else {
+                this.warn("Missing necessary entities");
+            }
+        };
+        this.dispatchStartZSpace = Dispatcher_1.DispatchStartZSpaceUC.get(appObject.appObjectRepo);
+        if (!this.dispatchStartZSpace) {
+            console.error("No DispatchStartZSpace");
+        }
+    }
+}

package/lib/Components/StoredView/UC/StoreCurrentViewUC.d.ts

@@ -0,0 +1,8 @@
+import { AppObject, AppObjectRepo, AppObjectUC } from "../../../AppObject";
+export declare abstract class StoreCurrentViewUC extends AppObjectUC {
+    static readonly type = "StoreCurrentViewUC";
+    static get: (appObjects: AppObjectRepo) => StoreCurrentViewUC | undefined;
+    abstract storeCurrentView(): void;
+}
+export declare function makeStoreCurrentViewUC(appObject: AppObject): StoreCurrentViewUC;
+export declare function storeCurrentView(appObjects: AppObjectRepo): void;

package/lib/Components/StoredView/UC/StoreCurrentViewUC.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.storeCurrentView = exports.makeStoreCurrentViewUC = exports.StoreCurrentViewUC = void 0;
+const AppObject_1 = require("../../../AppObject");
+const Dispatcher_1 = require("../../Dispatcher");
+const SceneRoot_1 = require("../../SceneRoot");
+const Entities_1 = require("../Entities");
+class StoreCurrentViewUC extends AppObject_1.AppObjectUC {
+}
+exports.StoreCurrentViewUC = StoreCurrentViewUC;
+StoreCurrentViewUC.type = "StoreCurrentViewUC";
+StoreCurrentViewUC.get = (appObjects) => AppObject_1.getSingletonComponent(StoreCurrentViewUC.type, appObjects);
+function makeStoreCurrentViewUC(appObject) {
+    return new StoreCurrentViewUCImp(appObject);
+}
+exports.makeStoreCurrentViewUC = makeStoreCurrentViewUC;
+function storeCurrentView(appObjects) {
+    const uc = StoreCurrentViewUC.get(appObjects);
+    if (uc) {
+        uc.storeCurrentView();
+    }
+    else {
+        appObjects.submitWarning("storeCurrentView", "Can't find StoreCurrentViewUC");
+    }
+}
+exports.storeCurrentView = storeCurrentView;
+class StoreCurrentViewUCImp extends StoreCurrentViewUC {
+    constructor(appObject) {
+        super(appObject, StoreCurrentViewUC.type);
+        this.storeCurrentView = () => {
+            if (!this.storedView || !this.sceneRoot)
+                return;
+            this.storedView.position = this.sceneRoot.position;
+            this.storedView.rotation = this.sceneRoot.rotation;
+            this.storedView.scale = this.sceneRoot.scale;
+            this.storedView.hasStoredView = true;
+            Dispatcher_1.dispatchStateChange(this.appObject.appObjectRepo);
+        };
+        this.sceneRoot = SceneRoot_1.SceneRootEntity.get(appObject.appObjectRepo);
+        if (!this.sceneRoot) {
+            this.error("Unable to find scene root");
+        }
+        this.storedView = Entities_1.StoredView.get(appObject.appObjectRepo);
+        if (!this.storedView) {
+            this.error("Unable to find stored view");
+        }
+    }
+}

package/lib/Components/StoredView/UC/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./ClearStoredViewUC";
+export * from "./RestoreStoredViewUC";
+export * from "./SerializeStoredView";
+export * from "./SetInXRUC";
+export * from "./StoreCurrentViewUC";

package/lib/Components/StoredView/UC/index.js

@@ -0,0 +1,17 @@
+"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("./ClearStoredViewUC"), exports);
+__exportStar(require("./RestoreStoredViewUC"), exports);
+__exportStar(require("./SerializeStoredView"), exports);
+__exportStar(require("./SetInXRUC"), exports);
+__exportStar(require("./StoreCurrentViewUC"), exports);

package/lib/Components/StoredView/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./Entities";
+export * from "./PM";
+export * from "./UC";

package/lib/Components/StoredView/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"), exports);
+__exportStar(require("./PM"), exports);
+__exportStar(require("./UC"), exports);

package/lib/Components/ThemeColors/Entities/ThemeColors.d.ts

@@ -0,0 +1,69 @@
+import { AppObject, AppObjectEntity, AppObjectRepo } from "../../../AppObject";
+import { Color } from "../../../ValueObjects";
+export declare enum ThemeColorType {
+    primary = "primary",
+    onPrimary = "onPrimary",
+    primaryContainer = "primaryContainer",
+    onPrimaryContainer = "onPrimaryContainer",
+    primaryFixed = "primaryFixed",
+    onPrimaryFixed = "onPrimaryFixed",
+    primaryFixedDim = "primaryFixedDim",
+    onPrimaryFixedVariant = "onPrimaryFixedVariant",
+    secondary = "secondary",
+    onSecondary = "onSecondary",
+    secondaryContainer = "secondaryContainer",
+    onSecondaryContainer = "onSecondaryContainer",
+    secondaryFixed = "secondaryFixed",
+    onSecondaryFixed = "onSecondaryFixed",
+    secondaryFixedDim = "secondaryFixedDim",
+    onSecondaryFixedVariant = "onSecondaryFixedVariant",
+    tertiary = "tertiary",
+    onTertiary = "onTertiary",
+    tertiaryContainer = "tertiaryContainer",
+    onTertiaryContainer = "onTertiaryContainer",
+    tertiaryFixed = "tertiaryFixed",
+    onTertiaryFixed = "onTertiaryFixed",
+    tertiaryFixedDim = "tertiaryFixedDim",
+    onTertiaryFixedVariant = "onTertiaryFixedVariant",
+    error = "error",
+    onError = "onError",
+    errorContainer = "errorContainer",
+    onErrorContainer = "onErrorContainer",
+    outline = "outline",
+    background = "background",
+    onBackground = "onBackground",
+    surface = "surface",
+    onSurface = "onSurface",
+    surfaceVariant = "surfaceVariant",
+    onSurfaceVariant = "onSurfaceVariant",
+    inverseSurface = "inverseSurface",
+    inverseOnSurface = "inverseOnSurface",
+    inversePrimary = "inversePrimary",
+    shadow = "shadow",
+    surfaceTint = "surfaceTint",
+    outlineVariant = "outlineVariant",
+    scrim = "scrim",
+    surfaceContainerHighest = "surfaceContainerHighest",
+    surfaceContainerHigh = "surfaceContainerHigh",
+    surfaceContainer = "surfaceContainer",
+    surfaceContainerLow = "surfaceContainerLow",
+    surfaceContainerLowest = "surfaceContainerLowest",
+    surfaceBright = "surfaceBright",
+    surfaceDim = "surfaceDim"
+}
+export declare abstract class ThemeColors extends AppObjectEntity {
+    static readonly type = "ThemeColors";
+    abstract getColorForType(type: ThemeColorType): Color;
+    abstract setColorForType(type: ThemeColorType, val: Color): void;
+    abstract setColorHexForType(type: ThemeColorType, hex: string): void;
+    static get: (appObjects: AppObjectRepo) => ThemeColors | undefined;
+}
+export declare function makeThemeColors(appObject: AppObject): ThemeColorsImp;
+declare class ThemeColorsImp extends ThemeColors {
+    private memoizedColorLookup;
+    constructor(appObject: AppObject);
+    getColorForType: (type: ThemeColorType) => Color;
+    setColorForType: (type: ThemeColorType, val: Color) => void;
+    setColorHexForType: (type: ThemeColorType, hex: string) => void;
+}
+export {};

package/lib/Components/ThemeColors/Entities/ThemeColors.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeThemeColors = exports.ThemeColors = exports.ThemeColorType = void 0;
+const AppObject_1 = require("../../../AppObject");
+const Entities_1 = require("../../../Entities");
+const ValueObjects_1 = require("../../../ValueObjects");
+var ThemeColorType;
+(function (ThemeColorType) {
+    ThemeColorType["primary"] = "primary";
+    ThemeColorType["onPrimary"] = "onPrimary";
+    ThemeColorType["primaryContainer"] = "primaryContainer";
+    ThemeColorType["onPrimaryContainer"] = "onPrimaryContainer";
+    ThemeColorType["primaryFixed"] = "primaryFixed";
+    ThemeColorType["onPrimaryFixed"] = "onPrimaryFixed";
+    ThemeColorType["primaryFixedDim"] = "primaryFixedDim";
+    ThemeColorType["onPrimaryFixedVariant"] = "onPrimaryFixedVariant";
+    ThemeColorType["secondary"] = "secondary";
+    ThemeColorType["onSecondary"] = "onSecondary";
+    ThemeColorType["secondaryContainer"] = "secondaryContainer";
+    ThemeColorType["onSecondaryContainer"] = "onSecondaryContainer";
+    ThemeColorType["secondaryFixed"] = "secondaryFixed";
+    ThemeColorType["onSecondaryFixed"] = "onSecondaryFixed";
+    ThemeColorType["secondaryFixedDim"] = "secondaryFixedDim";
+    ThemeColorType["onSecondaryFixedVariant"] = "onSecondaryFixedVariant";
+    ThemeColorType["tertiary"] = "tertiary";
+    ThemeColorType["onTertiary"] = "onTertiary";
+    ThemeColorType["tertiaryContainer"] = "tertiaryContainer";
+    ThemeColorType["onTertiaryContainer"] = "onTertiaryContainer";
+    ThemeColorType["tertiaryFixed"] = "tertiaryFixed";
+    ThemeColorType["onTertiaryFixed"] = "onTertiaryFixed";
+    ThemeColorType["tertiaryFixedDim"] = "tertiaryFixedDim";
+    ThemeColorType["onTertiaryFixedVariant"] = "onTertiaryFixedVariant";
+    ThemeColorType["error"] = "error";
+    ThemeColorType["onError"] = "onError";
+    ThemeColorType["errorContainer"] = "errorContainer";
+    ThemeColorType["onErrorContainer"] = "onErrorContainer";
+    ThemeColorType["outline"] = "outline";
+    ThemeColorType["background"] = "background";
+    ThemeColorType["onBackground"] = "onBackground";
+    ThemeColorType["surface"] = "surface";
+    ThemeColorType["onSurface"] = "onSurface";
+    ThemeColorType["surfaceVariant"] = "surfaceVariant";
+    ThemeColorType["onSurfaceVariant"] = "onSurfaceVariant";
+    ThemeColorType["inverseSurface"] = "inverseSurface";
+    ThemeColorType["inverseOnSurface"] = "inverseOnSurface";
+    ThemeColorType["inversePrimary"] = "inversePrimary";
+    ThemeColorType["shadow"] = "shadow";
+    ThemeColorType["surfaceTint"] = "surfaceTint";
+    ThemeColorType["outlineVariant"] = "outlineVariant";
+    ThemeColorType["scrim"] = "scrim";
+    ThemeColorType["surfaceContainerHighest"] = "surfaceContainerHighest";
+    ThemeColorType["surfaceContainerHigh"] = "surfaceContainerHigh";
+    ThemeColorType["surfaceContainer"] = "surfaceContainer";
+    ThemeColorType["surfaceContainerLow"] = "surfaceContainerLow";
+    ThemeColorType["surfaceContainerLowest"] = "surfaceContainerLowest";
+    ThemeColorType["surfaceBright"] = "surfaceBright";
+    ThemeColorType["surfaceDim"] = "surfaceDim";
+})(ThemeColorType = exports.ThemeColorType || (exports.ThemeColorType = {}));
+class ThemeColors extends AppObject_1.AppObjectEntity {
+}
+exports.ThemeColors = ThemeColors;
+ThemeColors.type = "ThemeColors";
+ThemeColors.get = (appObjects) => AppObject_1.getSingletonComponent(ThemeColors.type, appObjects);
+function makeThemeColors(appObject) {
+    return new ThemeColorsImp(appObject);
+}
+exports.makeThemeColors = makeThemeColors;
+class ThemeColorsImp extends ThemeColors {
+    constructor(appObject) {
+        super(appObject, ThemeColors.type);
+        this.memoizedColorLookup = new Map();
+        this.getColorForType = (type) => {
+            const memoizedColor = this.memoizedColorLookup.get(type);
+            if (memoizedColor) {
+                return memoizedColor.val;
+            }
+            // Edge case. Not sure how to even get here.
+            console.warn("[ThemeColors] Unknown color type " + type);
+            return ValueObjects_1.Color.RGBA(0, 0, 0, 0);
+        };
+        this.setColorForType = (type, val) => {
+            const memoizedColor = this.memoizedColorLookup.get(type);
+            if (!memoizedColor) {
+                // Edge case. Not sure how to even get here.
+                return;
+            }
+            memoizedColor.val = val;
+        };
+        this.setColorHexForType = (type, hex) => {
+            const memoizedColor = this.memoizedColorLookup.get(type);
+            if (!memoizedColor) {
+                // Edge case. Not sure how to even get here.
+                return;
+            }
+            memoizedColor.val = ValueObjects_1.Color.Hex(hex);
+        };
+        for (const themeColor in ThemeColorType) {
+            const memoizedColor = new Entities_1.MemoizedColor(ValueObjects_1.Color.RGBA(0, 0, 0, 0), this.notifyOnChange);
+            this.memoizedColorLookup.set(themeColor, memoizedColor);
+        }
+    }
+}

package/lib/Components/ThemeColors/Entities/index.d.ts

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