@vived/app 4.28.2 → 4.30.0

package/lib/Components/Environment/Factories/setupEnvironmnets.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupEnvironments = void 0;
+const Environment_1 = require("../Entities/Environment");
+const EnvironmentalIntensityPM_1 = require("../PMs/EnvironmentalIntensityPM");
+const TexturalEnvironmentPM_1 = require("../PMs/TexturalEnvironmentPM");
+const SerializeEnvironment_1 = require("../UCs/SerializeEnvironment");
+const SetEnvironmentIntensityUC_1 = require("../UCs/SetEnvironmentIntensityUC");
+const SetTexturalEnvironmentUC_1 = require("../UCs/SetTexturalEnvironmentUC");
+function setupEnvironments(appObjects) {
+    const ao = appObjects.getOrCreate("Environments");
+    Environment_1.makeEnvironmentEntity(ao);
+    SetTexturalEnvironmentUC_1.makeSetTexturalEnvironmentUC(ao);
+    new SerializeEnvironment_1.SerializeEnvironment(ao);
+    SetEnvironmentIntensityUC_1.makeSetEnvironmentIntensityUC(ao);
+    TexturalEnvironmentPM_1.makeTexturalEnvironmentPM(ao);
+    EnvironmentalIntensityPM_1.makeEnvironmentalIntensityPM(ao);
+}
+exports.setupEnvironments = setupEnvironments;

package/lib/Components/Environment/Mocks/EnvironmentalIntensityPmMock.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="jest" />
+import { AppObject, AppObjectRepo } from "../../../AppObject";
+import { EnvironmentalIntensityPM } from "../PMs/EnvironmentalIntensityPM";
+export declare class EnvironmentalIntensityPmMock extends EnvironmentalIntensityPM {
+    vmsAreEqual: jest.Mock<any, any>;
+    constructor(appObject: AppObject);
+}
+export declare function makeEnvironmentalIntensityPmMock(appObjects: AppObjectRepo): EnvironmentalIntensityPmMock;

package/lib/Components/Environment/Mocks/EnvironmentalIntensityPmMock.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeEnvironmentalIntensityPmMock = exports.EnvironmentalIntensityPmMock = void 0;
+const EnvironmentalIntensityPM_1 = require("../PMs/EnvironmentalIntensityPM");
+class EnvironmentalIntensityPmMock extends EnvironmentalIntensityPM_1.EnvironmentalIntensityPM {
+    constructor(appObject) {
+        super(appObject, EnvironmentalIntensityPM_1.EnvironmentalIntensityPM.type);
+        this.vmsAreEqual = jest.fn();
+    }
+}
+exports.EnvironmentalIntensityPmMock = EnvironmentalIntensityPmMock;
+function makeEnvironmentalIntensityPmMock(appObjects) {
+    return new EnvironmentalIntensityPmMock(appObjects.getOrCreate("EnvironmentalIntensityPmMock"));
+}
+exports.makeEnvironmentalIntensityPmMock = makeEnvironmentalIntensityPmMock;

package/lib/Components/Environment/Mocks/SetEnvironmentIntensityUcMock.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="jest" />
+import { AppObject, AppObjectRepo } from "../../../AppObject";
+import { SetEnvironmentIntensityUC } from "../UCs/SetEnvironmentIntensityUC";
+export declare class SetEnvironmentIntensityUcMock extends SetEnvironmentIntensityUC {
+    submit: jest.Mock<any, any>;
+    update: jest.Mock<any, any>;
+    constructor(appObject: AppObject);
+}
+export declare function makeSetEnvironmentIntensityUcMock(appObjects: AppObjectRepo): SetEnvironmentIntensityUcMock;

package/lib/Components/Environment/Mocks/SetEnvironmentIntensityUcMock.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeSetEnvironmentIntensityUcMock = exports.SetEnvironmentIntensityUcMock = void 0;
+const SetEnvironmentIntensityUC_1 = require("../UCs/SetEnvironmentIntensityUC");
+class SetEnvironmentIntensityUcMock extends SetEnvironmentIntensityUC_1.SetEnvironmentIntensityUC {
+    constructor(appObject) {
+        super(appObject, SetEnvironmentIntensityUC_1.SetEnvironmentIntensityUC.type);
+        this.submit = jest.fn();
+        this.update = jest.fn();
+    }
+}
+exports.SetEnvironmentIntensityUcMock = SetEnvironmentIntensityUcMock;
+function makeSetEnvironmentIntensityUcMock(appObjects) {
+    return new SetEnvironmentIntensityUcMock(appObjects.getOrCreate("SetEnvironmentIntensityUcMock"));
+}
+exports.makeSetEnvironmentIntensityUcMock = makeSetEnvironmentIntensityUcMock;

