@vived/host 3.0.0

package/lib/Components/Dialog/Factories/confirmDialogFactory.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeConfirmFactory = void 0;
+const Utilities_1 = require("../../../Utilities");
+const Entities_1 = require("../Entities");
+const PMs_1 = require("../PMs");
+function makeConfirmFactory(appObjects) {
+    return function confirmFactory(data) {
+        const ao = appObjects.getOrCreate(Utilities_1.generateUniqueID());
+        const entity = new Entities_1.ConfirmDialogEntity(data, ao);
+        new PMs_1.ConfirmDialogPM(ao);
+        return entity;
+    };
+}
+exports.makeConfirmFactory = makeConfirmFactory;

package/lib/Components/Dialog/Factories/index.d.ts

@@ -0,0 +1,5 @@
+export * from './alertDialogFactory';
+export * from './confirmDialogFactory';
+export * from './markdownDialogEditorFactory';
+export * from './selectDialogModelFactory';
+export * from './spinnerDialogFactory';

package/lib/Components/Dialog/Factories/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("./alertDialogFactory"), exports);
+__exportStar(require("./confirmDialogFactory"), exports);
+__exportStar(require("./markdownDialogEditorFactory"), exports);
+__exportStar(require("./selectDialogModelFactory"), exports);
+__exportStar(require("./spinnerDialogFactory"), exports);

package/lib/Components/Dialog/Factories/markdownDialogEditorFactory.d.ts

@@ -0,0 +1,3 @@
+import { HostAppObjectRepo } from "../../../HostAppObject";
+import { DialogMarkDownEditorDTO, MarkDownEditorDialogEntity } from "../Entities";
+export declare function makeMarkdownEditorFactory(appObjects: HostAppObjectRepo): (data: DialogMarkDownEditorDTO) => MarkDownEditorDialogEntity;

package/lib/Components/Dialog/Factories/markdownDialogEditorFactory.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeMarkdownEditorFactory = void 0;
+const Utilities_1 = require("../../../Utilities");
+const Entities_1 = require("../Entities");
+const PMs_1 = require("../PMs");
+function makeMarkdownEditorFactory(appObjects) {
+    return function markdownEditorFactory(data) {
+        const ao = appObjects.getOrCreate(Utilities_1.generateUniqueID());
+        const entity = new Entities_1.MarkDownEditorDialogEntity(data, ao);
+        new PMs_1.MarkDownEditorDialogPM(ao);
+        return entity;
+    };
+}
+exports.makeMarkdownEditorFactory = makeMarkdownEditorFactory;

package/lib/Components/Dialog/Factories/selectDialogModelFactory.d.ts

@@ -0,0 +1,3 @@
+import { HostAppObjectRepo } from "../../../HostAppObject";
+import { SelectModelDialogEntity } from "../Entities";
+export declare function makeSelectModelFactory(appObjects: HostAppObjectRepo): () => SelectModelDialogEntity;

package/lib/Components/Dialog/Factories/selectDialogModelFactory.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeSelectModelFactory = void 0;
+const Utilities_1 = require("../../../Utilities");
+const Entities_1 = require("../Entities");
+function makeSelectModelFactory(appObjects) {
+    return function selectModelFactory() {
+        const ao = appObjects.getOrCreate(Utilities_1.generateUniqueID());
+        return new Entities_1.SelectModelDialogEntity(ao);
+    };
+}
+exports.makeSelectModelFactory = makeSelectModelFactory;

package/lib/Components/Dialog/Factories/spinnerDialogFactory.d.ts

@@ -0,0 +1,3 @@
+import { HostAppObjectRepo } from "../../../HostAppObject";
+import { DialogSpinnerDTO, SpinnerDialogEntity } from "../Entities";
+export declare function makeSpinnerFactory(appObjects: HostAppObjectRepo): (data: DialogSpinnerDTO) => SpinnerDialogEntity;

