@vived/host 3.0.0

package/lib/Components/Handler/UCs/GetLinkedAssetsHandler.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeGetLinkedAssetsHandler = exports.GetLinkedAssetsHandler = void 0;
+const HostAppObject_1 = require("../../../HostAppObject");
+const Assets_1 = require("../../Assets");
+const Entities_1 = require("../Entities");
+class GetLinkedAssetsHandler extends HostAppObject_1.HostAppObjectUC {
+    constructor() {
+        super(...arguments);
+        this.requestType = "GET_LINKED_ASSETS";
+    }
+}
+exports.GetLinkedAssetsHandler = GetLinkedAssetsHandler;
+GetLinkedAssetsHandler.type = "GetLinkedAssetsHandler";
+function makeGetLinkedAssetsHandler(appObject) {
+    return new GetLinkedAssetsHandlerImp(appObject);
+}
+exports.makeGetLinkedAssetsHandler = makeGetLinkedAssetsHandler;
+class GetLinkedAssetsHandlerImp extends GetLinkedAssetsHandler {
+    constructor(appObject) {
+        super(appObject, GetLinkedAssetsHandler.type);
+        this.action = (assetID, type, callback) => {
+            const getAssetUC = this.getAssetUC;
+            if (!getAssetUC) {
+                this.error("Unable to find GetAssetUC");
+                callback(undefined);
+                return;
+            }
+            getAssetUC
+                .getAsset(assetID)
+                .then((baseAsset) => {
+                const { linkedAssets } = baseAsset;
+                const getLinkedAssetPromises = [];
+                linkedAssets.forEach((linkedAsset) => {
+                    if (linkedAsset.type === type) {
+                        getLinkedAssetPromises.push(getAssetUC.getAsset(linkedAsset.id));
+                    }
+                });
+                return Promise.all(getLinkedAssetPromises);
+            })
+                .then((linkedAssets) => {
+                const linkedAssetMetas = linkedAssets.map((asset) => {
+                    return {
+                        description: asset.description,
+                        id: asset.id,
+                        name: asset.name
+                    };
+                });
+                callback(linkedAssetMetas);
+            })
+                .catch((e) => {
+                this.appObjects.submitError("GetLinkedAssets", e.message);
+                callback(undefined);
+            });
+        };
+        this.handleRequest = (version, payload) => {
+            if (version === 1) {
+                const { assetID, callback, type } = this.castPayloadV1(payload);
+                this.action(assetID, type, callback);
+            }
+            else {
+                throw new Entities_1.UnsupportedRequestVersion(this.requestType, version);
+            }
+        };
+        const hostHandler = Entities_1.HostHandlerEntity.get(appObject);
+        if (!hostHandler) {
+            this.error("UC added to an entity that does not have HostHandlerEntity");
+            return;
+        }
+        hostHandler.registerRequestHandler(this);
+    }
+    get getAssetUC() {
+        return this.getCachedSingleton(Assets_1.GetAssetUC.type);
+    }
+    castPayloadV1(payload) {
+        const castPayload = payload;
+        if (!castPayload.assetID || !castPayload.callback || !castPayload.type) {
+            throw new Entities_1.UnableToParsePayload(this.requestType, 1, JSON.stringify(payload));
+        }
+        return castPayload;
+    }
+}

package/lib/Components/Handler/UCs/GoToNextStateHandler.d.ts

@@ -0,0 +1,9 @@
+import { HostAppObject, HostAppObjectUC } from "../../../HostAppObject";
+import { RequestHandler } from "../Entities";
+export declare abstract class GoToNextStateHandler extends HostAppObjectUC implements RequestHandler {
+    static readonly type = "GoToNextStateHandler";
+    readonly requestType = "GO_TO_NEXT_STATE";
+    abstract action: () => void;
+    abstract handleRequest: (version: number, payload?: unknown) => void;
+}
+export declare function makeGoToNextStateHandler(appObject: HostAppObject): GoToNextStateHandler;