package/lib/Components/Environment/Mocks/SetTexturalEnvironmentUcMock.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="jest" />
+import { AppObject, AppObjectRepo } from "../../../AppObject";
+import { SetTexturalEnvironmentUC } from "../UCs/SetTexturalEnvironmentUC";
+export declare class SetTexturalEnvironmentUcMock extends SetTexturalEnvironmentUC {
+    setEnvironment: jest.Mock<any, any>;
+    constructor(appObject: AppObject);
+}
+export declare function makeSetTexturalEnvironmentUcMock(appObjects: AppObjectRepo): SetTexturalEnvironmentUcMock;

package/lib/Components/Environment/Mocks/SetTexturalEnvironmentUcMock.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeSetTexturalEnvironmentUcMock = exports.SetTexturalEnvironmentUcMock = void 0;
+const SetTexturalEnvironmentUC_1 = require("../UCs/SetTexturalEnvironmentUC");
+class SetTexturalEnvironmentUcMock extends SetTexturalEnvironmentUC_1.SetTexturalEnvironmentUC {
+    constructor(appObject) {
+        super(appObject, SetTexturalEnvironmentUC_1.SetTexturalEnvironmentUC.type);
+        this.setEnvironment = jest.fn();
+    }
+}
+exports.SetTexturalEnvironmentUcMock = SetTexturalEnvironmentUcMock;
+function makeSetTexturalEnvironmentUcMock(appObjects) {
+    return new SetTexturalEnvironmentUcMock(appObjects.getOrCreate("SetTexturalEnvironmentUcMock"));
+}
+exports.makeSetTexturalEnvironmentUcMock = makeSetTexturalEnvironmentUcMock;

package/lib/Components/Environment/Mocks/TexturalEnvironmentPmMock.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="jest" />
+import { AppObject, AppObjectRepo } from "../../../AppObject";
+import { TexturalEnvironmentPM } from "../PMs/TexturalEnvironmentPM";
+export declare class TexturalEnvironmentPmMock extends TexturalEnvironmentPM {
+    vmsAreEqual: jest.Mock<any, any>;
+    constructor(appObject: AppObject);
+}
+export declare function makeTexturalEnvironmentPmMock(appObjects: AppObjectRepo): TexturalEnvironmentPmMock;

package/lib/Components/Environment/Mocks/TexturalEnvironmentPmMock.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeTexturalEnvironmentPmMock = exports.TexturalEnvironmentPmMock = void 0;
+const TexturalEnvironmentPM_1 = require("../PMs/TexturalEnvironmentPM");
+class TexturalEnvironmentPmMock extends TexturalEnvironmentPM_1.TexturalEnvironmentPM {
+    constructor(appObject) {
+        super(appObject, TexturalEnvironmentPM_1.TexturalEnvironmentPM.type);
+        this.vmsAreEqual = jest.fn();
+    }
+}
+exports.TexturalEnvironmentPmMock = TexturalEnvironmentPmMock;
+function makeTexturalEnvironmentPmMock(appObjects) {
+    return new TexturalEnvironmentPmMock(appObjects.getOrCreate("TexturalEnvironmentPmMock"));
+}
+exports.makeTexturalEnvironmentPmMock = makeTexturalEnvironmentPmMock;

package/lib/Components/Environment/Mocks/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./EnvironmentalIntensityPmMock";
+export * from "./SetEnvironmentIntensityUcMock";
+export * from "./SetTexturalEnvironmentUcMock";
+export * from "./TexturalEnvironmentPmMock";

package/lib/Components/Environment/Mocks/index.js

@@ -0,0 +1,16 @@
+"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("./EnvironmentalIntensityPmMock"), exports);
+__exportStar(require("./SetEnvironmentIntensityUcMock"), exports);
+__exportStar(require("./SetTexturalEnvironmentUcMock"), exports);
+__exportStar(require("./TexturalEnvironmentPmMock"), exports);

package/lib/Components/Environment/PMs/EnvironmentalIntensityPM.d.ts

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