package/lib/Components/Dialog/Factories/spinnerDialogFactory.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeSpinnerFactory = void 0;
+const Utilities_1 = require("../../../Utilities");
+const Entities_1 = require("../Entities");
+const PMs_1 = require("../PMs");
+function makeSpinnerFactory(appObjects) {
+    return function spinnerFactory(data) {
+        const ao = appObjects.getOrCreate(Utilities_1.generateUniqueID());
+        const entity = new Entities_1.SpinnerDialogEntity(data, ao);
+        new PMs_1.SpinnerDialogPM(ao);
+        return entity;
+    };
+}
+exports.makeSpinnerFactory = makeSpinnerFactory;

package/lib/Components/Dialog/PMs/AlertDialogPM.d.ts

@@ -0,0 +1,16 @@
+import { HostAppObject, HostAppObjectPM, HostAppObjectRepo } from '../../../HostAppObject';
+export interface AlertDialogVM {
+    message: string;
+    title: string;
+    buttonLabel: string;
+    close: () => void;
+}
+export declare class AlertDialogPM extends HostAppObjectPM<AlertDialogVM> {
+    static type: string;
+    static get(assetID: string, appObjects: HostAppObjectRepo): AlertDialogPM | undefined;
+    private alert?;
+    vmsAreEqual(a: AlertDialogVM, b: AlertDialogVM): boolean;
+    onAlertChange: () => void;
+    constructor(appObject: HostAppObject);
+}
+export declare const defaultAlertDialogVM: AlertDialogVM;

package/lib/Components/Dialog/PMs/AlertDialogPM.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultAlertDialogVM = exports.AlertDialogPM = void 0;
+const HostAppObject_1 = require("../../../HostAppObject");
+const Entities_1 = require("../Entities");
+class AlertDialogPM extends HostAppObject_1.HostAppObjectPM {
+    constructor(appObject) {
+        super(appObject, AlertDialogPM.type);
+        this.onAlertChange = () => {
+            if (!this.alert)
+                return;
+            this.doUpdateView({
+                buttonLabel: this.alert.buttonLabel,
+                close: this.alert.close,
+                message: this.alert.message,
+                title: this.alert.title,
+            });
+        };
+        this.alert = appObject.getComponent(Entities_1.AlertDialogEntity.type);
+        if (!this.alert) {
+            this.error('PM added to an app object that does not have a DialogAlertEntity');
+            return;
+        }
+        this.alert.addChangeObserver(this.onAlertChange);
+        this.onAlertChange();
+    }
+    static get(assetID, appObjects) {
+        const appObject = appObjects.get(assetID);
+        if (!appObject) {
+            appObjects.submitWarning('AlertDialogPM.get', 'Unable to find app object');
+            return undefined;
+        }
+        const pm = appObject.getComponent(AlertDialogPM.type);
+        if (!pm) {
+            appObjects.submitWarning('AlertDialogPM.get', 'App Object does not have AlertDialogPM');
+            return undefined;
+        }
+        return pm;
+    }
+    vmsAreEqual(a, b) {
+        if (a.message !== b.message)
+            return false;
+        if (a.title !== b.title)
+            return false;
+        if (a.buttonLabel !== b.buttonLabel)
+            return false;
+        return true;
+    }
+}
+exports.AlertDialogPM = AlertDialogPM;
+AlertDialogPM.type = 'AlertDialogPM';
+exports.defaultAlertDialogVM = {
+    message: "Generic alert message",
+    title: "Alert",
+    buttonLabel: "Close",
+    close: () => {
+        console.warn('[AlertDialogVM.close] default VM');
+    }
+};

package/lib/Components/Dialog/PMs/ConfirmDialogPM.d.ts

@@ -0,0 +1,18 @@
+import { HostAppObject, HostAppObjectPM, HostAppObjectRepo } from '../../../HostAppObject';
+export interface ConfirmDialogVM {
+    message: string;
+    title: string;
+    cancelButtonLabel: string;
+    confirmButtonLabel: string;
+    cancel: () => void;
+    confirm: () => void;
+}
+export declare class ConfirmDialogPM extends HostAppObjectPM<ConfirmDialogVM> {
+    static type: string;
+    static get(assetID: string, appObjects: HostAppObjectRepo): ConfirmDialogPM | undefined;
+    private dialog?;
+    vmsAreEqual(a: ConfirmDialogVM, b: ConfirmDialogVM): boolean;
+    onAlertChange: () => void;
+    constructor(appObject: HostAppObject);
+}
+export declare const defaultConfirmDialogVM: ConfirmDialogVM;

