@vived/app 3.9.1 → 4.0.0

package/lib/Components/Question/UC/SubmitQuestionAnswerUC.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeSubmitQuestionAnswerUC = exports.SubmitQuestionAnswerUC = void 0;
+const AppObject_1 = require("../../../AppObject");
+const AppObjectUC_1 = require("../../../AppObject/AppObjectUC");
+const App_1 = require("../../App");
+const Dispatcher_1 = require("../../Dispatcher");
+const Entities_1 = require("../Entities");
+class SubmitQuestionAnswerUC extends AppObjectUC_1.AppObjectUC {
+}
+exports.SubmitQuestionAnswerUC = SubmitQuestionAnswerUC;
+SubmitQuestionAnswerUC.type = "SubmitQuestionAnswerUC";
+SubmitQuestionAnswerUC.get = (appObjects) => AppObject_1.getSingletonComponent(SubmitQuestionAnswerUC.type, appObjects);
+function makeSubmitQuestionAnswerUC(appObject) {
+    return new SubmitQuestionAnswerUCImp(appObject);
+}
+exports.makeSubmitQuestionAnswerUC = makeSubmitQuestionAnswerUC;
+class SubmitQuestionAnswerUCImp extends SubmitQuestionAnswerUC {
+    constructor(appObject) {
+        super(appObject, SubmitQuestionAnswerUC.type);
+        this.questionEntity = appObject.getComponent(Entities_1.QuestionEntity.type);
+        if (!this.questionEntity) {
+            this.warn("SubmitQuestionAnswerUCImp has been added to an app object that does not have QuestionEntity");
+        }
+    }
+    submitAnswer(id) {
+        if (!this.questionEntity)
+            return;
+        if (!this.questionEntity.hasAnswer(id)) {
+            this.warn("Unable to find answer by ID");
+            return;
+        }
+        const baseApp = App_1.BaseAppState.get(this.appObject.appObjectRepo);
+        if (!baseApp) {
+            this.warn("Unable to find Base App");
+            return;
+        }
+        if (baseApp.isAuthoring)
+            return;
+        this.questionEntity.submitAnswer(id);
+        const submitResult = Dispatcher_1.SubmitResultResultUC.get(this.appObject.appObjectRepo);
+        if (submitResult) {
+            submitResult.submitHitResult({
+                success: this.questionEntity.gotItRight,
+                description: baseApp.slideText,
+            });
+        }
+        baseApp.isReviewing = true;
+    }
+}

package/lib/Components/Question/UC/ToggleIsCorrectUndoRedo.d.ts

@@ -0,0 +1,10 @@
+import { AppObjectRepo } from "../../../AppObject/AppObjectRepo";
+import { UndoRedoAction } from "../../UndoRedo/Entities/UndoRedoEntity";
+export declare class ToggleIsCorrectUndoRedo implements UndoRedoAction {
+    private answerID;
+    private dispatchStateChange?;
+    private questionEntity?;
+    undoAction: () => void;
+    redoAction: () => void;
+    constructor(answerID: string, appObjects: AppObjectRepo);
+}