package/lib/Components/Environment/PMs/EnvironmentalIntensityPM.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeEnvironmentalIntensityPM = exports.EnvironmentalIntensityPM = void 0;
+const AppObject_1 = require("../../../AppObject");
+const Environment_1 = require("../Entities/Environment");
+class EnvironmentalIntensityPM extends AppObject_1.AppObjectPM {
+}
+exports.EnvironmentalIntensityPM = EnvironmentalIntensityPM;
+EnvironmentalIntensityPM.type = "EnvironmentalIntensityPM";
+EnvironmentalIntensityPM.get = (appObjects) => AppObject_1.getSingletonComponent(EnvironmentalIntensityPM.type, appObjects);
+function makeEnvironmentalIntensityPM(appObject) {
+    return new EnvironmentalIntensityPMImp(appObject);
+}
+exports.makeEnvironmentalIntensityPM = makeEnvironmentalIntensityPM;
+class EnvironmentalIntensityPMImp extends EnvironmentalIntensityPM {
+    constructor(appObject) {
+        var _a;
+        super(appObject, EnvironmentalIntensityPM.type);
+        this.onEntityChange = () => {
+            if (!this.entity)
+                return;
+            this.doUpdateView(this.entity.intensity);
+        };
+        (_a = this.entity) === null || _a === void 0 ? void 0 : _a.addChangeObserver(this.onEntityChange);
+        this.onEntityChange();
+        this.appObjects.registerSingleton(this);
+    }
+    vmsAreEqual(a, b) {
+        return a === b;
+    }
+    get entity() {
+        return this.getCachedSingleton(Environment_1.EnvironmentEntity.type);
+    }
+}

package/lib/Components/Environment/PMs/TexturalEnvironmentPM.d.ts

@@ -0,0 +1,7 @@
+import { AppObject, AppObjectPM, AppObjectRepo } from "../../../AppObject";
+import { Environments } from "../Entities/Environment";
+export declare abstract class TexturalEnvironmentPM extends AppObjectPM<Environments> {
+    static type: string;
+    static get: (appObjects: AppObjectRepo) => TexturalEnvironmentPM | undefined;
+}
+export declare function makeTexturalEnvironmentPM(appObject: AppObject): TexturalEnvironmentPM;

package/lib/Components/Environment/PMs/TexturalEnvironmentPM.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeTexturalEnvironmentPM = exports.TexturalEnvironmentPM = void 0;
+const AppObject_1 = require("../../../AppObject");
+const Environment_1 = require("../Entities/Environment");
+class TexturalEnvironmentPM extends AppObject_1.AppObjectPM {
+}
+exports.TexturalEnvironmentPM = TexturalEnvironmentPM;
+TexturalEnvironmentPM.type = "TexturalEnvironmentPM";
+TexturalEnvironmentPM.get = (appObjects) => AppObject_1.getSingletonComponent(TexturalEnvironmentPM.type, appObjects);
+function makeTexturalEnvironmentPM(appObject) {
+    return new TexturalEnvironmentPMImp(appObject);
+}
+exports.makeTexturalEnvironmentPM = makeTexturalEnvironmentPM;
+class TexturalEnvironmentPMImp extends TexturalEnvironmentPM {
+    constructor(appObject) {
+        var _a;
+        super(appObject, TexturalEnvironmentPM.type);
+        this.onEntityChange = () => {
+            if (!this.entity)
+                return;
+            this.doUpdateView(this.entity.currentEnvironment);
+        };
+        (_a = this.entity) === null || _a === void 0 ? void 0 : _a.addChangeObserver(this.onEntityChange);
+        this.onEntityChange();
+        this.appObjects.registerSingleton(this);
+    }
+    vmsAreEqual(a, b) {
+        return a === b;
+    }
+    get entity() {
+        return this.getCachedSingleton(Environment_1.EnvironmentEntity.type);
+    }
+}

package/lib/Components/Environment/PMs/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./EnvironmentalIntensityPM";
+export * from "./TexturalEnvironmentPM";

package/lib/Components/Environment/PMs/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("./EnvironmentalIntensityPM"), exports);
+__exportStar(require("./TexturalEnvironmentPM"), exports);

package/lib/Components/Environment/UCs/SerializeEnvironment.d.ts