package/lib/Components/Handler/UCs/GoToNextStateHandler.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeGoToNextStateHandler = exports.GoToNextStateHandler = void 0;
+const HostAppObject_1 = require("../../../HostAppObject");
+const Entities_1 = require("../Entities");
+class GoToNextStateHandler extends HostAppObject_1.HostAppObjectUC {
+    constructor() {
+        super(...arguments);
+        this.requestType = "GO_TO_NEXT_STATE";
+    }
+}
+exports.GoToNextStateHandler = GoToNextStateHandler;
+GoToNextStateHandler.type = "GoToNextStateHandler";
+function makeGoToNextStateHandler(appObject) {
+    return new GoToNextStateHandlerImp(appObject);
+}
+exports.makeGoToNextStateHandler = makeGoToNextStateHandler;
+class GoToNextStateHandlerImp extends GoToNextStateHandler {
+    constructor(appObject) {
+        super(appObject, GoToNextStateHandler.type);
+        this.payloadVersion = 1;
+        this.action = () => {
+            throw new Entities_1.ActionNotImplemented(this.requestType);
+        };
+        this.handleRequest = (version) => {
+            if (version === this.payloadVersion) {
+                this.action();
+            }
+            else {
+                throw new Entities_1.UnsupportedRequestVersion(this.requestType, version);
+            }
+        };
+        const hostHandler = Entities_1.HostHandlerEntity.get(appObject);
+        if (!hostHandler) {
+            this.error("UC added to an entity that does not have HostHandlerEntity");
+            return;
+        }
+        hostHandler.registerRequestHandler(this);
+    }
+}

package/lib/Components/Handler/UCs/GoToPreviousStateHandler.d.ts

@@ -0,0 +1,9 @@
+import { HostAppObject, HostAppObjectUC } from "../../../HostAppObject";
+import { RequestHandler } from "../Entities";
+export declare abstract class GoToPreviousStateHandler extends HostAppObjectUC implements RequestHandler {
+    static readonly type = "GoToPreviousStateHandler";
+    readonly requestType = "GO_TO_PREVIOUS_STATE";
+    abstract action: () => void;
+    abstract handleRequest: (version: number, payload?: unknown) => void;
+}
+export declare function makeGoToPreviousStateHandler(appObject: HostAppObject): GoToPreviousStateHandler;

package/lib/Components/Handler/UCs/GoToPreviousStateHandler.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeGoToPreviousStateHandler = exports.GoToPreviousStateHandler = void 0;
+const HostAppObject_1 = require("../../../HostAppObject");
+const Entities_1 = require("../Entities");
+class GoToPreviousStateHandler extends HostAppObject_1.HostAppObjectUC {
+    constructor() {
+        super(...arguments);
+        this.requestType = "GO_TO_PREVIOUS_STATE";
+    }
+}
+exports.GoToPreviousStateHandler = GoToPreviousStateHandler;
+GoToPreviousStateHandler.type = "GoToPreviousStateHandler";
+function makeGoToPreviousStateHandler(appObject) {
+    return new GoToPreviousStateHandlerImp(appObject);
+}
+exports.makeGoToPreviousStateHandler = makeGoToPreviousStateHandler;
+class GoToPreviousStateHandlerImp extends GoToPreviousStateHandler {
+    constructor(appObject) {
+        super(appObject, GoToPreviousStateHandler.type);
+        this.payloadVersion = 1;
+        this.action = () => {
+            throw new Entities_1.ActionNotImplemented(this.requestType);
+        };
+        this.handleRequest = (version) => {
+            if (version === this.payloadVersion) {
+                this.action();
+            }
+            else {
+                throw new Entities_1.UnsupportedRequestVersion(this.requestType, version);
+            }
+        };
+        const hostHandler = Entities_1.HostHandlerEntity.get(appObject);
+        if (!hostHandler) {
+            this.error("UC added to an entity that does not have HostHandlerEntity");
+            return;
+        }
+        hostHandler.registerRequestHandler(this);
+    }
+}

package/lib/Components/Handler/UCs/HasNextStateHandler.d.ts