package/lib/Components/Question/UC/ToggleIsCorrectUndoRedo.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToggleIsCorrectUndoRedo = void 0;
+const DispatchStateChangeUC_1 = require("../../Dispatcher/UC/DispatchStateChangeUC");
+const UndoRedoEntity_1 = require("../../UndoRedo/Entities/UndoRedoEntity");
+const Entities_1 = require("../Entities");
+class ToggleIsCorrectUndoRedo {
+    constructor(answerID, appObjects) {
+        this.answerID = answerID;
+        this.undoAction = () => {
+            if (!this.questionEntity || !this.dispatchStateChange)
+                return;
+            const answer = this.questionEntity.getAnswer(this.answerID);
+            if (!answer)
+                return;
+            answer.isCorrect = !answer.isCorrect;
+            this.dispatchStateChange.doDispatch();
+        };
+        this.redoAction = () => {
+            if (!this.questionEntity || !this.dispatchStateChange)
+                return;
+            const answer = this.questionEntity.getAnswer(this.answerID);
+            if (!answer)
+                return;
+            answer.isCorrect = !answer.isCorrect;
+            this.dispatchStateChange.doDispatch();
+        };
+        this.questionEntity = Entities_1.QuestionEntity.get(appObjects);
+        if (!this.questionEntity) {
+            appObjects.submitWarning("DeleteAnswerUndoRedo", "Unable to find QuestionEntity");
+            return;
+        }
+        this.dispatchStateChange = DispatchStateChangeUC_1.DispatchStateChangeUC.get(appObjects);
+        if (!this.dispatchStateChange) {
+            appObjects.submitWarning("DeleteAnswerUndoRedo", "Unable to find DispatchStateChangeUC");
+            return;
+        }
+        const undoRedo = UndoRedoEntity_1.UndoRedoEntity.get(appObjects);
+        if (!undoRedo) {
+            appObjects.submitWarning("DeleteAnswerUndoRedo", "Unable to find UndoRedoEntity");
+            return;
+        }
+        undoRedo.submitAction(this);
+    }
+}
+exports.ToggleIsCorrectUndoRedo = ToggleIsCorrectUndoRedo;

package/lib/Components/Question/UC/ToggleQuestionAnswerIsCorrect.d.ts

@@ -0,0 +1,7 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectUC } from "../../../AppObject/AppObjectUC";
+export declare abstract class ToggleQuestionChallengeAnswerIsCorrectUC extends AppObjectUC {
+    static readonly type = "ToggleQuestionChallengeAnswerIsCorrect";
+    abstract toggleIsCorrect(): void;
+}
+export declare function makeToggleQuestionChallengeAnswerIsCorrectUC(appObject: AppObject): ToggleQuestionChallengeAnswerIsCorrectUC;

package/lib/Components/Question/UC/ToggleQuestionAnswerIsCorrect.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeToggleQuestionChallengeAnswerIsCorrectUC = exports.ToggleQuestionChallengeAnswerIsCorrectUC = void 0;
+const AppObjectUC_1 = require("../../../AppObject/AppObjectUC");
+const Dispatcher_1 = require("../../Dispatcher");
+const QuestionAnswerEntity_1 = require("../Entities/QuestionAnswerEntity");
+const ToggleIsCorrectUndoRedo_1 = require("./ToggleIsCorrectUndoRedo");
+class ToggleQuestionChallengeAnswerIsCorrectUC extends AppObjectUC_1.AppObjectUC {
+}
+exports.ToggleQuestionChallengeAnswerIsCorrectUC = ToggleQuestionChallengeAnswerIsCorrectUC;
+ToggleQuestionChallengeAnswerIsCorrectUC.type = "ToggleQuestionChallengeAnswerIsCorrect";
+function makeToggleQuestionChallengeAnswerIsCorrectUC(appObject) {
+    return new ToggleQuestionChallengeAnswerIsCorrectImp(appObject);
+}
+exports.makeToggleQuestionChallengeAnswerIsCorrectUC = makeToggleQuestionChallengeAnswerIsCorrectUC;
+class ToggleQuestionChallengeAnswerIsCorrectImp extends ToggleQuestionChallengeAnswerIsCorrectUC {
+    constructor(appObject) {
+        super(appObject, ToggleQuestionChallengeAnswerIsCorrectUC.type);
+        this.answer = appObject.getComponent(QuestionAnswerEntity_1.QuestionAnswerEntity.type);
+        if (!this.answer) {
+            this.warn("ToggleQuestionChallengeAnswerIsCorrectUC has been added to an app object that does not have QuestionAnswerEntity");
+        }
+    }
+    toggleIsCorrect() {
+        var _a;
+        if (!this.answer)
+            return;
+        this.answer.isCorrect = !this.answer.isCorrect;
+        (_a = Dispatcher_1.DispatchStateChangeUC.get(this.appObject.appObjectRepo)) === null || _a === void 0 ? void 0 : _a.doDispatch();
+        new ToggleIsCorrectUndoRedo_1.ToggleIsCorrectUndoRedo(this.answer.id, this.appObject.appObjectRepo);
+    }
+}

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

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

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

