@vived/host 3.11.1 → 4.0.1

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

@@ -1,52 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeGoToPreviousStateHandler = exports.GoToPreviousStateHandler = void 0;
-const HostAppObject_1 = require("../../../HostAppObject");
-const UCs_1 = require("../../StateMachine/UCs");
-const Entities_1 = require("../../StateMachine/Entities");
-const Entities_2 = 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 = () => {
-            var _a, _b;
-            const prevState = (_a = this.stateMachine) === null || _a === void 0 ? void 0 : _a.previousState;
-            if (prevState) {
-                (_b = this.transitionToStateUC) === null || _b === void 0 ? void 0 : _b.transitionToState(prevState);
-            }
-        };
-        this.handleRequest = (version) => {
-            if (version === this.payloadVersion) {
-                this.action();
-            }
-            else {
-                throw new Entities_2.UnsupportedRequestVersion(this.requestType, version);
-            }
-        };
-        const hostHandler = Entities_2.HostHandlerEntity.get(appObject);
-        if (!hostHandler) {
-            this.error("UC added to an entity that does not have HostHandlerEntity");
-            return;
-        }
-        hostHandler.registerRequestHandler(this);
-    }
-    get stateMachine() {
-        return this.getCachedSingleton(Entities_1.HostStateMachine.type);
-    }
-    get transitionToStateUC() {
-        return this.getCachedSingleton(UCs_1.TransitionToStateUC.type);
-    }
-}

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

@@ -1,10 +0,0 @@
-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

@@ -1,60 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeHasNextStateHandler = exports.HasNextStateHandler = void 0;
-const HostAppObject_1 = require("../../../HostAppObject");
-const StateMachine_1 = require("../../StateMachine");
-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 = (cb) => {
-            if (!this.stateMachine) {
-                cb(false);
-                return;
-            }
-            if (this.stateMachine.nextState) {
-                cb(true);
-            }
-            else {
-                cb(false);
-            }
-        };
-        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);
-    }
-    get stateMachine() {
-        return this.getCachedSingleton(StateMachine_1.HostStateMachine.type);
-    }
-    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

@@ -1,10 +0,0 @@
-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

@@ -1,60 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeHasPreviousStateHandler = exports.HasPreviousStateHandler = void 0;
-const HostAppObject_1 = require("../../../HostAppObject");
-const StateMachine_1 = require("../../StateMachine");
-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 = (cb) => {
-            if (!this.stateMachine) {
-                cb(false);
-                return;
-            }
-            if (this.stateMachine.previousState) {
-                cb(true);
-            }
-            else {
-                cb(false);
-            }
-        };
-        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);
-    }
-    get stateMachine() {
-        return this.getCachedSingleton(StateMachine_1.HostStateMachine.type);
-    }
-    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

@@ -1,14 +0,0 @@
-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

@@ -1,48 +0,0 @@
-"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

@@ -1,10 +0,0 @@
-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

@@ -1,56 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeIsZSpaceAvailableHandler = exports.IsZSpaceAvailableHandler = void 0;
-const HostAppObject_1 = require("../../../HostAppObject");
-const ZSpaceHost_1 = require("../../ZSpaceHost");
-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 = (callback) => {
-            if (this.zSpace) {
-                callback(this.zSpace.isSupported);
-            }
-            else {
-                callback(false);
-            }
-        };
-        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);
-    }
-    get zSpace() {
-        return this.getCachedSingleton(ZSpaceHost_1.ZSpaceHostEntity.type);
-    }
-    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

@@ -1,10 +0,0 @@
-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

@@ -1,47 +0,0 @@
-"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

@@ -1,9 +0,0 @@
-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

@@ -1,47 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeOnAppIsReadyHandler = exports.OnAppIsReadyHandler = void 0;
-const HostAppObject_1 = require("../../../HostAppObject");
-const Apps_1 = require("../../Apps");
-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 = () => {
-            if (!this.app) {
-                this.error("No App");
-                return;
-            }
-            this.app.state = Apps_1.AppState.READY;
-        };
-        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);
-    }
-    get app() {
-        return this.getCachedLocalComponent(Apps_1.AppEntity.type);
-    }
-}

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