@@ -0,0 +1,10 @@
+import { HostAppObject, HostAppObjectUC } from "../../../HostAppObject";
+import { RequestHandler } from "../Entities";
+export declare type HasNextStateAction = (callback: (hasNextState: boolean) => void) => void;
+export declare abstract class HasNextStateHandler extends HostAppObjectUC implements RequestHandler {
+    static readonly type = "HasNextStateHandler";
+    readonly requestType = "HAS_NEXT_STATE";
+    abstract action: HasNextStateAction;
+    abstract handleRequest: (version: number, payload?: unknown) => void;
+}
+export declare function makeHasNextStateHandler(appObject: HostAppObject): HasNextStateHandler;

package/lib/Components/Handler/UCs/HasNextStateHandler.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeHasNextStateHandler = exports.HasNextStateHandler = void 0;
+const HostAppObject_1 = require("../../../HostAppObject");
+const Entities_1 = require("../Entities");
+class HasNextStateHandler extends HostAppObject_1.HostAppObjectUC {
+    constructor() {
+        super(...arguments);
+        this.requestType = "HAS_NEXT_STATE";
+    }
+}
+exports.HasNextStateHandler = HasNextStateHandler;
+HasNextStateHandler.type = "HasNextStateHandler";
+function makeHasNextStateHandler(appObject) {
+    return new HasNextStateHandlerImp(appObject);
+}
+exports.makeHasNextStateHandler = makeHasNextStateHandler;
+class HasNextStateHandlerImp extends HasNextStateHandler {
+    constructor(appObject) {
+        super(appObject, HasNextStateHandler.type);
+        this.action = () => {
+            throw new Entities_1.ActionNotImplemented(this.requestType);
+        };
+        this.handleRequest = (version, payload) => {
+            if (version === 1) {
+                const { callback } = this.castPayloadV1(payload);
+                this.action(callback);
+            }
+            else {
+                throw new Entities_1.UnsupportedRequestVersion(this.requestType, version);
+            }
+        };
+        const hostHandler = Entities_1.HostHandlerEntity.get(appObject);
+        if (!hostHandler) {
+            this.error("UC added to an entity that does not have HostHandlerEntity");
+            return;
+        }
+        hostHandler.registerRequestHandler(this);
+    }
+    castPayloadV1(payload) {
+        const castPayload = payload;
+        if (!castPayload.callback) {
+            throw new Entities_1.UnableToParsePayload(this.requestType, 1, JSON.stringify(payload));
+        }
+        return castPayload;
+    }
+}

package/lib/Components/Handler/UCs/HasPreviousStateHandler.d.ts

@@ -0,0 +1,10 @@
+import { HostAppObject, HostAppObjectUC } from "../../../HostAppObject";
+import { RequestHandler } from "../Entities";
+export declare type HasPreviousStateAction = (callback: (hasNextState: boolean) => void) => void;
+export declare abstract class HasPreviousStateHandler extends HostAppObjectUC implements RequestHandler {
+    static readonly type = "HasPreviousStateHandler";
+    readonly requestType = "HAS_PREVIOUS_STATE";
+    abstract action: HasPreviousStateAction;
+    abstract handleRequest: (version: number, payload?: unknown) => void;
+}
+export declare function makeHasPreviousStateHandler(appObject: HostAppObject): HasPreviousStateHandler;