package/lib/Components/RequestHandler/Entities/AppHandler.d.ts

@@ -0,0 +1,20 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectEntity } from "../../../AppObject/AppObjectEntity";
+import { Handler } from "../../../Types/AppBoundary";
+export interface RequestHandler {
+    readonly requestType: string;
+    payloadVersion: number;
+    handleRequest: (version: number, payload?: unknown) => void;
+}
+export declare abstract class AppHandlerEntity extends AppObjectEntity {
+    static readonly type = "APP_HANDLER_ENTITY";
+    abstract handler: Handler;
+    abstract registerRequestHandler: (requestHandler: RequestHandler) => void;
+}
+export declare function makeAppHandler(appObject: AppObject): AppHandlerEntity;
+export declare class UnsupportedRequestVersion extends Error {
+    constructor(requestType: string, version: number);
+}
+export declare class UnableToParsePayload extends Error {
+    constructor(requestType: string, version: number, payload: string);
+}

package/lib/Components/RequestHandler/Entities/AppHandler.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnableToParsePayload = exports.UnsupportedRequestVersion = exports.makeAppHandler = exports.AppHandlerEntity = void 0;
+const AppObjectEntity_1 = require("../../../AppObject/AppObjectEntity");
+class AppHandlerEntity extends AppObjectEntity_1.AppObjectEntity {
+}
+exports.AppHandlerEntity = AppHandlerEntity;
+AppHandlerEntity.type = "APP_HANDLER_ENTITY";
+function makeAppHandler(appObject) {
+    return new RequestHandlerImp(appObject);
+}
+exports.makeAppHandler = makeAppHandler;
+class RequestHandlerImp extends AppHandlerEntity {
+    constructor(appObject) {
+        super(appObject, AppHandlerEntity.type);
+        this.handlers = new Map();
+        this.getAppPayloadRequest = "GET_APP_PAYLOAD_VERSION";
+        this.getAppHandlerVersionRequest = "GET_APP_HANDLER_VERSION";
+        this.appHandlerVersion = 1;
+        this.handler = (request) => {
+            if (request.type === this.getAppPayloadRequest) {
+                this.handlePayloadVersionRequest(request);
+                return;
+            }
+            if (request.type === this.getAppHandlerVersionRequest) {
+                this.handleAppHandlerVersionRequest(request);
+                return;
+            }
+            const handler = this.handlers.get(request.type);
+            if (!handler) {
+                console.warn(`[AppHandler] Unsupported request type received: ${request.type}`);
+                return;
+            }
+            try {
+                handler.handleRequest(request.version, request.payload);
+            }
+            catch (e) {
+                console.warn(`[AppHandler] ${e}`);
+            }
+        };
+        this.registerRequestHandler = (handler) => {
+            if (this.handlers.has(handler.requestType)) {
+                console.warn(`[AppHandler] More than one handler is being registered for ${handler.requestType}. Previous handler is being overwritten`);
+            }
+            this.handlers.set(handler.requestType, handler);
+        };
+    }
+    handlePayloadVersionRequest(request) {
+        if (request.version !== 2) {
+            throw new UnsupportedRequestVersion(request.type, request.version);
+        }
+        const payload = request.payload;
+        if (payload.callback === undefined) {
+            throw new UnableToParsePayload(request.type, request.version, JSON.stringify(payload));
+        }
+        const versionMap = new Map();
+        this.handlers.forEach((handler) => {
+            versionMap.set(handler.requestType, handler.payloadVersion);
+        });
+        payload.callback(versionMap);
+    }
+    handleAppHandlerVersionRequest(request) {
+        if (request.version !== 1) {
+            throw new UnsupportedRequestVersion(request.type, request.version);
+        }
+        const payload = request.payload;
+        if (payload.callback === undefined) {
+            throw new UnableToParsePayload(request.type, request.version, JSON.stringify(payload));
+        }
+        payload.callback(this.appHandlerVersion);
+    }
+}
+class UnsupportedRequestVersion extends Error {
+    constructor(requestType, version) {
+        const msg = `Version ${version} of request type ${requestType} is not supported`;
+        super(msg);
+    }
+}
+exports.UnsupportedRequestVersion = UnsupportedRequestVersion;
+class UnableToParsePayload extends Error {
+    constructor(requestType, version, payload) {
+        const msg = `Unable to parse payload for version ${version} of request type ${requestType}: ${payload}`;
+        super(msg);
+    }
+}
+exports.UnableToParsePayload = UnableToParsePayload;

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

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