@@ -0,0 +1,23 @@
+import { AppObject, AppObjectUC } from "../../../AppObject";
+import { SerializedSystem } from "../../StateMachine";
+import { Environments } from "../Entities/Environment";
+export declare class SerializeEnvironment extends AppObjectUC implements SerializedSystem {
+    static readonly type = "SerializeEnvironment";
+    name: string;
+    seriliziationVersion: number;
+    private get environmentEntity();
+    readonly defaultState: SerializedEnvironmentV2;
+    getSystemState(): SerializedEnvironmentV2 | undefined;
+    applySystemState(state: object, version: number): void;
+    private applyStateV1;
+    private applyStateV2;
+    applyDefaultState(): void;
+    constructor(appObject: AppObject);
+}
+export interface SerializedEnvironmentV1 {
+    environment: Environments;
+}
+export interface SerializedEnvironmentV2 {
+    environment: Environments;
+    intensity: number;
+}

package/lib/Components/Environment/UCs/SerializeEnvironment.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SerializeEnvironment = void 0;
+const AppObject_1 = require("../../../AppObject");
+const StateMachine_1 = require("../../StateMachine");
+const Environment_1 = require("../Entities/Environment");
+class SerializeEnvironment extends AppObject_1.AppObjectUC {
+    constructor(appObject) {
+        super(appObject, SerializeEnvironment.type);
+        this.name = "textural-environment";
+        this.seriliziationVersion = 2;
+        this.defaultState = {
+            environment: Environment_1.Environments.STUDIO,
+            intensity: 0.75,
+        };
+        const stateMachine = StateMachine_1.StateMachineEntity.get(appObject.appObjectRepo);
+        if (stateMachine) {
+            stateMachine.registerSerializedSystem(this);
+        }
+        else {
+            this.warn("Unable to find StateMachineEntity");
+        }
+    }
+    get environmentEntity() {
+        return this.getCachedSingleton(Environment_1.EnvironmentEntity.type);
+    }
+    getSystemState() {
+        if (!this.environmentEntity)
+            return;
+        const state = {
+            environment: this.environmentEntity.currentEnvironment,
+            intensity: this.environmentEntity.intensity,
+        };
+        return state;
+    }
+    applySystemState(state, version) {
+        if (version === 1) {
+            this.applyStateV1(state);
+        }
+        else if (version === 2) {
+            this.applyStateV2(state);
+        }
+        else {
+            this.applyDefaultState();
+        }
+    }
+    applyStateV1(state) {
+        if (!this.environmentEntity)
+            return;
+        if (state.environment === undefined) {
+            this.applyDefaultState();
+        }
+        this.environmentEntity.currentEnvironment = state.environment;
+        this.environmentEntity.intensity = this.defaultState.intensity;
+    }
+    applyStateV2(state) {
+        if (!this.environmentEntity)
+            return;
+        if (state.environment === undefined || state.intensity === undefined) {
+            this.applyDefaultState();
+        }
+        this.environmentEntity.currentEnvironment = state.environment;
+        this.environmentEntity.intensity = state.intensity;
+    }
+    applyDefaultState() {
+        if (!this.environmentEntity)
+            return;
+        this.environmentEntity.currentEnvironment = this.defaultState.environment;
+        this.environmentEntity.intensity = this.defaultState.intensity;
+    }
+}
+exports.SerializeEnvironment = SerializeEnvironment;
+SerializeEnvironment.type = "SerializeEnvironment";

package/lib/Components/Environment/UCs/SetEnvironmentIntensityUC.d.ts

@@ -0,0 +1,8 @@
+import { AppObject, AppObjectRepo, AppObjectUC } from "../../../AppObject";
+export declare abstract class SetEnvironmentIntensityUC extends AppObjectUC {
+    static readonly type = "SetEnvironmentIntensityUC";
+    abstract update(intensity: number): void;
+    abstract submit(): void;
+    static get(appObjects: AppObjectRepo): SetEnvironmentIntensityUC | undefined;
+}
+export declare function makeSetEnvironmentIntensityUC(appObject: AppObject): SetEnvironmentIntensityUC;