package/lib/Components/Handler/UCs/HasPreviousStateHandler.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeHasPreviousStateHandler = exports.HasPreviousStateHandler = void 0;
+const HostAppObject_1 = require("../../../HostAppObject");
+const Entities_1 = require("../Entities");
+class HasPreviousStateHandler extends HostAppObject_1.HostAppObjectUC {
+    constructor() {
+        super(...arguments);
+        this.requestType = "HAS_PREVIOUS_STATE";
+    }
+}
+exports.HasPreviousStateHandler = HasPreviousStateHandler;
+HasPreviousStateHandler.type = "HasPreviousStateHandler";
+function makeHasPreviousStateHandler(appObject) {
+    return new HasPreviousStateHandlerImp(appObject);
+}
+exports.makeHasPreviousStateHandler = makeHasPreviousStateHandler;
+class HasPreviousStateHandlerImp extends HasPreviousStateHandler {
+    constructor(appObject) {
+        super(appObject, HasPreviousStateHandler.type);
+        this.action = () => {
+            throw new Entities_1.ActionNotImplemented(this.requestType);
+        };
+        this.handleRequest = (version, payload) => {
+            if (version === 1) {
+                const { callback } = this.castPayloadV1(payload);
+                this.action(callback);
+            }
+            else {
+                throw new Entities_1.UnsupportedRequestVersion(this.requestType, version);
+            }
+        };
+        const hostHandler = Entities_1.HostHandlerEntity.get(appObject);
+        if (!hostHandler) {
+            this.error("UC added to an entity that does not have HostHandlerEntity");
+            return;
+        }
+        hostHandler.registerRequestHandler(this);
+    }
+    castPayloadV1(payload) {
+        const castPayload = payload;
+        if (!castPayload.callback) {
+            throw new Entities_1.UnableToParsePayload(this.requestType, 1, JSON.stringify(payload));
+        }
+        return castPayload;
+    }
+}

package/lib/Components/Handler/UCs/IsAssetFetchedHandler.d.ts

@@ -0,0 +1,14 @@
+import { HostAppObject, HostAppObjectUC } from "../../../HostAppObject";
+import { RequestHandler } from "../Entities";
+export interface IsAssetFetchedActionDTO {
+    assetId: string;
+    callback: (isFetched: boolean) => void;
+}
+export declare type IsAssetFetchedAction = (confirmData: IsAssetFetchedActionDTO) => void;
+export declare abstract class IsAssetFetchedHandler extends HostAppObjectUC implements RequestHandler {
+    static readonly type = "IsAssetFetchedHandler";
+    readonly requestType = "IS_ASSET_FILE_FETCHED";
+    abstract action: IsAssetFetchedAction;
+    abstract handleRequest: (version: number, payload?: unknown) => void;
+}
+export declare function makeIsAssetFetchedHandler(appObject: HostAppObject): IsAssetFetchedHandler;

package/lib/Components/Handler/UCs/IsAssetFetchedHandler.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeIsAssetFetchedHandler = exports.IsAssetFetchedHandler = void 0;
+const HostAppObject_1 = require("../../../HostAppObject");
+const Entities_1 = require("../Entities");
+class IsAssetFetchedHandler extends HostAppObject_1.HostAppObjectUC {
+    constructor() {
+        super(...arguments);
+        this.requestType = "IS_ASSET_FILE_FETCHED";
+    }
+}
+exports.IsAssetFetchedHandler = IsAssetFetchedHandler;
+IsAssetFetchedHandler.type = "IsAssetFetchedHandler";
+function makeIsAssetFetchedHandler(appObject) {
+    return new IsAssetFetchedHandlerImp(appObject);
+}
+exports.makeIsAssetFetchedHandler = makeIsAssetFetchedHandler;
+class IsAssetFetchedHandlerImp extends IsAssetFetchedHandler {
+    constructor(appObject) {
+        super(appObject, IsAssetFetchedHandler.type);
+        this.action = () => {
+            throw new Entities_1.ActionNotImplemented(this.requestType);
+        };
+        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 hostHandler = Entities_1.HostHandlerEntity.get(appObject);
+        if (!hostHandler) {
+            this.error("UC added to an entity that does not have HostHandlerEntity");
+            return;
+        }
+        hostHandler.registerRequestHandler(this);
+    }
+    castPayloadV1(payload) {
+        const castPayload = payload;
+        if (castPayload.assetId === undefined ||
+            castPayload.callback === undefined) {
+            throw new Entities_1.UnableToParsePayload(this.requestType, 1, JSON.stringify(payload));
+        }
+        return castPayload;
+    }
+}

package/lib/Components/Handler/UCs/IsZSpaceAvailableHandler.d.ts