package/lib/Components/RequestHandler/Entities/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("./AppHandler"), exports);

package/lib/Components/RequestHandler/Mocks/MockAppHandlerEntity.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="jest" />
+import { AppObject } from "../../../AppObject";
+import { AppHandlerEntity } from "../Entities";
+export declare class MockAppHandlerEntity extends AppHandlerEntity {
+    handler: jest.Mock<any, any>;
+    registerRequestHandler: jest.Mock<any, any>;
+    constructor(appObject: AppObject);
+}

package/lib/Components/RequestHandler/Mocks/MockAppHandlerEntity.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockAppHandlerEntity = void 0;
+const Entities_1 = require("../Entities");
+class MockAppHandlerEntity extends Entities_1.AppHandlerEntity {
+    constructor(appObject) {
+        super(appObject, Entities_1.AppHandlerEntity.type);
+        this.handler = jest.fn();
+        this.registerRequestHandler = jest.fn();
+    }
+}
+exports.MockAppHandlerEntity = MockAppHandlerEntity;

package/lib/Components/RequestHandler/UC/DisposeAppUC.d.ts

@@ -0,0 +1,11 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectUC } from "../../../AppObject/AppObjectUC";
+import { RequestHandler } from "../Entities";
+export declare abstract class DisposeAppBaseUC extends AppObjectUC implements RequestHandler {
+    static readonly type = "DisposeAppBaseUC";
+    readonly requestType = "DISPOSE_APP";
+    readonly payloadVersion = 1;
+    abstract action: () => void;
+    abstract handleRequest: (version: number, payload?: unknown) => void;
+}
+export declare function makeDisposeAppUC(appObject: AppObject): DisposeAppBaseUC;

package/lib/Components/RequestHandler/UC/DisposeAppUC.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeDisposeAppUC = exports.DisposeAppBaseUC = void 0;
+const AppObjectUC_1 = require("../../../AppObject/AppObjectUC");
+const Entities_1 = require("../Entities");
+class DisposeAppBaseUC extends AppObjectUC_1.AppObjectUC {
+    constructor() {
+        super(...arguments);
+        this.requestType = "DISPOSE_APP";
+        this.payloadVersion = 1;
+    }
+}
+exports.DisposeAppBaseUC = DisposeAppBaseUC;
+DisposeAppBaseUC.type = "DisposeAppBaseUC";
+function makeDisposeAppUC(appObject) {
+    return new DisposeAppBaseUCImp(appObject);
+}
+exports.makeDisposeAppUC = makeDisposeAppUC;
+class DisposeAppBaseUCImp extends DisposeAppBaseUC {
+    constructor(appObject) {
+        super(appObject, DisposeAppBaseUC.type);
+        this.action = () => {
+            // inject if needed
+        };
+        this.handleRequest = (version) => {
+            if (version === this.payloadVersion) {
+                this.action();
+            }
+            else {
+                throw new Entities_1.UnsupportedRequestVersion(this.requestType, version);
+            }
+        };
+        const handler = appObject.getComponent(Entities_1.AppHandlerEntity.type);
+        if (!handler) {
+            this.warn("DisposeAppBaseUC has been added to an app object that does not have an AppHandlerEntity. Add one first");
+            return;
+        }
+        handler.registerRequestHandler(this);
+    }
+}