package/lib/Components/Dialog/PMs/ConfirmDialogPM.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultConfirmDialogVM = exports.ConfirmDialogPM = void 0;
+const HostAppObject_1 = require("../../../HostAppObject");
+const Entities_1 = require("../Entities");
+class ConfirmDialogPM extends HostAppObject_1.HostAppObjectPM {
+    constructor(appObject) {
+        super(appObject, ConfirmDialogPM.type);
+        this.onAlertChange = () => {
+            if (!this.dialog)
+                return;
+            this.doUpdateView({
+                confirmButtonLabel: this.dialog.confirmButtonLabel,
+                cancelButtonLabel: this.dialog.cancelButtonLabel,
+                cancel: this.dialog.cancel,
+                message: this.dialog.message,
+                title: this.dialog.title,
+                confirm: this.dialog.confirm,
+            });
+        };
+        this.dialog = appObject.getComponent(Entities_1.ConfirmDialogEntity.type);
+        if (!this.dialog) {
+            this.error('PM added to an app object that does not have a DialogConfirmEntity');
+            return;
+        }
+        this.dialog.addChangeObserver(this.onAlertChange);
+        this.onAlertChange();
+    }
+    static get(assetID, appObjects) {
+        const appObject = appObjects.get(assetID);
+        if (!appObject) {
+            appObjects.submitWarning('ConfirmDialogPM.get', 'Unable to find app object');
+            return undefined;
+        }
+        const pm = appObject.getComponent(ConfirmDialogPM.type);
+        if (!pm) {
+            appObjects.submitWarning('ConfirmDialogPM.get', 'App Object does not have ConfirmDialogPM');
+            return undefined;
+        }
+        return pm;
+    }
+    vmsAreEqual(a, b) {
+        if (a.message !== b.message)
+            return false;
+        if (a.title !== b.title)
+            return false;
+        if (a.cancelButtonLabel !== b.cancelButtonLabel)
+            return false;
+        if (a.confirmButtonLabel !== b.confirmButtonLabel)
+            return false;
+        return true;
+    }
+}
+exports.ConfirmDialogPM = ConfirmDialogPM;
+ConfirmDialogPM.type = 'ConfirmDialogPM';
+exports.defaultConfirmDialogVM = {
+    message: 'Generic confirm message',
+    title: 'Confirm',
+    cancel: () => {
+        console.warn('[ConfirmDialogVM.cancel] default VM');
+    },
+    cancelButtonLabel: '',
+    confirm: () => {
+        console.warn('[ConfirmDialogVM.confirm] default VM');
+    },
+    confirmButtonLabel: '',
+};

package/lib/Components/Dialog/PMs/DialogQueuePM.d.ts

@@ -0,0 +1,16 @@
+import { HostAppObject, HostAppObjectPM, HostAppObjectRepo } from '../../../HostAppObject';
+export interface DialogVM {
+    open: boolean;
+    id?: string;
+    dialogType?: string;
+    preventOutsideDismiss?: boolean;
+}
+export declare class DialogQueuePM extends HostAppObjectPM<DialogVM> {
+    static type: string;
+    static get(appObjects: HostAppObjectRepo): DialogQueuePM | undefined;
+    private queue?;
+    vmsAreEqual(a: DialogVM, b: DialogVM): boolean;
+    onQueueChange: () => void;
+    constructor(appObject: HostAppObject);
+}
+export declare const defualtDialogVM: DialogVM;