@@ -0,0 +1,10 @@
+import { HostAppObject, HostAppObjectUC } from "../../../HostAppObject";
+import { RequestHandler } from "../Entities";
+export declare type IsZSpaceAvailableAction = (callback: (isZSpaceAvailable: boolean) => void) => void;
+export declare abstract class IsZSpaceAvailableHandler extends HostAppObjectUC implements RequestHandler {
+    static readonly type = "IsZSpaceAvailableHandler";
+    readonly requestType = "IS_ZSPACE_AVAILABLE";
+    abstract action: IsZSpaceAvailableAction;
+    abstract handleRequest: (version: number, payload?: unknown) => void;
+}
+export declare function makeIsZSpaceAvailableHandler(appObject: HostAppObject): IsZSpaceAvailableHandler;

package/lib/Components/Handler/UCs/IsZSpaceAvailableHandler.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeIsZSpaceAvailableHandler = exports.IsZSpaceAvailableHandler = void 0;
+const HostAppObject_1 = require("../../../HostAppObject");
+const Entities_1 = require("../Entities");
+class IsZSpaceAvailableHandler extends HostAppObject_1.HostAppObjectUC {
+    constructor() {
+        super(...arguments);
+        this.requestType = "IS_ZSPACE_AVAILABLE";
+    }
+}
+exports.IsZSpaceAvailableHandler = IsZSpaceAvailableHandler;
+IsZSpaceAvailableHandler.type = "IsZSpaceAvailableHandler";
+function makeIsZSpaceAvailableHandler(appObject) {
+    return new IsZSpaceAvailableHandlerImp(appObject);
+}
+exports.makeIsZSpaceAvailableHandler = makeIsZSpaceAvailableHandler;
+class IsZSpaceAvailableHandlerImp extends IsZSpaceAvailableHandler {
+    constructor(appObject) {
+        super(appObject, IsZSpaceAvailableHandler.type);
+        this.action = () => {
+            throw new Entities_1.ActionNotImplemented(this.requestType);
+        };
+        this.handleRequest = (version, payload) => {
+            if (version === 1) {
+                const { callback } = this.castPayloadV1(payload);
+                this.action(callback);
+            }
+            else {
+                throw new Entities_1.UnsupportedRequestVersion(this.requestType, version);
+            }
+        };
+        const hostHandler = Entities_1.HostHandlerEntity.get(appObject);
+        if (!hostHandler) {
+            this.error("UC added to an entity that does not have HostHandlerEntity");
+            return;
+        }
+        hostHandler.registerRequestHandler(this);
+    }
+    castPayloadV1(payload) {
+        const castPayload = payload;
+        if (!castPayload.callback) {
+            throw new Entities_1.UnableToParsePayload(this.requestType, 1, JSON.stringify(payload));
+        }
+        return castPayload;
+    }
+}

package/lib/Components/Handler/UCs/NewActivityAssetHandler.d.ts

@@ -0,0 +1,10 @@
+import { HostAppObject, HostAppObjectUC } from "../../../HostAppObject";
+import { RequestHandler } from "../Entities";
+export declare type NewActivityAssetAction = (file: File, callback: (blobURL: string | undefined) => void) => void;
+export declare abstract class NewActivityAssetHandler extends HostAppObjectUC implements RequestHandler {
+    static readonly type = "NewActivityAssetHandler";
+    readonly requestType = "NEW_ACTIVITY_ASSET";
+    abstract action: NewActivityAssetAction;
+    abstract handleRequest: (version: number, payload?: unknown) => void;
+}
+export declare function makeNewActivityAssetAction(appObject: HostAppObject): NewActivityAssetHandler;