package/lib/Components/RequestHandler/UC/SetAppStateUC.d.ts

@@ -0,0 +1,12 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectUC } from "../../../AppObject/AppObjectUC";
+import { RequestHandler } from "../Entities";
+export declare type SetAppStateAction = (finalState: string, duration?: number) => void;
+export declare abstract class SetAppStateBaseUC extends AppObjectUC implements RequestHandler {
+    static readonly type = "SetAppStateBaseUC";
+    readonly requestType = "SET_APP_STATE";
+    readonly payloadVersion = 2;
+    abstract action: SetAppStateAction;
+    abstract handleRequest: (version: number, payload?: unknown) => void;
+}
+export declare function makeSetAppStateUC(appObject: AppObject): SetAppStateBaseUC;

package/lib/Components/RequestHandler/UC/SetAppStateUC.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeSetAppStateUC = exports.SetAppStateBaseUC = void 0;
+const AppObjectUC_1 = require("../../../AppObject/AppObjectUC");
+const App_1 = require("../../App");
+const Dispatcher_1 = require("../../Dispatcher");
+const StateMachine_1 = require("../../StateMachine");
+const UndoRedo_1 = require("../../UndoRedo");
+const Entities_1 = require("../Entities");
+class SetAppStateBaseUC extends AppObjectUC_1.AppObjectUC {
+    constructor() {
+        super(...arguments);
+        this.requestType = "SET_APP_STATE";
+        this.payloadVersion = 2;
+    }
+}
+exports.SetAppStateBaseUC = SetAppStateBaseUC;
+SetAppStateBaseUC.type = "SetAppStateBaseUC";
+function makeSetAppStateUC(appObject) {
+    return new SetAppStateBaseUCImp(appObject);
+}
+exports.makeSetAppStateUC = makeSetAppStateUC;
+class SetAppStateBaseUCImp extends SetAppStateBaseUC {
+    constructor(appObject) {
+        super(appObject, SetAppStateBaseUC.type);
+        this.action = (finalState, duration) => {
+            var _a, _b;
+            const appObjects = this.appObject.appObjectRepo;
+            const baseApp = App_1.BaseAppState.get(appObjects);
+            if (!baseApp) {
+                this.warn("Unable to find BaseAppState");
+                return;
+            }
+            const stateMachine = StateMachine_1.StateMachineEntity.get(appObjects);
+            if (!stateMachine) {
+                this.warn("Unable to find AppState");
+                return;
+            }
+            stateMachine.applySerializedStatesString(finalState, duration);
+            baseApp.isReviewing = false;
+            UndoRedo_1.clearUndoStack(appObjects);
+            (_a = Dispatcher_1.HasNextStateUC.get(appObjects)) === null || _a === void 0 ? void 0 : _a.doDispatch().then((hasNextState) => (baseApp.hasNextState = hasNextState));
+            (_b = Dispatcher_1.HasPreviousStateUC.get(appObjects)) === null || _b === void 0 ? void 0 : _b.doDispatch().then((hasPreviousState) => (baseApp.hasPreviousState = hasPreviousState));
+        };
+        this.handleRequest = (version, payload) => {
+            if (version === this.payloadVersion) {
+                const { finalState, duration } = this.castPayload(payload);
+                this.action(finalState, duration);
+            }
+            else {
+                throw new Entities_1.UnsupportedRequestVersion(this.requestType, version);
+            }
+        };
+        const handler = appObject.getComponent(Entities_1.AppHandlerEntity.type);
+        if (!handler) {
+            this.warn("SetAppStateBaseUC has been added to an app object that does not have an AppHandlerEntity. Add one first");
+            return;
+        }
+        handler.registerRequestHandler(this);
+    }
+    castPayload(payload) {
+        const castPayload = payload;
+        if (castPayload.finalState === undefined) {
+            throw new Entities_1.UnableToParsePayload(this.requestType, 1, JSON.stringify(payload));
+        }
+        return castPayload;
+    }
+}

