@vived/app 4.14.1 → 4.15.1

package/lib/AppObject/AppObjectComponent.d.ts

@@ -4,8 +4,9 @@ export declare class AppObjectComponent {
     readonly type: string;
     readonly appObject: AppObject;
     get appObjects(): AppObjectRepo;
-    private cachedSingletons;
+    private cachedComponents;
     getCachedSingleton<T extends AppObjectComponent>(type: string): T | undefined;
+    getCachedLocalComponent<T extends AppObjectComponent>(type: string): T | undefined;
     getSingleton<T extends AppObjectComponent>(type: string, logType?: "LOG" | "WARN" | "ERROR"): T | undefined;
     dispose(): void;
     log(message: string): void;

package/lib/AppObject/AppObjectComponent.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.AppObjectComponent = void 0;
 class AppObjectComponent {
     constructor(appObject, type) {
-        this.cachedSingletons = new Map();
+        this.cachedComponents = new Map();
         this.appObject = appObject;
         this.type = type;
         appObject.addComponent(this);
@@ -12,16 +12,28 @@ class AppObjectComponent {
         return this.appObject.appObjectRepo;
     }
     getCachedSingleton(type) {
-        if (!this.cachedSingletons.has(type)) {
+        if (!this.cachedComponents.has(type)) {
             const component = this.appObjects.getSingleton(type);
             if (!component) {
                 this.warn("Unable to get cached singleton type " + type);
             }
             else {
-                this.cachedSingletons.set(type, component);
+                this.cachedComponents.set(type, component);
             }
         }
-        return this.cachedSingletons.get(type);
+        return this.cachedComponents.get(type);
+    }
+    getCachedLocalComponent(type) {
+        if (!this.cachedComponents.has(type)) {
+            const component = this.appObject.getComponent(type);
+            if (!component) {
+                this.warn("Unable to get local component of type " + type);
+            }
+            else {
+                this.cachedComponents.set(type, component);
+            }
+        }
+        return this.cachedComponents.get(type);
     }
     getSingleton(type, logType = "WARN") {
         const comp = this.appObjects.getSingleton(type);
@@ -41,7 +53,6 @@ class AppObjectComponent {
         }
         return comp;
     }
-    ;
     dispose() {
         if (this.appObject.getComponent(this.type) === this) {
             this.appObject.removeComponent(this.type);
@@ -53,7 +64,6 @@ class AppObjectComponent {
     warn(message) {
         this.appObjects.submitWarning(`${this.appObject.id}/${this.type}`, message);
     }
-    ;
     error(message) {
         this.appObjects.submitError(`${this.appObject.id}/${this.type}`, message);
     }

package/lib/Components/Challenge/Controller/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./setChallenge";
+export * from "./showChallengeHelp";

package/lib/Components/Challenge/Controller/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("./setChallenge"), exports);
+__exportStar(require("./showChallengeHelp"), exports);

package/lib/Components/Challenge/Controller/setChallenge.d.ts

@@ -0,0 +1,2 @@
+import { AppObjectRepo } from "../../../AppObject";
+export declare function setChallenge<CT>(challenge: CT, appObjects: AppObjectRepo): void;

package/lib/Components/Challenge/Controller/setChallenge.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setChallenge = void 0;
+const SetChallengeUC_1 = require("../UCs/SetChallengeUC");
+function setChallenge(challenge, appObjects) {
+    const uc = SetChallengeUC_1.SetChallengeUC.get(appObjects);
+    if (!uc) {
+        appObjects.submitWarning("setChallenge", "Unable to find SetChallengeUC");
+        return;
+    }
+    uc.setChallenge(challenge);
+}
+exports.setChallenge = setChallenge;

package/lib/Components/Challenge/Controller/showChallengeHelp.d.ts

@@ -0,0 +1,2 @@
+import { AppObjectRepo } from "../../../AppObject";
+export declare function showChallengeHelp(appObjects: AppObjectRepo): void;

package/lib/Components/Challenge/Controller/showChallengeHelp.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.showChallengeHelp = void 0;
+const UCs_1 = require("../UCs");
+function showChallengeHelp(appObjects) {
+    const uc = UCs_1.ShowChallengeHelpUC.get(appObjects);
+    if (!uc) {
+        appObjects.submitWarning("showChallengeHelp", "Unable to find ShowChallengeHelpUC");
+        return;
+    }
+    uc.showChallengeHelp();
+}
+exports.showChallengeHelp = showChallengeHelp;

package/lib/Components/Challenge/Entities/ChallengeEntity.d.ts

@@ -0,0 +1,30 @@
+import { AppObject, AppObjectEntity, AppObjectRepo } from "../../../AppObject";
+export declare abstract class ChallengeEntity<CT> extends AppObjectEntity {
+    static type: string;
+    abstract readonly defaultChallenge: CT;
+    abstract get selectedChallenge(): CT;
+    abstract set selectedChallenge(val: CT);
+    abstract get selectedChallengeName(): string;
+    abstract get allChallengeNames(): Map<CT, string>;
+    abstract setChallengeNames(list: {
+        value: CT;
+        label: string;
+    }[]): void;
+    abstract get helpHeading(): string;
+    abstract setHelpHeading(list: {
+        value: CT;
+        label: string;
+    }[]): void;
+    abstract get helpText(): string;
+    abstract setHelpText(list: {
+        value: CT;
+        label: string;
+    }[]): void;
+    abstract get authorHelp(): string;
+    abstract setAuthorHelp(list: {
+        value: CT;
+        label: string;
+    }[]): void;
+    static get<ChallengeType>(appObjects: AppObjectRepo): ChallengeEntity<ChallengeType> | undefined;
+}
+export declare function makeChallengeEntity<CT>(appObject: AppObject, defaultChallenge: CT): ChallengeEntity<CT>;

package/lib/Components/Challenge/Entities/ChallengeEntity.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeChallengeEntity = exports.ChallengeEntity = void 0;
+const AppObject_1 = require("../../../AppObject");
+class ChallengeEntity extends AppObject_1.AppObjectEntity {
+    static get(appObjects) {
+        return AppObject_1.getSingletonComponent(ChallengeEntity.type, appObjects);
+    }
+}
+exports.ChallengeEntity = ChallengeEntity;
+ChallengeEntity.type = "ChallengeEntity";
+function makeChallengeEntity(appObject, defaultChallenge) {
+    return new ChallengeEntityImp(appObject, defaultChallenge);
+}
+exports.makeChallengeEntity = makeChallengeEntity;
+class ChallengeEntityImp extends ChallengeEntity {
+    constructor(appObject, defaultChallenge) {
+        super(appObject, ChallengeEntity.type);
+        this.challengeNameLookup = new Map();
+        this.helpTextLookup = new Map();
+        this.authorHelpLookup = new Map();
+        this.helpHeadingLookup = new Map();
+        this.defaultChallenge = defaultChallenge;
+        this.appObjects.registerSingleton(this);
+    }
+    get selectedChallengeName() {
+        var _a;
+        return (_a = this.challengeNameLookup.get(this.selectedChallenge)) !== null && _a !== void 0 ? _a : "";
+    }
+    get allChallengeNames() {
+        return this.challengeNameLookup;
+    }
+    setChallengeNames(list) {
+        list.forEach((item) => {
+            this.challengeNameLookup.set(item.value, item.label);
+        });
+    }
+    get helpText() {
+        var _a;
+        return (_a = this.helpTextLookup.get(this.selectedChallenge)) !== null && _a !== void 0 ? _a : "";
+    }
+    setHelpText(list) {
+        list.forEach((item) => {
+            this.helpTextLookup.set(item.value, item.label);
+        });
+    }
+    get authorHelp() {
+        var _a;
+        return (_a = this.authorHelpLookup.get(this.selectedChallenge)) !== null && _a !== void 0 ? _a : "";
+    }
+    setAuthorHelp(list) {
+        list.forEach((item) => {
+            this.authorHelpLookup.set(item.value, item.label);
+        });
+    }
+    get helpHeading() {
+        var _a;
+        return (_a = this.helpHeadingLookup.get(this.selectedChallenge)) !== null && _a !== void 0 ? _a : "";
+    }
+    setHelpHeading(list) {
+        list.forEach((item) => {
+            this.helpHeadingLookup.set(item.value, item.label);
+        });
+    }
+    get selectedChallenge() {
+        if (!this._selectedChallenge) {
+            return this.defaultChallenge;
+        }
+        else {
+            return this._selectedChallenge;
+        }
+    }
+    set selectedChallenge(val) {
+        if (this._selectedChallenge === val)
+            return;
+        this._selectedChallenge = val;
+        this.notifyOnChange();
+    }
+}

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

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

package/lib/Components/Challenge/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("./ChallengeEntity"), exports);

package/lib/Components/Challenge/Mocks/MockChallengeAuthorHelpPM.d.ts

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

package/lib/Components/Challenge/Mocks/MockChallengeAuthorHelpPM.js

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

package/lib/Components/Challenge/Mocks/MockChallengeConsumerHelpPM.d.ts

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

package/lib/Components/Challenge/Mocks/MockChallengeConsumerHelpPM.js

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

package/lib/Components/Challenge/Mocks/MockSelectedChallengePM.d.ts

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

package/lib/Components/Challenge/Mocks/MockSelectedChallengePM.js

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

package/lib/Components/Challenge/Mocks/MockSetChallengeUC.d.ts

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

package/lib/Components/Challenge/Mocks/MockSetChallengeUC.js

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

package/lib/Components/Challenge/Mocks/MockShowChallengeHelpUC.d.ts

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

package/lib/Components/Challenge/Mocks/MockShowChallengeHelpUC.js

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

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

@@ -0,0 +1,5 @@
+export * from "./MockChallengeAuthorHelpPM";
+export * from "./MockChallengeConsumerHelpPM";
+export * from "./MockSelectedChallengePM";
+export * from "./MockSetChallengeUC";
+export * from "./MockShowChallengeHelpUC";

package/lib/Components/Challenge/Mocks/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("./MockChallengeAuthorHelpPM"), exports);
+__exportStar(require("./MockChallengeConsumerHelpPM"), exports);
+__exportStar(require("./MockSelectedChallengePM"), exports);
+__exportStar(require("./MockSetChallengeUC"), exports);
+__exportStar(require("./MockShowChallengeHelpUC"), exports);

package/lib/Components/Challenge/PMs/ChallengeAuthorHelpPM.d.ts

@@ -0,0 +1,11 @@
+import { AppObject, AppObjectPM, AppObjectRepo } from "../../../AppObject";
+export interface ChallengeAuthorHelpVM {
+    heading: string;
+    text: string;
+}
+export declare abstract class ChallengeAuthorHelpPM extends AppObjectPM<ChallengeAuthorHelpVM> {
+    static type: string;
+    static get(appObjects: AppObjectRepo): ChallengeAuthorHelpPM | undefined;
+}
+export declare function makeChallengeAuthorHelpPM<CT>(appObject: AppObject): ChallengeAuthorHelpPM;
+export declare const defaultChallengeAuthorHelpVM: ChallengeAuthorHelpVM;

package/lib/Components/Challenge/PMs/ChallengeAuthorHelpPM.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultChallengeAuthorHelpVM = exports.makeChallengeAuthorHelpPM = exports.ChallengeAuthorHelpPM = void 0;
+const AppObject_1 = require("../../../AppObject");
+const ChallengeEntity_1 = require("../Entities/ChallengeEntity");
+class ChallengeAuthorHelpPM extends AppObject_1.AppObjectPM {
+    static get(appObjects) {
+        return AppObject_1.getSingletonComponent(ChallengeAuthorHelpPM.type, appObjects);
+    }
+}
+exports.ChallengeAuthorHelpPM = ChallengeAuthorHelpPM;
+ChallengeAuthorHelpPM.type = "ChallengeAuthorHelpPM";
+function makeChallengeAuthorHelpPM(appObject) {
+    return new ChallengeAuthorHelpPMImp(appObject);
+}
+exports.makeChallengeAuthorHelpPM = makeChallengeAuthorHelpPM;
+class ChallengeAuthorHelpPMImp extends AppObject_1.AppObjectPM {
+    constructor(appObject) {
+        super(appObject, ChallengeAuthorHelpPM.type);
+        this.onEntityChange = () => {
+            if (!this.challengeEntity)
+                return;
+            const text = this.challengeEntity.authorHelp;
+            const heading = this.challengeEntity.selectedChallengeName;
+            const vm = {
+                heading,
+                text,
+            };
+            this.doUpdateView(vm);
+        };
+        this.challengeEntity = appObject.getComponent(ChallengeEntity_1.ChallengeEntity.type);
+        if (!this.challengeEntity) {
+            this.error("PM has been added to an app object that does not have ChallengeEntity");
+            return;
+        }
+        this.challengeEntity.addChangeObserver(this.onEntityChange);
+        this.onEntityChange();
+        this.appObjects.registerSingleton(this);
+    }
+    vmsAreEqual(a, b) {
+        if (a.heading !== b.heading)
+            return false;
+        if (a.text !== b.text)
+            return false;
+        return true;
+    }
+}
+exports.defaultChallengeAuthorHelpVM = {
+    heading: "",
+    text: "",
+};

package/lib/Components/Challenge/PMs/ChallengeConsumerHelpPM.d.ts

@@ -0,0 +1,12 @@
+import { AppObject, AppObjectPM, AppObjectRepo } from "../../../AppObject";
+export interface ChallengeConsumerHelpVM {
+    show: boolean;
+    heading: string;
+    text: string;
+}
+export declare abstract class ChallengeConsumerHelpPM extends AppObjectPM<ChallengeConsumerHelpVM> {
+    static type: string;
+    static get(appObjects: AppObjectRepo): ChallengeConsumerHelpPM | undefined;
+}
+export declare function makeChallengeConsumerHelpPM<CT>(appObject: AppObject): ChallengeConsumerHelpPM;
+export declare const defaultChallengeConsumerHelpVM: ChallengeConsumerHelpVM;

package/lib/Components/Challenge/PMs/ChallengeConsumerHelpPM.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultChallengeConsumerHelpVM = exports.makeChallengeConsumerHelpPM = exports.ChallengeConsumerHelpPM = void 0;
+const AppObject_1 = require("../../../AppObject");
+const App_1 = require("../../App");
+const ChallengeEntity_1 = require("../Entities/ChallengeEntity");
+class ChallengeConsumerHelpPM extends AppObject_1.AppObjectPM {
+    static get(appObjects) {
+        return AppObject_1.getSingletonComponent(ChallengeConsumerHelpPM.type, appObjects);
+    }
+}
+exports.ChallengeConsumerHelpPM = ChallengeConsumerHelpPM;
+ChallengeConsumerHelpPM.type = "ChallengeHelpPM";
+function makeChallengeConsumerHelpPM(appObject) {
+    return new ChallengeConsumerHelpPMImp(appObject);
+}
+exports.makeChallengeConsumerHelpPM = makeChallengeConsumerHelpPM;
+class ChallengeConsumerHelpPMImp extends AppObject_1.AppObjectPM {
+    constructor(appObject) {
+        super(appObject, ChallengeConsumerHelpPM.type);
+        this.onEntityChange = () => {
+            if (!this.challengeEntity || !this.baseApp)
+                return;
+            const text = this.challengeEntity.helpText;
+            const heading = this.challengeEntity.helpHeading;
+            let challengeHelpShow = true;
+            if (!text || !heading || this.baseApp.isReviewing) {
+                challengeHelpShow = false;
+            }
+            const vm = {
+                show: challengeHelpShow,
+                heading,
+                text,
+            };
+            this.doUpdateView(vm);
+        };
+        this.challengeEntity = appObject.getComponent(ChallengeEntity_1.ChallengeEntity.type);
+        if (!this.challengeEntity) {
+            this.error("PM has been added to an app object that does not have ChallengeEntity");
+            return;
+        }
+        this.baseApp = App_1.BaseAppState.get(appObject.appObjectRepo);
+        if (!this.baseApp) {
+            this.warn(`Unable to find the Base App State`);
+            return;
+        }
+        this.baseApp.addChangeObserver(this.onEntityChange);
+        this.challengeEntity.addChangeObserver(this.onEntityChange);
+        this.onEntityChange();
+        this.appObjects.registerSingleton(this);
+    }
+    vmsAreEqual(a, b) {
+        if (a.heading !== b.heading)
+            return false;
+        if (a.show !== b.show)
+            return false;
+        if (a.text !== b.text)
+            return false;
+        return true;
+    }
+}
+exports.defaultChallengeConsumerHelpVM = {
+    show: false,
+    heading: "",
+    text: "",
+};

package/lib/Components/Challenge/PMs/SelectedChallengePM.d.ts

@@ -0,0 +1,13 @@
+import { AppObject, AppObjectPM, AppObjectRepo } from "../../../AppObject";
+export interface SelectedChallengeVM<CT> {
+    challenge: CT | undefined;
+    options: {
+        value: CT;
+        label: string;
+    }[];
+}
+export declare abstract class SelectedChallengePM<CT> extends AppObjectPM<SelectedChallengeVM<CT>> {
+    static type: string;
+    static get<CT>(appObjects: AppObjectRepo): SelectedChallengePM<CT> | undefined;
+}
+export declare function makeSelectedChallengePM<CT>(appObject: AppObject): SelectedChallengePM<CT>;

package/lib/Components/Challenge/PMs/SelectedChallengePM.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeSelectedChallengePM = exports.SelectedChallengePM = void 0;
+const AppObject_1 = require("../../../AppObject");
+const ChallengeEntity_1 = require("../Entities/ChallengeEntity");
+class SelectedChallengePM extends AppObject_1.AppObjectPM {
+    static get(appObjects) {
+        return AppObject_1.getSingletonComponent(SelectedChallengePM.type, appObjects);
+    }
+}
+exports.SelectedChallengePM = SelectedChallengePM;
+SelectedChallengePM.type = "SelectedChallengePM";
+function makeSelectedChallengePM(appObject) {
+    return new SelectedChallengePMImp(appObject);
+}
+exports.makeSelectedChallengePM = makeSelectedChallengePM;
+class SelectedChallengePMImp extends SelectedChallengePM {
+    constructor(appObject) {
+        super(appObject, SelectedChallengePM.type);
+        this.onChallengeChange = () => {
+            if (!this.challengeEntity)
+                return;
+            const options = [];
+            this.challengeEntity.allChallengeNames.forEach((challengeName, challengeType) => {
+                options.push({ value: challengeType, label: challengeName });
+            });
+            const vm = {
+                challenge: this.challengeEntity.selectedChallenge,
+                options,
+            };
+            this.doUpdateView(vm);
+        };
+        this.challengeEntity = appObject.getComponent(ChallengeEntity_1.ChallengeEntity.type);
+        if (!this.challengeEntity) {
+            this.error("PM has been added to an app object that does not have ChallengeEntity");
+            return;
+        }
+        this.challengeEntity.addChangeObserver(this.onChallengeChange);
+        this.onChallengeChange();
+        this.appObjects.registerSingleton(this);
+    }
+    vmsAreEqual(a, b) {
+        if (a.challenge !== b.challenge)
+            return false;
+        if (a.options.length !== b.options.length)
+            return false;
+        let optionsAreTheSame = true;
+        a.options.forEach((optionA, i) => {
+            const optionB = b.options[i];
+            if (optionA.label !== optionB.label || optionA.value !== optionB.value) {
+                optionsAreTheSame = false;
+            }
+        });
+        return optionsAreTheSame;
+    }
+}

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

@@ -0,0 +1,3 @@
+export * from "./ChallengeAuthorHelpPM";
+export * from "./ChallengeConsumerHelpPM";
+export * from "./SelectedChallengePM";

package/lib/Components/Challenge/PMs/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("./ChallengeAuthorHelpPM"), exports);
+__exportStar(require("./ChallengeConsumerHelpPM"), exports);
+__exportStar(require("./SelectedChallengePM"), exports);

package/lib/Components/Challenge/React/challengeAuthorHelpHookAdapter.d.ts

@@ -0,0 +1,3 @@
+import { ReactHookPmAdapter } from "../../../Types/ReactHookPmAdapter";
+import { ChallengeAuthorHelpVM } from "../PMs/ChallengeAuthorHelpPM";
+export declare const challengeAuthorHelpHookAdapter: ReactHookPmAdapter<ChallengeAuthorHelpVM>;

package/lib/Components/Challenge/React/challengeAuthorHelpHookAdapter.js

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

package/lib/Components/Challenge/React/challengeConsumerHelpHookAdapter.d.ts

@@ -0,0 +1,3 @@
+import { ReactHookPmAdapter } from "../../../Types/ReactHookPmAdapter";
+import { ChallengeConsumerHelpVM } from "../PMs/ChallengeConsumerHelpPM";
+export declare const challengeConsumerHelpHookAdapter: ReactHookPmAdapter<ChallengeConsumerHelpVM>;

package/lib/Components/Challenge/React/challengeConsumerHelpHookAdapter.js

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

package/lib/Components/Challenge/React/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./challengeAuthorHelpHookAdapter";
+export * from "./challengeConsumerHelpHookAdapter";
+export * from "./selectedChallengeHookAdapter";

package/lib/Components/Challenge/React/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("./challengeAuthorHelpHookAdapter"), exports);
+__exportStar(require("./challengeConsumerHelpHookAdapter"), exports);
+__exportStar(require("./selectedChallengeHookAdapter"), exports);

package/lib/Components/Challenge/React/selectedChallengeHookAdapter.d.ts

@@ -0,0 +1,3 @@
+import { ReactHookPmAdapter } from "../../../Types/ReactHookPmAdapter";
+import { SelectedChallengeVM } from "../PMs/SelectedChallengePM";
+export declare function makeSelectedChallengeHookAdapter<CT>(): ReactHookPmAdapter<SelectedChallengeVM<CT>>;

package/lib/Components/Challenge/React/selectedChallengeHookAdapter.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeSelectedChallengeHookAdapter = void 0;
+const SelectedChallengePM_1 = require("../PMs/SelectedChallengePM");
+function makeSelectedChallengeHookAdapter() {
+    return {
+        defaultVM: {
+            challenge: undefined,
+            options: [],
+        },
+        subscribe: (appObjects, setVM) => {
+            const pm = SelectedChallengePM_1.SelectedChallengePM.get(appObjects);
+            if (!pm) {
+                appObjects.submitError("inspectorTabAdapter", "Unable to find InspectorTabPM");
+                return;
+            }
+            pm.addView(setVM);
+        },
+        unsubscribe: (appObjects, setVM) => {
+            const pm = SelectedChallengePM_1.SelectedChallengePM.get(appObjects);
+            if (!pm) {
+                appObjects.submitError("inspectorTabAdapter", "Unable to find InspectorTabPM");
+                return;
+            }
+            pm.removeView(setVM);
+        },
+    };
+}
+exports.makeSelectedChallengeHookAdapter = makeSelectedChallengeHookAdapter;

package/lib/Components/Challenge/UCs/SerializeChallenge.d.ts

@@ -0,0 +1,16 @@
+import { AppObject, AppObjectUC } from "../../../AppObject";
+import { SerializedSystem } from "../../StateMachine";
+export declare class SerializeChallengeUC<CT> extends AppObjectUC implements SerializedSystem {
+    static readonly type = "SerializeChallengeUC";
+    name: string;
+    seriliziationVersion: number;
+    private get challenge();
+    getSystemState(): object;
+    applySystemState(state: object, version: number): void;
+    private applyVersion1;
+    applyDefaultState(): void;
+    constructor(appObject: AppObject);
+}
+export interface SerializedStateV1 {
+    challenge: string;
+}

package/lib/Components/Challenge/UCs/SerializeChallenge.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SerializeChallengeUC = void 0;
+const AppObject_1 = require("../../../AppObject");
+const StateMachine_1 = require("../../StateMachine");
+const ChallengeEntity_1 = require("../Entities/ChallengeEntity");
+class SerializeChallengeUC extends AppObject_1.AppObjectUC {
+    constructor(appObject) {
+        super(appObject, SerializeChallengeUC.type);
+        this.name = "challenge";
+        this.seriliziationVersion = 1;
+        const stateMachine = StateMachine_1.StateMachineEntity.get(appObject.appObjectRepo);
+        if (stateMachine) {
+            stateMachine.registerSerializedSystem(this);
+        }
+        else {
+            this.warn("Unable to find StateMachineEntity");
+        }
+    }
+    get challenge() {
+        return this.getCachedSingleton(ChallengeEntity_1.ChallengeEntity.type);
+    }
+    getSystemState() {
+        if (!this.challenge)
+            return {};
+        let challenge = this.challenge
+            .defaultChallenge;
+        if (this.challenge.selectedChallenge) {
+            challenge = this.challenge.selectedChallenge;
+        }
+        const state = {
+            challenge,
+        };
+        return state;
+    }
+    applySystemState(state, version) {
+        if (version === 1) {
+            this.applyVersion1(state);
+        }
+        else {
+            this.applyDefaultState();
+        }
+    }
+    applyVersion1(state) {
+        if (!this.challenge)
+            return;
+        this.challenge.selectedChallenge = state.challenge;
+    }
+    applyDefaultState() {
+        if (!this.challenge)
+            return;
+        this.challenge.selectedChallenge = this.challenge.defaultChallenge;
+    }
+}
+exports.SerializeChallengeUC = SerializeChallengeUC;
+SerializeChallengeUC.type = "SerializeChallengeUC";

package/lib/Components/Challenge/UCs/SetChallengeUC.d.ts

@@ -0,0 +1,7 @@
+import { AppObject, AppObjectRepo, AppObjectUC } from "../../../AppObject";
+export declare abstract class SetChallengeUC<CT> extends AppObjectUC {
+    static type: string;
+    abstract setChallenge(challenge: CT): void;
+    static get<CT>(appObjects: AppObjectRepo): SetChallengeUC<CT> | undefined;
+}
+export declare function makeSetChallengeUC<CT>(appObject: AppObject): SetChallengeUC<CT>;

package/lib/Components/Challenge/UCs/SetChallengeUC.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeSetChallengeUC = exports.SetChallengeUC = void 0;
+const AppObject_1 = require("../../../AppObject");
+const Dispatcher_1 = require("../../Dispatcher");
+const ChallengeEntity_1 = require("../Entities/ChallengeEntity");
+const SetChallengeUndo_1 = require("./SetChallengeUndo");
+class SetChallengeUC extends AppObject_1.AppObjectUC {
+    static get(appObjects) {
+        return AppObject_1.getSingletonComponent(SetChallengeUC.type, appObjects);
+    }
+}
+exports.SetChallengeUC = SetChallengeUC;
+SetChallengeUC.type = "SetChallengeUC";
+function makeSetChallengeUC(appObject) {
+    return new SetChallengeUCImp(appObject);
+}
+exports.makeSetChallengeUC = makeSetChallengeUC;
+class SetChallengeUCImp extends SetChallengeUC {
+    get challengeEntity() {
+        return this.getCachedSingleton(ChallengeEntity_1.ChallengeEntity.type);
+    }
+    get dispatchStateChange() {
+        return this.getCachedSingleton(Dispatcher_1.DispatchStateChangeUC.type);
+    }
+    setChallenge(challenge) {
+        var _a;
+        if (!this.challengeEntity) {
+            return;
+        }
+        if (this.challengeEntity.selectedChallenge === challenge)
+            return;
+        if (this.challengeEntity.selectedChallenge) {
+            new SetChallengeUndo_1.SetChallengeUndo(this.challengeEntity.selectedChallenge, this.appObjects);
+        }
+        this.challengeEntity.selectedChallenge = challenge;
+        (_a = this.dispatchStateChange) === null || _a === void 0 ? void 0 : _a.doDispatch();
+    }
+    constructor(appObject) {
+        super(appObject, SetChallengeUC.type);
+        this.appObjects.registerSingleton(this);
+    }
+}

package/lib/Components/Challenge/UCs/SetChallengeUndo.d.ts

@@ -0,0 +1,11 @@
+import { AppObjectRepo } from "../../../AppObject";
+import { UndoRedoAction } from "../../UndoRedo";
+export declare class SetChallengeUndo<CT> implements UndoRedoAction {
+    private appObjects;
+    private challenge?;
+    private undoChallenge;
+    private redoChallenge?;
+    undoAction: () => void;
+    redoAction: () => void;
+    constructor(initialChallenge: CT, appObjects: AppObjectRepo);
+}

package/lib/Components/Challenge/UCs/SetChallengeUndo.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SetChallengeUndo = void 0;
+const Dispatcher_1 = require("../../Dispatcher");
+const UndoRedo_1 = require("../../UndoRedo");
+const ChallengeEntity_1 = require("../Entities/ChallengeEntity");
+class SetChallengeUndo {
+    constructor(initialChallenge, appObjects) {
+        this.appObjects = appObjects;
+        this.undoAction = () => {
+            if (!this.undoChallenge || !this.challenge)
+                return;
+            this.challenge.selectedChallenge = this.undoChallenge;
+            Dispatcher_1.dispatchStateChange(this.appObjects);
+        };
+        this.redoAction = () => {
+            if (!this.challenge || !this.redoChallenge)
+                return;
+            this.challenge.selectedChallenge = this.redoChallenge;
+            Dispatcher_1.dispatchStateChange(this.appObjects);
+        };
+        this.undoChallenge = initialChallenge;
+        this.challenge = ChallengeEntity_1.ChallengeEntity.get(appObjects);
+        if (!this.challenge) {
+            appObjects.submitError("SetChallengeUR", "Unable to find ChallengeEntity");
+            return;
+        }
+        this.redoChallenge = this.challenge.selectedChallenge;
+        const undoRedo = UndoRedo_1.UndoRedoEntity.get(this.appObjects);
+        if (!undoRedo) {
+            this.appObjects.submitWarning("SetChallengeUR", "Unable to find UndoRedoEntity");
+            return;
+        }
+        undoRedo.submitAction(this);
+    }
+}
+exports.SetChallengeUndo = SetChallengeUndo;

package/lib/Components/Challenge/UCs/ShowChallengeHelpUC.d.ts

@@ -0,0 +1,7 @@
+import { AppObject, AppObjectRepo, AppObjectUC } from "../../../AppObject";
+export declare abstract class ShowChallengeHelpUC extends AppObjectUC {
+    static readonly type = "ShowChallengeHelpUC";
+    abstract showChallengeHelp(): void;
+    static get: (appObjects: AppObjectRepo) => ShowChallengeHelpUC | undefined;
+}
+export declare function makeShowChallengeHelpUC<CT>(appObject: AppObject): ShowChallengeHelpUC;

package/lib/Components/Challenge/UCs/ShowChallengeHelpUC.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeShowChallengeHelpUC = exports.ShowChallengeHelpUC = void 0;
+const AppObject_1 = require("../../../AppObject");
+const ShowAlertUC_1 = require("../../Dispatcher/UC/ShowAlertUC");
+const Entities_1 = require("../Entities");
+class ShowChallengeHelpUC extends AppObject_1.AppObjectUC {
+}
+exports.ShowChallengeHelpUC = ShowChallengeHelpUC;
+ShowChallengeHelpUC.type = "ShowChallengeHelpUC";
+ShowChallengeHelpUC.get = (appObjects) => AppObject_1.getSingletonComponent(ShowChallengeHelpUC.type, appObjects);
+function makeShowChallengeHelpUC(appObject) {
+    return new ShowChallengeHelpUCImp(appObject);
+}
+exports.makeShowChallengeHelpUC = makeShowChallengeHelpUC;
+class ShowChallengeHelpUCImp extends ShowChallengeHelpUC {
+    constructor(appObject) {
+        super(appObject, ShowChallengeHelpUC.type);
+        this.showChallengeHelp = () => {
+            if (!this.challengeEntity || !this.showAlertUC)
+                return;
+            ShowAlertUC_1.ShowAlertUC.get(this.appObjects);
+            const title = this.challengeEntity.helpHeading;
+            const message = this.challengeEntity.helpText;
+            if (!title || !message) {
+                this.warn("Title or message is empty");
+                return;
+            }
+            const alertDTO = {
+                title,
+                message,
+                closeButtonLabel: "Close",
+                closeCallback: () => { },
+            };
+            this.showAlertUC.showAlert(alertDTO);
+        };
+        this.appObjects.registerSingleton(this);
+    }
+    get challengeEntity() {
+        return this.getCachedSingleton(Entities_1.ChallengeEntity.type);
+    }
+    get showAlertUC() {
+        return this.getCachedSingleton(ShowAlertUC_1.ShowAlertUC.type);
+    }
+}

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

@@ -0,0 +1,4 @@
+export * from "./SerializeChallenge";
+export * from "./SetChallengeUC";
+export * from "./SetChallengeUndo";
+export * from "./ShowChallengeHelpUC";

package/lib/Components/Challenge/UCs/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("./SerializeChallenge"), exports);
+__exportStar(require("./SetChallengeUC"), exports);
+__exportStar(require("./SetChallengeUndo"), exports);
+__exportStar(require("./ShowChallengeHelpUC"), exports);

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

@@ -0,0 +1,6 @@
+export * from "./Controller";
+export * from "./Entities";
+export * from "./Mocks";
+export * from "./PMs";
+export * from "./React";
+export * from "./UCs";

package/lib/Components/Challenge/index.js

@@ -0,0 +1,18 @@
+"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("./Controller"), exports);
+__exportStar(require("./Entities"), exports);
+__exportStar(require("./Mocks"), exports);
+__exportStar(require("./PMs"), exports);
+__exportStar(require("./React"), exports);
+__exportStar(require("./UCs"), exports);

package/lib/Components/Dispatcher/Mocks/MockShowAlert.js

@@ -10,6 +10,6 @@ class MockShowAlert extends UC_1.ShowAlertUC {
 }
 exports.MockShowAlert = MockShowAlert;
 function makeMockShowAlert(appObjects) {
-    return new MockShowAlert(appObjects.getOrCreate("Dispatcher"));
+    return new MockShowAlert(appObjects.getOrCreate("MockShowAlert"));
 }
 exports.makeMockShowAlert = makeMockShowAlert;

package/lib/Components/Dispatcher/UC/ShowAlertUC.d.ts

@@ -8,7 +8,7 @@ export interface ShowAlertDTO {
     closeCallback: () => void;
 }
 export declare abstract class ShowAlertUC extends AppObjectUC {
-    static readonly type = "ShowAlertUC";
+    static type: string;
     readonly requestType = "SHOW_ALERT";
     abstract showAlert(data: ShowAlertDTO): void;
     static get: (appObjects: AppObjectRepo) => ShowAlertUC | undefined;

package/lib/Components/StateMachine/Entities/StateMachineEntity.js

@@ -60,22 +60,27 @@ class StateMachineImp extends StateMachineEntity {
         };
         this.setSerializedStates = (states, duration) => {
             if (states.version === 2) {
-                const appliedToSystems = [];
+                const systemStateLookup = new Map();
                 states.systems.forEach((systemState) => {
-                    const seriliazableSystem = this.serializedSystems.get(systemState.name);
-                    if (seriliazableSystem) {
-                        seriliazableSystem.applySystemState(systemState.state, systemState.seriliziationVersion, duration);
+                    if (this.serializedSystems.has(systemState.name)) {
+                        systemStateLookup.set(systemState.name, systemState);
                     }
                     else {
                         this.warn(`Unable to find serializedSystem ${systemState.name}`);
                     }
-                    appliedToSystems.push(systemState.name);
                 });
+                // Apply default states first
                 this.serializedSystems.forEach((system) => {
-                    if (!appliedToSystems.includes(system.name)) {
+                    if (!systemStateLookup.has(system.name)) {
                         system.applyDefaultState(duration);
                     }
                 });
+                this.serializedSystems.forEach((system) => {
+                    const systemState = systemStateLookup.get(system.name);
+                    if (systemState) {
+                        system.applySystemState(systemState.state, systemState.seriliziationVersion, duration);
+                    }
+                });
                 this.notifyOnChange();
                 return;
             }

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

@@ -1 +1,2 @@
 export * from "./Entities";
+export * from "./Mocks";

package/lib/Components/StateMachine/index.js

@@ -11,3 +11,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./Entities"), exports);
+__exportStar(require("./Mocks"), exports);

package/lib/Components/index.d.ts

@@ -1,6 +1,7 @@
 export * from "./App";
 export * from "./Babylon";
 export * from "./Camera";
+export * from "./Challenge";
 export * from "./ChannelModel";
 export * from "./Dispatcher";
 export * from "./Enablement";

package/lib/Components/index.js

@@ -13,6 +13,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./App"), exports);
 __exportStar(require("./Babylon"), exports);
 __exportStar(require("./Camera"), exports);
+__exportStar(require("./Challenge"), exports);
 __exportStar(require("./ChannelModel"), exports);
 __exportStar(require("./Dispatcher"), exports);
 __exportStar(require("./Enablement"), exports);

package/lib/Types/ReactHookPmAdapter.d.ts

@@ -0,0 +1,6 @@
+import { AppObjectRepo } from "../AppObject";
+export interface ReactHookPmAdapter<VM> {
+    defaultVM: VM;
+    subscribe(appObjects: AppObjectRepo, setVM: (vm: VM) => void): void;
+    unsubscribe(appObjects: AppObjectRepo, setVM: (vm: VM) => void): void;
+}

package/lib/Types/ReactHookPmAdapter.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/Types/index.d.ts

@@ -2,3 +2,4 @@ export * from "./AppBoundary";
 export * from "./AssetMetaDTO";
 export * from "./ChannelModelData";
 export * from "./EaseFn";
+export * from "./ReactHookPmAdapter";

package/lib/Types/index.js

@@ -14,3 +14,4 @@ __exportStar(require("./AppBoundary"), exports);
 __exportStar(require("./AssetMetaDTO"), exports);
 __exportStar(require("./ChannelModelData"), exports);
 __exportStar(require("./EaseFn"), exports);
+__exportStar(require("./ReactHookPmAdapter"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vived/app",
-  "version": "4.14.1",
+  "version": "4.15.1",
   "description": "Public package for the VIVED Learning App system",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",