package/lib/Components/Handler/UCs/NewActivityAssetHandler.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeNewActivityAssetAction = exports.NewActivityAssetHandler = void 0;
+const HostAppObject_1 = require("../../../HostAppObject");
+const Entities_1 = require("../Entities");
+class NewActivityAssetHandler extends HostAppObject_1.HostAppObjectUC {
+    constructor() {
+        super(...arguments);
+        this.requestType = "NEW_ACTIVITY_ASSET";
+    }
+}
+exports.NewActivityAssetHandler = NewActivityAssetHandler;
+NewActivityAssetHandler.type = "NewActivityAssetHandler";
+function makeNewActivityAssetAction(appObject) {
+    return new NewActivityAssetHandlerImp(appObject);
+}
+exports.makeNewActivityAssetAction = makeNewActivityAssetAction;
+class NewActivityAssetHandlerImp extends NewActivityAssetHandler {
+    constructor(appObject) {
+        super(appObject, NewActivityAssetHandler.type);
+        this.action = () => {
+            throw new Entities_1.ActionNotImplemented(this.requestType);
+        };
+        this.handleRequest = (version, payload) => {
+            if (version === 1) {
+                const { file, callback } = this.castPayloadV1(payload);
+                this.action(file, callback);
+            }
+            else {
+                throw new Entities_1.UnsupportedRequestVersion(this.requestType, version);
+            }
+        };
+        const hostHandler = Entities_1.HostHandlerEntity.get(appObject);
+        if (!hostHandler) {
+            this.error("UC added to an entity that does not have HostHandlerEntity");
+            return;
+        }
+        hostHandler.registerRequestHandler(this);
+    }
+    castPayloadV1(payload) {
+        const castPayload = payload;
+        if (!castPayload.file || !castPayload.callback) {
+            throw new Entities_1.UnableToParsePayload(this.requestType, 1, JSON.stringify(payload));
+        }
+        return castPayload;
+    }
+}

package/lib/Components/Handler/UCs/OnAppIsReadyHandler.d.ts

@@ -0,0 +1,9 @@
+import { HostAppObject, HostAppObjectUC } from "../../../HostAppObject";
+import { RequestHandler } from "../Entities";
+export declare abstract class OnAppIsReadyHandler extends HostAppObjectUC implements RequestHandler {
+    static readonly type = "OnAppIsReadyHandler";
+    readonly requestType = "APP_IS_READY";
+    abstract action: () => void;
+    abstract handleRequest: (version: number, payload?: unknown) => void;
+}
+export declare function makeOnAppIsReadyHandler(appObject: HostAppObject): OnAppIsReadyHandler;

package/lib/Components/Handler/UCs/OnAppIsReadyHandler.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeOnAppIsReadyHandler = exports.OnAppIsReadyHandler = void 0;
+const HostAppObject_1 = require("../../../HostAppObject");
+const Entities_1 = require("../Entities");
+class OnAppIsReadyHandler extends HostAppObject_1.HostAppObjectUC {
+    constructor() {
+        super(...arguments);
+        this.requestType = "APP_IS_READY";
+    }
+}
+exports.OnAppIsReadyHandler = OnAppIsReadyHandler;
+OnAppIsReadyHandler.type = "OnAppIsReadyHandler";
+function makeOnAppIsReadyHandler(appObject) {
+    return new OnAppIsReadyHandlerImp(appObject);
+}
+exports.makeOnAppIsReadyHandler = makeOnAppIsReadyHandler;
+class OnAppIsReadyHandlerImp extends OnAppIsReadyHandler {
+    constructor(appObject) {
+        super(appObject, OnAppIsReadyHandler.type);
+        this.action = () => {
+            throw new Entities_1.ActionNotImplemented(this.requestType);
+        };
+        this.handleRequest = (version) => {
+            if (version === 1) {
+                this.action();
+            }
+            else {
+                throw new Entities_1.UnsupportedRequestVersion(this.requestType, version);
+            }
+        };
+        const hostHandler = Entities_1.HostHandlerEntity.get(appObject);
+        if (!hostHandler) {
+            this.error("UC added to an entity that does not have HostHandlerEntity");
+            return;
+        }
+        hostHandler.registerRequestHandler(this);
+    }
+}

package/lib/Components/Handler/UCs/OnStateChangeHandler.d.ts

@@ -0,0 +1,18 @@
+import { HostAppObject, HostAppObjectUC } from "../../../HostAppObject";
+import { RequestHandler } from "../Entities";
+export declare type OnStateChangeAction = (state: object, assets: string[], validationErrorMessage?: string) => void;
+export declare abstract class OnStateChangeHandler extends HostAppObjectUC implements RequestHandler {
+    static readonly type = "OnStateChangeHandler";
+    readonly requestType = "ON_STATE_CHANGE";
+    abstract action: OnStateChangeAction;
+    abstract handleRequest: (version: number, payload?: unknown) => void;
+}
+export declare function makeOnStateChangeHandler(appObject: HostAppObject): OnStateChangeHandler;
+export declare class OnStateChangeHandlerImp extends OnStateChangeHandler {
+    action: OnStateChangeAction;
+    handleRequest: (version: number, payload: unknown) => void;
+    private castPayloadV1;
+    private castPayloadV2;
+    private castPayloadV3;
+    constructor(appObject: HostAppObject);
+}