package/lib/Components/RequestHandler/UC/SetIsAuthoringUC.d.ts

@@ -0,0 +1,12 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectUC } from "../../../AppObject/AppObjectUC";
+import { RequestHandler } from "../Entities";
+export declare type SetIsAuthoringAction = (isAuthoring: boolean) => void;
+export declare abstract class SetIsAuthoringUC extends AppObjectUC implements RequestHandler {
+    static readonly type = "SetIsAuthoringBaseUC";
+    readonly requestType = "SET_IS_AUTHORING";
+    readonly payloadVersion = 1;
+    abstract action: SetIsAuthoringAction;
+    abstract handleRequest: (version: number, payload?: unknown) => void;
+}
+export declare function makeSetIsAuthoringUC(appObject: AppObject): SetIsAuthoringUC;

package/lib/Components/RequestHandler/UC/SetIsAuthoringUC.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeSetIsAuthoringUC = exports.SetIsAuthoringUC = void 0;
+const AppObjectUC_1 = require("../../../AppObject/AppObjectUC");
+const App_1 = require("../../App");
+const Entities_1 = require("../Entities");
+class SetIsAuthoringUC extends AppObjectUC_1.AppObjectUC {
+    constructor() {
+        super(...arguments);
+        this.requestType = "SET_IS_AUTHORING";
+        this.payloadVersion = 1;
+    }
+}
+exports.SetIsAuthoringUC = SetIsAuthoringUC;
+SetIsAuthoringUC.type = "SetIsAuthoringBaseUC";
+function makeSetIsAuthoringUC(appObject) {
+    return new SetIsAuthoringUCImp(appObject);
+}
+exports.makeSetIsAuthoringUC = makeSetIsAuthoringUC;
+class SetIsAuthoringUCImp extends SetIsAuthoringUC {
+    constructor(appObject) {
+        super(appObject, SetIsAuthoringUC.type);
+        this.action = (isAuthoring) => {
+            const appObjects = this.appObject.appObjectRepo;
+            const baseApp = App_1.BaseAppState.get(appObjects);
+            if (!baseApp) {
+                this.warn("Unable to find BaseAppState");
+                return;
+            }
+            baseApp.isAuthoring = isAuthoring;
+        };
+        this.handleRequest = (version, payload) => {
+            if (version === this.payloadVersion) {
+                const { isAuthoring: setIsAuthoring } = this.castPayloadV1(payload);
+                this.action(setIsAuthoring);
+            }
+            else {
+                throw new Entities_1.UnsupportedRequestVersion(this.requestType, version);
+            }
+        };
+        const handler = appObject.getComponent(Entities_1.AppHandlerEntity.type);
+        if (!handler) {
+            this.warn("SetIsAuthoringBaseUC has been added to an app object that does not have an AppHandlerEntity. Add one first");
+            return;
+        }
+        handler.registerRequestHandler(this);
+    }
+    castPayloadV1(payload) {
+        const castPayload = payload;
+        if (castPayload.isAuthoring === undefined) {
+            throw new Entities_1.UnableToParsePayload(this.requestType, 1, JSON.stringify(payload));
+        }
+        return castPayload;
+    }
+}

package/lib/Components/RequestHandler/UC/SetThemeColorUC.d.ts