package/lib/Components/Dialog/PMs/DialogQueuePM.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defualtDialogVM = exports.DialogQueuePM = void 0;
+const HostAppObject_1 = require("../../../HostAppObject");
+const Entities_1 = require("../Entities");
+class DialogQueuePM extends HostAppObject_1.HostAppObjectPM {
+    constructor(appObject) {
+        super(appObject, DialogQueuePM.type);
+        this.onQueueChange = () => {
+            if (!this.queue)
+                return;
+            let vm = { open: false };
+            const currentDialog = this.queue.activeDialog;
+            if (currentDialog) {
+                vm = {
+                    open: currentDialog.isOpen,
+                    dialogType: currentDialog.dialogType,
+                    preventOutsideDismiss: currentDialog.preventOutsideDismiss,
+                    id: currentDialog.appObject.id,
+                };
+            }
+            this.doUpdateView(vm);
+        };
+        this.queue = appObject.getComponent(Entities_1.DialogQueue.type);
+        if (!this.queue) {
+            this.error('PM added to an app object that does not have a DialogQueue');
+            return;
+        }
+        this.queue.addChangeObserver(this.onQueueChange);
+        this.onQueueChange();
+        this.appObjects.registerSingleton(this);
+    }
+    static get(appObjects) {
+        return HostAppObject_1.getSingletonComponent(DialogQueuePM.type, appObjects);
+    }
+    vmsAreEqual(a, b) {
+        if (a.open !== b.open)
+            return false;
+        if (a.id !== b.id)
+            return false;
+        if (a.dialogType !== b.dialogType)
+            return false;
+        if (a.preventOutsideDismiss !== b.preventOutsideDismiss)
+            return false;
+        return true;
+    }
+}
+exports.DialogQueuePM = DialogQueuePM;
+DialogQueuePM.type = 'DialogQueuePM';
+exports.defualtDialogVM = {
+    open: false,
+};

package/lib/Components/Dialog/PMs/MarkDownEditorDialogPM.d.ts

@@ -0,0 +1,14 @@
+import { HostAppObject, HostAppObjectPM, HostAppObjectRepo } from '../../../HostAppObject';
+export interface MarkDownEditorDialogVM {
+    initialText: string;
+    confirm: (text: string) => void;
+}
+export declare class MarkDownEditorDialogPM extends HostAppObjectPM<MarkDownEditorDialogVM> {
+    static type: string;
+    static get(assetID: string, appObjects: HostAppObjectRepo): MarkDownEditorDialogPM | undefined;
+    private dialog?;
+    vmsAreEqual(a: MarkDownEditorDialogVM, b: MarkDownEditorDialogVM): boolean;
+    onAlertChange: () => void;
+    constructor(appObject: HostAppObject);
+}
+export declare const defaultMarkDownEditorDialogVM: MarkDownEditorDialogVM;

package/lib/Components/Dialog/PMs/MarkDownEditorDialogPM.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultMarkDownEditorDialogVM = exports.MarkDownEditorDialogPM = void 0;
+const HostAppObject_1 = require("../../../HostAppObject");
+const MarkDownEditor_1 = require("../Entities/MarkDownEditor");
+class MarkDownEditorDialogPM extends HostAppObject_1.HostAppObjectPM {
+    constructor(appObject) {
+        super(appObject, MarkDownEditorDialogPM.type);
+        this.onAlertChange = () => {
+            if (!this.dialog)
+                return;
+            this.doUpdateView({
+                initialText: this.dialog.initialText,
+                confirm: this.dialog.confirm,
+            });
+        };
+        this.dialog = appObject.getComponent(MarkDownEditor_1.MarkDownEditorDialogEntity.type);
+        if (!this.dialog) {
+            this.error('PM added to an app object that does not have a DialogMarkDownEntity');
+            return;
+        }
+        this.dialog.addChangeObserver(this.onAlertChange);
+        this.onAlertChange();
+    }
+    static get(assetID, appObjects) {
+        const appObject = appObjects.get(assetID);
+        if (!appObject) {
+            appObjects.submitWarning('MarkDownEditorDialogPM.get', 'Unable to find app object');
+            return undefined;
+        }
+        const pm = appObject.getComponent(MarkDownEditorDialogPM.type);
+        if (!pm) {
+            appObjects.submitWarning('MarkDownEditorDialogPM.get', 'App Object does not have MarkDownEditorDialogPM');
+            return undefined;
+        }
+        return pm;
+    }
+    vmsAreEqual(a, b) {
+        if (a.initialText !== b.initialText)
+            return false;
+        return true;
+    }
+}
+exports.MarkDownEditorDialogPM = MarkDownEditorDialogPM;
+MarkDownEditorDialogPM.type = 'MarkDownEditorDialogPM';
+exports.defaultMarkDownEditorDialogVM = {
+    initialText: '',
+    confirm: (text) => {
+        console.warn('[MarkDownEditorDialogVM.confirm] default VM!');
+    },
+};