package/lib/Components/Handler/UCs/OnStateChangeHandler.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OnStateChangeHandlerImp = exports.makeOnStateChangeHandler = exports.OnStateChangeHandler = void 0;
+const HostAppObject_1 = require("../../../HostAppObject");
+const Entities_1 = require("../Entities");
+class OnStateChangeHandler extends HostAppObject_1.HostAppObjectUC {
+    constructor() {
+        super(...arguments);
+        this.requestType = "ON_STATE_CHANGE";
+    }
+}
+exports.OnStateChangeHandler = OnStateChangeHandler;
+OnStateChangeHandler.type = "OnStateChangeHandler";
+function makeOnStateChangeHandler(appObject) {
+    return new OnStateChangeHandlerImp(appObject);
+}
+exports.makeOnStateChangeHandler = makeOnStateChangeHandler;
+class OnStateChangeHandlerImp extends OnStateChangeHandler {
+    constructor(appObject) {
+        super(appObject, OnStateChangeHandler.type);
+        this.action = () => {
+            throw new Entities_1.ActionNotImplemented(this.requestType);
+        };
+        this.handleRequest = (version, payload) => {
+            if (version === 1) {
+                const { stateObject } = this.castPayloadV1(payload);
+                this.action(stateObject, []);
+            }
+            else if (version === 2) {
+                const { stateObject, validationErrorMessage } = this.castPayloadV2(payload);
+                this.action(stateObject, [], validationErrorMessage);
+            }
+            else if (version === 3) {
+                const { stateObject, assets, validationErrorMessage } = this.castPayloadV3(payload);
+                this.action(stateObject, assets, validationErrorMessage);
+            }
+            else {
+                throw new Entities_1.UnsupportedRequestVersion(this.requestType, version);
+            }
+        };
+        const hostHandler = Entities_1.HostHandlerEntity.get(appObject);
+        if (!hostHandler) {
+            this.error("UC added to an entity that does not have HostHandlerEntity");
+            return;
+        }
+        hostHandler.registerRequestHandler(this);
+    }
+    castPayloadV1(payload) {
+        const castPayload = payload;
+        if (castPayload.stateObject === undefined) {
+            throw new Entities_1.UnableToParsePayload(this.requestType, 1, JSON.stringify(payload));
+        }
+        return castPayload;
+    }
+    castPayloadV2(payload) {
+        const castPayload = payload;
+        if (castPayload.stateObject === undefined) {
+            throw new Entities_1.UnableToParsePayload(this.requestType, 2, JSON.stringify(payload));
+        }
+        return castPayload;
+    }
+    castPayloadV3(payload) {
+        const castPayload = payload;
+        if (castPayload.stateObject === undefined) {
+            throw new Entities_1.UnableToParsePayload(this.requestType, 3, JSON.stringify(payload));
+        }
+        return castPayload;
+    }
+}
+exports.OnStateChangeHandlerImp = OnStateChangeHandlerImp;

package/lib/Components/Handler/UCs/OnStateCompleteHandler.d.ts

@@ -0,0 +1,9 @@
+import { HostAppObject, HostAppObjectUC } from "../../../HostAppObject";
+import { RequestHandler } from "../Entities";
+export declare abstract class OnStateCompleteHandler extends HostAppObjectUC implements RequestHandler {
+    static readonly type = "OnStateCompleteHandler";
+    readonly requestType = "ON_STATE_COMPLETED";
+    abstract action: () => void;
+    abstract handleRequest: (version: number, payload?: unknown) => void;
+}
+export declare function makeOnStateCompleteHandler(appObject: HostAppObject): OnStateCompleteHandler;