@@ -0,0 +1,14 @@
+import { AppObject, AppObjectUC } from "../../../AppObject/";
+import { RequestHandler } from "../Entities";
+export interface SetThemeColorsDTO {
+    colors: object;
+}
+export declare type SetThemeColorsAction = (colors: SetThemeColorsDTO) => void;
+export declare abstract class SetThemeColorUC extends AppObjectUC implements RequestHandler {
+    static readonly type = "SetThemeColorsBaseUC";
+    readonly requestType = "SET_THEME_COLORS";
+    readonly payloadVersion = 1;
+    abstract action: SetThemeColorsAction;
+    abstract handleRequest: (version: number, payload?: unknown) => void;
+}
+export declare function makeSetThemeColorUC(appObject: AppObject): SetThemeColorUC;

package/lib/Components/RequestHandler/UC/SetThemeColorUC.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeSetThemeColorUC = exports.SetThemeColorUC = void 0;
+const AppObject_1 = require("../../../AppObject/");
+const ThemeColors_1 = require("../../ThemeColors");
+const Entities_1 = require("../Entities");
+class SetThemeColorUC extends AppObject_1.AppObjectUC {
+    constructor() {
+        super(...arguments);
+        this.requestType = "SET_THEME_COLORS";
+        this.payloadVersion = 1;
+    }
+}
+exports.SetThemeColorUC = SetThemeColorUC;
+SetThemeColorUC.type = "SetThemeColorsBaseUC";
+function makeSetThemeColorUC(appObject) {
+    return new SetThemeColorUCImp(appObject);
+}
+exports.makeSetThemeColorUC = makeSetThemeColorUC;
+class SetThemeColorUCImp extends SetThemeColorUC {
+    constructor(appObject) {
+        super(appObject, SetThemeColorUC.type);
+        this.action = (payload) => {
+            const { colors } = payload;
+            const themeColors = ThemeColors_1.ThemeColors.get(this.appObject.appObjectRepo);
+            if (!themeColors) {
+                return;
+            }
+            Object.keys(colors).forEach((schemeType) => {
+                const type = schemeType;
+                const hex = colors[schemeType];
+                themeColors.setColorHexForType(type, hex);
+            });
+        };
+        this.handleRequest = (version, payload) => {
+            if (version === 1) {
+                const castPayload = this.castPayloadV1(payload);
+                this.action(castPayload);
+            }
+            else {
+                throw new Entities_1.UnsupportedRequestVersion(this.requestType, version);
+            }
+        };
+        const handler = appObject.getComponent(Entities_1.AppHandlerEntity.type);
+        if (!handler) {
+            this.warn("SetThemeColorsBaseUC has been added to an app object that does not have an AppHandlerEntity. Add one first");
+            return;
+        }
+        handler.registerRequestHandler(this);
+    }
+    castPayloadV1(payload) {
+        const castPayload = payload;
+        if (castPayload.colors === undefined) {
+            throw new Entities_1.UnableToParsePayload(this.requestType, 1, JSON.stringify(payload));
+        }
+        return castPayload;
+    }
+}

package/lib/Components/RequestHandler/UC/ShowBabylonInspectorUC.d.ts

@@ -0,0 +1,12 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectUC } from "../../../AppObject/AppObjectUC";
+import { RequestHandler } from "../Entities";
+export declare type ShowBabylonInspectorAction = (show: boolean) => void;
+export declare abstract class ShowBabylonInspectorUC extends AppObjectUC implements RequestHandler {
+    static readonly type = "ShowBabylonInspectorBaseUC";
+    readonly requestType = "SHOW_BABYLON_INSPECTOR";
+    readonly payloadVersion = 1;
+    abstract action: ShowBabylonInspectorAction;
+    abstract handleRequest: (version: number, payload?: unknown) => void;
+}
+export declare function makeShowBabylonInspectorUC(appObject: AppObject): ShowBabylonInspectorUC;