package/lib/Components/Dialog/PMs/SpinnerDialogPM.d.ts

@@ -0,0 +1,14 @@
+import { HostAppObject, HostAppObjectPM, HostAppObjectRepo } from '../../../HostAppObject';
+export interface SpinnerDialogVM {
+    message: string;
+    title: string;
+}
+export declare class SpinnerDialogPM extends HostAppObjectPM<SpinnerDialogVM> {
+    static type: string;
+    static get(assetID: string, appObjects: HostAppObjectRepo): SpinnerDialogPM | undefined;
+    private dialog?;
+    vmsAreEqual(a: SpinnerDialogVM, b: SpinnerDialogVM): boolean;
+    onAlertChange: () => void;
+    constructor(appObject: HostAppObject);
+}
+export declare const defaultSpinnerDialogVM: SpinnerDialogVM;

package/lib/Components/Dialog/PMs/SpinnerDialogPM.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultSpinnerDialogVM = exports.SpinnerDialogPM = void 0;
+const HostAppObject_1 = require("../../../HostAppObject");
+const Entities_1 = require("../Entities");
+class SpinnerDialogPM extends HostAppObject_1.HostAppObjectPM {
+    constructor(appObject) {
+        super(appObject, SpinnerDialogPM.type);
+        this.onAlertChange = () => {
+            if (!this.dialog)
+                return;
+            this.doUpdateView({
+                message: this.dialog.message,
+                title: this.dialog.title,
+            });
+        };
+        this.dialog = appObject.getComponent(Entities_1.SpinnerDialogEntity.type);
+        if (!this.dialog) {
+            this.error('PM added to an app object that does not have a DialogSpinnerEntity');
+            return;
+        }
+        this.dialog.addChangeObserver(this.onAlertChange);
+        this.onAlertChange();
+    }
+    static get(assetID, appObjects) {
+        const appObject = appObjects.get(assetID);
+        if (!appObject) {
+            appObjects.submitWarning('SpinnerDialogPM.get', 'Unable to find app object');
+            return undefined;
+        }
+        const pm = appObject.getComponent(SpinnerDialogPM.type);
+        if (!pm) {
+            appObjects.submitWarning('SpinnerDialogPM.get', 'App Object does not have SpinnerDialogPM');
+            return undefined;
+        }
+        return pm;
+    }
+    vmsAreEqual(a, b) {
+        if (a.message !== b.message)
+            return false;
+        if (a.title !== b.title)
+            return false;
+        return true;
+    }
+}
+exports.SpinnerDialogPM = SpinnerDialogPM;
+SpinnerDialogPM.type = 'SpinnerDialogPM';
+exports.defaultSpinnerDialogVM = {
+    message: 'Default spinner message',
+    title: 'Spinner',
+};

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

@@ -0,0 +1,5 @@
+export * from './AlertDialogPM';
+export * from './ConfirmDialogPM';
+export * from './DialogQueuePM';
+export * from './MarkDownEditorDialogPM';
+export * from './SpinnerDialogPM';

package/lib/Components/Dialog/PMs/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("./AlertDialogPM"), exports);
+__exportStar(require("./ConfirmDialogPM"), exports);
+__exportStar(require("./DialogQueuePM"), exports);
+__exportStar(require("./MarkDownEditorDialogPM"), exports);
+__exportStar(require("./SpinnerDialogPM"), exports);

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

@@ -0,0 +1,4 @@
+export * from "./Controllers";
+export * from './Entities';
+export * from './Factories';
+export * from './PMs';

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

package/lib/Components/Dispatcher/Entities/HostDispatchEntity.d.ts