@@ -1,20 +0,0 @@
-import { HostAppObject, HostAppObjectUC } from "../../../HostAppObject";
-import { RequestHandler } from "../Entities";
-export declare type OnStateChangeAction = (state: object, assets: string[], validationErrorMessage?: string, responseType?: 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 {
-    private get editStateEntity();
-    action: OnStateChangeAction;
-    handleRequest: (version: number, payload: unknown) => void;
-    private castPayloadV1;
-    private castPayloadV2;
-    private castPayloadV3;
-    private castPayloadV4;
-    constructor(appObject: HostAppObject);
-}

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

@@ -1,108 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.OnStateChangeHandlerImp = exports.makeOnStateChangeHandler = exports.OnStateChangeHandler = void 0;
-const HostAppObject_1 = require("../../../HostAppObject");
-const HostStateEntity_1 = require("../../StateMachine/Entities/HostStateEntity");
-const HostEditingStateEntity_1 = require("../../StateMachine/Entities/HostEditingStateEntity");
-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 = (state, assets, validationErrorMessage, responseType) => {
-            if (!this.editStateEntity)
-                return;
-            const editingState = this.editStateEntity.editingState;
-            if (!editingState)
-                return;
-            editingState.setStateData(state);
-            editingState.assets = assets;
-            this.editStateEntity.stateValidationMessage = validationErrorMessage;
-            if (!responseType)
-                return;
-            const response = responseLookupMap.get(responseType.toUpperCase());
-            if (!response) {
-                this.warn(`Unable to parse ${responseType} into an expected response`);
-            }
-            editingState.expectedResponse = response;
-        };
-        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 if (version === 4) {
-                const { stateObject, assets, validationErrorMessage, responseType } = this.castPayloadV4(payload);
-                this.action(stateObject, assets, validationErrorMessage, responseType);
-            }
-            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 editStateEntity() {
-        return this.getCachedSingleton(HostEditingStateEntity_1.HostEditingStateEntity.type);
-    }
-    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;
-    }
-    castPayloadV4(payload) {
-        const castPayload = payload;
-        if (castPayload.stateObject === undefined) {
-            throw new Entities_1.UnableToParsePayload(this.requestType, 3, JSON.stringify(payload));
-        }
-        return castPayload;
-    }
-}
-exports.OnStateChangeHandlerImp = OnStateChangeHandlerImp;
-const responseLookupMap = new Map([
-    ["HIT", HostStateEntity_1.ChallengeResponse.HIT],
-    ["MULTIHIT", HostStateEntity_1.ChallengeResponse.MULTIHIT],
-    ["NONE", HostStateEntity_1.ChallengeResponse.NONE],
-    ["PROGRESS", HostStateEntity_1.ChallengeResponse.PROGRESS],
-    ["QUALITY", HostStateEntity_1.ChallengeResponse.QUALITY],
-    ["SCORE", HostStateEntity_1.ChallengeResponse.SCORE]
-]);

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

@@ -1,9 +0,0 @@
-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;

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

@@ -1,56 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeOnStateCompleteHandler = exports.OnStateCompleteHandler = void 0;
-const HostAppObject_1 = require("../../../HostAppObject");
-const StateMachine_1 = require("../../StateMachine");
-const Entities_1 = require("../Entities");
-class OnStateCompleteHandler extends HostAppObject_1.HostAppObjectUC {
-    constructor() {
-        super(...arguments);
-        this.requestType = "ON_STATE_COMPLETED";
-    }
-}
-exports.OnStateCompleteHandler = OnStateCompleteHandler;
-OnStateCompleteHandler.type = "OnStateCompleteHandler";
-function makeOnStateCompleteHandler(appObject) {
-    return new OnStateCompleteHandlerImp(appObject);
-}
-exports.makeOnStateCompleteHandler = makeOnStateCompleteHandler;
-class OnStateCompleteHandlerImp extends OnStateCompleteHandler {
-    constructor(appObject) {
-        super(appObject, OnStateCompleteHandler.type);
-        this.action = () => {
-            var _a, _b, _c;
-            const nextState = (_a = this.stateMachine) === null || _a === void 0 ? void 0 : _a.nextState;
-            if (nextState) {
-                (_b = this.transitionToStateUC) === null || _b === void 0 ? void 0 : _b.transitionToState(nextState);
-            }
-            else {
-                (_c = this.endActivityUC) === null || _c === void 0 ? void 0 : _c.end();
-            }
-        };
-        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);
-    }
-    get stateMachine() {
-        return this.getCachedSingleton(StateMachine_1.HostStateMachine.type);
-    }
-    get transitionToStateUC() {
-        return this.getCachedSingleton(StateMachine_1.TransitionToStateUC.type);
-    }
-    get endActivityUC() {
-        return this.getCachedSingleton(StateMachine_1.EndActivityUC.type);
-    }
-}

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

@@ -1,10 +0,0 @@
-import { HostAppObject, HostAppObjectUC } from "../../../HostAppObject";
-import { RequestHandler } from "../Entities";
-export declare type RegisterStylesheetsAction = (stylesheets: string[]) => void;
-export declare abstract class RegisterExternalStyleSheetsHandler extends HostAppObjectUC implements RequestHandler {
-    static readonly type = "RegisterExternalStyleSheetsHandler";
-    readonly requestType = "REGISTER_EXTERNAL_STYLESHEETS";
-    abstract action: RegisterStylesheetsAction;
-    abstract handleRequest: (version: number, payload?: unknown) => void;
-}
-export declare function makeRegisterExternalStyleSheetsHandler(appObject: HostAppObject): RegisterExternalStyleSheetsHandler;