package/lib/Components/Environment/UCs/SetEnvironmentIntensityUC.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeSetEnvironmentIntensityUC = exports.SetEnvironmentIntensityUC = void 0;
+const AppObject_1 = require("../../../AppObject");
+const Dispatcher_1 = require("../../Dispatcher");
+const UndoRedo_1 = require("../../UndoRedo");
+const Environment_1 = require("../Entities/Environment");
+class SetEnvironmentIntensityUC extends AppObject_1.AppObjectUC {
+    static get(appObjects) {
+        return AppObject_1.getSingletonComponent(SetEnvironmentIntensityUC.type, appObjects);
+    }
+}
+exports.SetEnvironmentIntensityUC = SetEnvironmentIntensityUC;
+SetEnvironmentIntensityUC.type = "SetEnvironmentIntensityUC";
+function makeSetEnvironmentIntensityUC(appObject) {
+    return new SetEnvironmentIntensityUCImp(appObject);
+}
+exports.makeSetEnvironmentIntensityUC = makeSetEnvironmentIntensityUC;
+class SetEnvironmentIntensityUCImp extends SetEnvironmentIntensityUC {
+    constructor(appObject) {
+        super(appObject, SetEnvironmentIntensityUC.type);
+        this.update = (val) => {
+            if (!this.environment)
+                return;
+            if (!this.initialIntensity) {
+                this.initialIntensity = this.environment.intensity;
+            }
+            this.environment.intensity = val;
+        };
+        this.appObjects.registerSingleton(this);
+    }
+    get environment() {
+        return this.getCachedSingleton(Environment_1.EnvironmentEntity.type);
+    }
+    get undo() {
+        return this.getCachedSingleton(UndoRedo_1.UndoRedoEntity.type);
+    }
+    get dispatchStateChange() {
+        var _a;
+        return (_a = this.getCachedSingleton(Dispatcher_1.DispatchStateChangeUC.type)) === null || _a === void 0 ? void 0 : _a.doDispatch;
+    }
+    submit() {
+        var _a;
+        if (!this.initialIntensity)
+            return;
+        const dispatchStateChange = this.dispatchStateChange;
+        const environment = this.environment;
+        if (!environment || !dispatchStateChange) {
+            this.error("Missing component");
+            return;
+        }
+        const undoIntensity = this.initialIntensity;
+        const redoIntensity = environment.intensity;
+        if (undoIntensity === redoIntensity)
+            return;
+        (_a = this.undo) === null || _a === void 0 ? void 0 : _a.submitAction({
+            undoAction: () => {
+                environment.intensity = undoIntensity;
+                dispatchStateChange();
+            },
+            redoAction: () => {
+                environment.intensity = redoIntensity;
+                dispatchStateChange();
+            },
+        });
+        dispatchStateChange();
+        this.initialIntensity = undefined;
+    }
+}

package/lib/Components/Environment/UCs/SetTexturalEnvironmentUC.d.ts

@@ -0,0 +1,8 @@
+import { AppObject, AppObjectRepo, AppObjectUC } from "../../../AppObject";
+import { Environments } from "../Entities/Environment";
+export declare abstract class SetTexturalEnvironmentUC extends AppObjectUC {
+    static readonly type = "SetTexturalEnvironmentUC";
+    abstract setEnvironment(env: Environments): void;
+    static get(appObjects: AppObjectRepo): SetTexturalEnvironmentUC | undefined;
+}
+export declare function makeSetTexturalEnvironmentUC(appObject: AppObject): SetTexturalEnvironmentUC;

package/lib/Components/Environment/UCs/SetTexturalEnvironmentUC.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeSetTexturalEnvironmentUC = exports.SetTexturalEnvironmentUC = void 0;
+const AppObject_1 = require("../../../AppObject");
+const Dispatcher_1 = require("../../Dispatcher");
+const UndoRedo_1 = require("../../UndoRedo");
+const Environment_1 = require("../Entities/Environment");
+class SetTexturalEnvironmentUC extends AppObject_1.AppObjectUC {
+    static get(appObjects) {
+        return AppObject_1.getSingletonComponent(SetTexturalEnvironmentUC.type, appObjects);
+    }
+}
+exports.SetTexturalEnvironmentUC = SetTexturalEnvironmentUC;
+SetTexturalEnvironmentUC.type = "SetTexturalEnvironmentUC";
+function makeSetTexturalEnvironmentUC(appObject) {
+    return new SetTexturalEnvironmentUCImp(appObject);
+}
+exports.makeSetTexturalEnvironmentUC = makeSetTexturalEnvironmentUC;
+class SetTexturalEnvironmentUCImp extends SetTexturalEnvironmentUC {
+    constructor(appObject) {
+        super(appObject, SetTexturalEnvironmentUC.type);
+        this.setEnvironment = (env) => {
+            var _a;
+            const dispatchStateChange = this.dispatchStateChange;
+            const environment = this.environment;
+            if (!environment || !dispatchStateChange) {
+                this.error("Missing component");
+                return;
+            }
+            if (environment.currentEnvironment === env)
+                return;
+            const previousEnv = environment.currentEnvironment;
+            environment.currentEnvironment = env;
+            (_a = this.undo) === null || _a === void 0 ? void 0 : _a.submitAction({
+                undoAction: () => {
+                    environment.currentEnvironment = previousEnv;
+                    dispatchStateChange();
+                },
+                redoAction: () => {
+                    environment.currentEnvironment = env;
+                    dispatchStateChange();
+                },
+            });
+            dispatchStateChange();
+        };
+        this.appObjects.registerSingleton(this);
+    }
+    get environment() {
+        return this.getCachedSingleton(Environment_1.EnvironmentEntity.type);
+    }
+    get undo() {
+        return this.getCachedSingleton(UndoRedo_1.UndoRedoEntity.type);
+    }
+    get dispatchStateChange() {
+        var _a;
+        return (_a = this.getCachedSingleton(Dispatcher_1.DispatchStateChangeUC.type)) === null || _a === void 0 ? void 0 : _a.doDispatch;
+    }
+}