@@ -0,0 +1,13 @@
+import { HostAppObject, HostAppObjectEntity, HostAppObjectRepo } from "../../../HostAppObject";
+import { Handler, Request } from "../../../Types";
+export declare abstract class HostDispatchEntity extends HostAppObjectEntity {
+    static readonly type = "HostDispatchEntity";
+    abstract appHandlerVersion: number;
+    abstract getRequestPayloadVersion(requestType: string): number | undefined;
+    abstract registerAppHandler: (appHandler: Handler) => void;
+    abstract dispatch: (request: Request) => void;
+    abstract formRequestAndDispatch: (type: string, version: number, payload?: object | undefined) => void;
+    static get(appObject: HostAppObject): HostDispatchEntity | undefined;
+    static getByID(id: string, appObjects: HostAppObjectRepo): HostDispatchEntity | undefined;
+}
+export declare function makeHostDispatchEntity(appObject: HostAppObject): HostDispatchEntity;

package/lib/Components/Dispatcher/Entities/HostDispatchEntity.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeHostDispatchEntity = exports.HostDispatchEntity = void 0;
+const HostAppObject_1 = require("../../../HostAppObject");
+class HostDispatchEntity extends HostAppObject_1.HostAppObjectEntity {
+    static get(appObject) {
+        const component = appObject.getComponent(HostDispatchEntity.type);
+        if (!component) {
+            appObject.appObjectRepo.submitWarning("AssetEntity.get", "Unable to find HostDispatchEntity on app object " + appObject.id);
+        }
+        return component;
+    }
+    static getByID(id, appObjects) {
+        const appObject = appObjects.get(id);
+        if (!appObject) {
+            appObjects.submitWarning("AssetEntity.getByID", "Unable to find app object " + id);
+            return;
+        }
+        return HostDispatchEntity.get(appObject);
+    }
+}
+exports.HostDispatchEntity = HostDispatchEntity;
+HostDispatchEntity.type = "HostDispatchEntity";
+function makeHostDispatchEntity(appObject) {
+    return new HostDispatchEntityImp(appObject);
+}
+exports.makeHostDispatchEntity = makeHostDispatchEntity;
+class HostDispatchEntityImp extends HostDispatchEntity {
+    constructor(appObject) {
+        super(appObject, HostDispatchEntity.type);
+        this._appHandlerVersion = 0;
+        this.appPayloadVersions = new Map();
+        this.registerAppHandler = (appHandler) => {
+            this.appHandler = appHandler;
+            this.getAppHandlerVersion();
+        };
+        this.getRequestPayloadVersion = (requestType) => {
+            return this.appPayloadVersions.get(requestType);
+        };
+        this.setupVersion = (version) => {
+            // Apps before app package version 2.27 will not reach this
+            this._appHandlerVersion = version;
+            this.getPayloadVersions();
+        };
+        this.getPayloadVersions = () => {
+            const type = "GET_APP_PAYLOAD_VERSION";
+            const payload = { callback: this.setupPayloadVersions };
+            this.formRequestAndDispatch(type, 2, payload);
+        };
+        this.setupPayloadVersions = (payloadVersion) => {
+            this.appPayloadVersions = payloadVersion;
+        };
+        this.dispatch = (request) => {
+            if (!this.appHandler) {
+                this.error("No app handler has been registered");
+                return;
+            }
+            this.appHandler(request);
+        };
+        this.formRequestAndDispatch = (type, version, payload) => {
+            if (!this.appHandler) {
+                this.error("No app handler has been registered");
+                return;
+            }
+            const request = {
+                type,
+                version,
+                payload
+            };
+            this.appHandler(request);
+        };
+    }
+    get appHandlerVersion() {
+        return this._appHandlerVersion;
+    }
+    getAppHandlerVersion() {
+        const type = "GET_APP_HANDLER_VERSION";
+        const payload = { callback: this.setupVersion };
+        try {
+            this.formRequestAndDispatch(type, 1, payload);
+        }
+        catch (_a) {
+            // All good. this is probably an older app
+        }
+    }
+}

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

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

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

package/lib/Components/Dispatcher/Mocks/MockDispatchAppDispatcherUC.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="jest" />
+import { HostAppObject } from "../../../HostAppObject";
+import { DispatchDisposeAppUC } from "../UCs";
+export declare class MockDispatchDisposeAppUC extends DispatchDisposeAppUC {
+    doDispatch: jest.Mock<any, any>;
+    constructor(appObject: HostAppObject);
+}