package/lib/Components/Environment/UCs/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./SerializeEnvironment";
+export * from "./SetEnvironmentIntensityUC";
+export * from "./SetTexturalEnvironmentUC";

package/lib/Components/Environment/UCs/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("./SerializeEnvironment"), exports);
+__exportStar(require("./SetEnvironmentIntensityUC"), exports);
+__exportStar(require("./SetTexturalEnvironmentUC"), exports);

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

@@ -0,0 +1,7 @@
+export * from "./Adapters";
+export * from "./Controllers";
+export * from "./Entities";
+export * from "./Factories";
+export * from "./Mocks";
+export * from "./PMs";
+export * from "./UCs";

package/lib/Components/Environment/index.js

@@ -0,0 +1,19 @@
+"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("./Adapters"), exports);
+__exportStar(require("./Controllers"), exports);
+__exportStar(require("./Entities"), exports);
+__exportStar(require("./Factories"), exports);
+__exportStar(require("./Mocks"), exports);
+__exportStar(require("./PMs"), exports);
+__exportStar(require("./UCs"), exports);

package/lib/Components/Stick/Adapters/index.d.ts

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

package/lib/Components/Stick/Adapters/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("./stickTargetAdapter"), exports);

package/lib/Components/Stick/Adapters/stickTargetAdapter.d.ts

@@ -0,0 +1,3 @@
+import { PmAdapter } from "../../../Types";
+import { StickTargetVM } from "../PMs/StickTargetPM";
+export declare const stickTargetAdapter: PmAdapter<StickTargetVM>;

package/lib/Components/Stick/Adapters/stickTargetAdapter.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stickTargetAdapter = void 0;
+const StickTargetPM_1 = require("../PMs/StickTargetPM");
+exports.stickTargetAdapter = {
+    defaultVM: StickTargetPM_1.defaultStickTargetVM,
+    subscribe: (id, appObjects, setVM) => {
+        if (!id)
+            return;
+        const pm = StickTargetPM_1.StickTargetPM.get(id, appObjects);
+        if (!pm) {
+            appObjects.submitError("stickTargetAdapter", "Unable to find StickTargetPM");
+            return;
+        }
+        pm.addView(setVM);
+    },
+    unsubscribe: (id, appObjects, setVM) => {
+        const pm = StickTargetPM_1.StickTargetPM.get(id, appObjects);
+        if (pm) {
+            pm.removeView(setVM);
+        }
+    }
+};

package/lib/Components/Stick/Controllers/DoubleClickToStickMC.d.ts

@@ -0,0 +1,15 @@
+import { AppObject, AppObjectController } from "../../../AppObject";
+import { MouseController, MouseInputEvent } from "../../MouseInput";
+export declare class DoubleClickToStickMC extends AppObjectController implements MouseController {
+    static type: string;
+    readonly maxClickTimeMS = 300;
+    readonly maxClickDistancePx = 5;
+    private initialClickPos;
+    private initialClickTime;
+    private clickCount;
+    private get mouseInput();
+    private get tryStickSceneMesh();
+    onClick: (e: MouseInputEvent) => void;
+    private cancelDoubleClick;
+    constructor(appObject: AppObject);
+}