@vived/app 2.26.0 → 2.28.0

package/lib/Entities/AppBoundary.d.ts

@@ -0,0 +1,6 @@
+export declare type Handler = (request: Request) => void;
+export interface Request {
+    type: string;
+    version: number;
+    payload?: unknown;
+}

package/lib/Entities/AppBoundary.js

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

package/lib/Entities/AppDispatcher.d.ts

@@ -0,0 +1,27 @@
+import { Handler, Request } from "./AppBoundary";
+export interface AssetMetaDTO {
+    id: string;
+    name: string;
+    description: string;
+}
+export declare abstract class AppDispatcher {
+    abstract registerHostHandler: (hostHandler: Handler) => void;
+    abstract dispatch: (request: Request) => void;
+    abstract stateHasChanged: (state: object, validationErrorMessage?: string) => void;
+    abstract stateIsCompleted: () => void;
+    abstract getAppAssetsURL: () => Promise<string>;
+    abstract registerExternalStylesheets: (stylesheets: string[]) => void;
+    abstract appIsReady: () => void;
+    abstract log: (sender: string, message: string) => void;
+    abstract logWarnign: (sender: string, message: string) => void;
+    abstract logError: (sender: string, message: string) => void;
+    abstract logFatalError: (sender: string, message: string) => void;
+    abstract submitHitResult: (success: boolean, description: string) => void;
+    abstract submitMultiHitResult: (hits: number, misses: number, unanswered: number, description: string) => void;
+    abstract submitQualityResult: (stars: number, maxStars: number, description: string) => void;
+    abstract submitScoreResult: (score: number, maxScore: number, description: string) => void;
+    abstract getAssetBlob: (assetID: string) => Promise<string>;
+    abstract getAssetMeta: (assetID: string) => Promise<AssetMetaDTO>;
+    abstract getAssetsForOwner: (ownerID: string) => Promise<AssetMetaDTO[]>;
+}
+export declare function makeAppDispatcher(): AppDispatcher;

package/lib/Entities/AppDispatcher.js

@@ -0,0 +1,218 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeAppDispatcher = exports.AppDispatcher = void 0;
+class AppDispatcher {
+}
+exports.AppDispatcher = AppDispatcher;
+function makeAppDispatcher() {
+    return new AppDistpatcherImp();
+}
+exports.makeAppDispatcher = makeAppDispatcher;
+class AppDistpatcherImp extends AppDispatcher {
+    constructor() {
+        super(...arguments);
+        this.registerHostHandler = (hostHandler) => {
+            this.hostHandler = hostHandler;
+        };
+        this.dispatch = (request) => {
+            if (!this.hostHandler) {
+                console.error("[AppDispatcher] No host handler has been registered");
+                return;
+            }
+            this.hostHandler(request);
+        };
+        this.stateHasChanged = (stateObject, validationErrorMessage) => {
+            const payload = {
+                stateObject,
+                validationErrorMessage,
+            };
+            this.formRequestAndDispatch("ON_STATE_CHANGE", 2, payload);
+        };
+        this.stateIsCompleted = () => {
+            this.formRequestAndDispatch("ON_STATE_COMPLETED", 1);
+        };
+        this.getAppAssetsURL = () => {
+            return new Promise((resolve, reject) => {
+                const callback = (url) => {
+                    if (!url) {
+                        reject(new Error("URL to asset folder is empty"));
+                    }
+                    else {
+                        resolve(url);
+                    }
+                };
+                const payload = {
+                    callback,
+                };
+                if (!this.hostHandler) {
+                    reject(new Error("No host handler has been registered"));
+                }
+                else {
+                    this.formRequestAndDispatch("GET_APP_ASSET_URL", 1, payload);
+                }
+            });
+        };
+        this.registerExternalStylesheets = (stylesheets) => {
+            const payload = {
+                stylesheets,
+            };
+            this.formRequestAndDispatch("REGISTER_EXTERNAL_STYLESHEETS", 1, payload);
+        };
+        this.appIsReady = () => {
+            this.formRequestAndDispatch("APP_IS_READY", 1);
+        };
+        this.submitLog = (sender, message) => {
+            const payload = {
+                sender,
+                severity: "LOG",
+                message,
+            };
+            this.formRequestAndDispatch("SUBMIT_LOG", 1, payload);
+        };
+        this.log = (sender, message) => {
+            const payload = {
+                sender,
+                severity: "LOG",
+                message,
+            };
+            this.formRequestAndDispatch("SUBMIT_LOG", 1, payload);
+        };
+        this.logWarnign = (sender, message) => {
+            const payload = {
+                sender,
+                severity: "WARNING",
+                message,
+            };
+            this.formRequestAndDispatch("SUBMIT_LOG", 1, payload);
+        };
+        this.logError = (sender, message) => {
+            const payload = {
+                sender,
+                severity: "ERROR",
+                message,
+            };
+            this.formRequestAndDispatch("SUBMIT_LOG", 1, payload);
+        };
+        this.logFatalError = (sender, message) => {
+            const payload = {
+                sender,
+                severity: "FATAL",
+                message,
+            };
+            this.formRequestAndDispatch("SUBMIT_LOG", 1, payload);
+        };
+        this.submitHitResult = (success, description) => {
+            const payload = {
+                resultType: "HIT_V1",
+                description,
+                result: {
+                    success,
+                },
+            };
+            this.formRequestAndDispatch("SUBMIT_RESULTS", 3, payload);
+        };
+        this.submitMultiHitResult = (hits, misses, unanswered, description) => {
+            const payload = {
+                resultType: "MULTIHIT_V1",
+                description,
+                result: {
+                    hits,
+                    misses,
+                    unanswered,
+                },
+            };
+            this.formRequestAndDispatch("SUBMIT_RESULTS", 3, payload);
+        };
+        this.submitQualityResult = (stars, maxStars, description) => {
+            const payload = {
+                resultType: "QUALITY_V1",
+                description,
+                result: {
+                    stars,
+                    maxStars,
+                },
+            };
+            this.formRequestAndDispatch("SUBMIT_RESULTS", 3, payload);
+        };
+        this.submitScoreResult = (score, maxScore, description) => {
+            const payload = {
+                resultType: "SCORE_V1",
+                description,
+                result: {
+                    score,
+                    maxScore,
+                },
+            };
+            this.formRequestAndDispatch("SUBMIT_RESULTS", 3, payload);
+        };
+        this.getAssetBlob = (assetID) => {
+            return new Promise((resolve, reject) => {
+                const callback = (blobURL) => {
+                    if (blobURL === undefined) {
+                        reject(new Error("Blob URL is undefined"));
+                    }
+                    else {
+                        resolve(blobURL);
+                    }
+                };
+                const payload = {
+                    assetID,
+                    callback,
+                };
+                if (!this.hostHandler) {
+                    reject(new Error("No host handler has been registered"));
+                }
+                else {
+                    this.formRequestAndDispatch("GET_ASSET_BLOB", 1, payload);
+                }
+            });
+        };
+        this.getAssetMeta = (assetID) => {
+            return new Promise((resolve, reject) => {
+                const callback = (assetMeta) => {
+                    if (assetMeta === undefined) {
+                        reject(new Error("Meta is undefined"));
+                    }
+                    else {
+                        resolve(assetMeta);
+                    }
+                };
+                const payload = {
+                    assetID,
+                    callback,
+                };
+                if (!this.hostHandler) {
+                    reject(new Error("No host handler has been registered"));
+                }
+                else {
+                    this.formRequestAndDispatch("GET_ASSET_META", 1, payload);
+                }
+            });
+        };
+        this.getAssetsForOwner = (ownerID) => {
+            return new Promise((resolve, reject) => {
+                const callback = (assetMetas) => {
+                    resolve(assetMetas);
+                };
+                const payload = {
+                    ownerID,
+                    callback,
+                };
+                if (!this.hostHandler) {
+                    reject(new Error("No host handler has been registered"));
+                }
+                else {
+                    this.formRequestAndDispatch("GET_ASSET_FOR_OWNER", 1, payload);
+                }
+            });
+        };
+    }
+    formRequestAndDispatch(type, version, payload) {
+        const request = {
+            type,
+            version,
+            payload,
+        };
+        this.dispatch(request);
+    }
+}

package/lib/Entities/AppHandler.d.ts

@@ -0,0 +1,20 @@
+import { Handler } from "./AppBoundary";
+export declare abstract class RequestHandler {
+    abstract readonly requestType: string;
+    abstract payloadVersion: number;
+    abstract handleRequest: (version: number, payload?: unknown) => void;
+}
+export declare abstract class AppHandler {
+    abstract handler: Handler;
+    abstract registerRequestHandler: (requestHandler: RequestHandler) => void;
+}
+export declare function makeAppHandler(): AppHandler;
+export declare class UnsupportedRequestVerion extends Error {
+    constructor(requestType: string, version: number);
+}
+export declare class ActionNotImplemented extends Error {
+    constructor(requestType: string);
+}
+export declare class UnableToParsePayload extends Error {
+    constructor(requestType: string, version: number, payload: string);
+}

package/lib/Entities/AppHandler.js

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

package/lib/Entities/index.d.ts

@@ -1,3 +1,6 @@
+export * from "./AppBoundary";
+export * from "./AppDispatcher";
+export * from "./AppHandler";
 export * from "./Babylon";
 export * from "./BaseApp";
 export * from "./DevicePreview";
@@ -10,7 +13,6 @@ export * from "./MemoizedVector2";
 export * from "./MemoizedVector3";
 export * from "./MessageSystem";
 export * from "./ObserverList";
-export * from "./FocusCamera";
 export * from "./StateMachine";
 export * from "./Tool";
 export * from "./ToolRepository";

package/lib/Entities/index.js

@@ -10,6 +10,9 @@ 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("./AppBoundary"), exports);
+__exportStar(require("./AppDispatcher"), exports);
+__exportStar(require("./AppHandler"), exports);
 __exportStar(require("./Babylon"), exports);
 __exportStar(require("./BaseApp"), exports);
 __exportStar(require("./DevicePreview"), exports);
@@ -22,7 +25,6 @@ __exportStar(require("./MemoizedVector2"), exports);
 __exportStar(require("./MemoizedVector3"), exports);
 __exportStar(require("./MessageSystem"), exports);
 __exportStar(require("./ObserverList"), exports);
-__exportStar(require("./FocusCamera"), exports);
 __exportStar(require("./StateMachine"), exports);
 __exportStar(require("./Tool"), exports);
 __exportStar(require("./ToolRepository"), exports);

package/lib/PresentationManagers/index.d.ts

@@ -4,9 +4,7 @@ export * from "./PresentationManager";
 export * from "./ShowBabylonInspectorPM";
 export * from "./HasRedoPM";
 export * from "./HasUndoPM";
-export * from "./FocusCameraPM";
 export * from "./QuestionChallenge";
-export * from "./FocusCameraPosRotPM";
 export * from "./ToolPM";
 export * from "./TransformNodePM";
 export * from "./HoverLabels";

package/lib/PresentationManagers/index.js

@@ -16,9 +16,7 @@ __exportStar(require("./PresentationManager"), exports);
 __exportStar(require("./ShowBabylonInspectorPM"), exports);
 __exportStar(require("./HasRedoPM"), exports);
 __exportStar(require("./HasUndoPM"), exports);
-__exportStar(require("./FocusCameraPM"), exports);
 __exportStar(require("./QuestionChallenge"), exports);
-__exportStar(require("./FocusCameraPosRotPM"), exports);
 __exportStar(require("./ToolPM"), exports);
 __exportStar(require("./TransformNodePM"), exports);
 __exportStar(require("./HoverLabels"), exports);

package/lib/UseCases/Handlers/DisposeAppBase.d.ts

@@ -0,0 +1,8 @@
+import { AppHandler, RequestHandler } from "../../Entities";
+export declare class DisposeAppBase extends RequestHandler {
+    readonly requestType = "DISPOSE_APP";
+    readonly payloadVersion = 1;
+    action: () => void;
+    handleRequest: (version: number) => void;
+    constructor(handler: AppHandler);
+}

package/lib/UseCases/Handlers/DisposeAppBase.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DisposeAppBase = void 0;
+const Entities_1 = require("../../Entities");
+class DisposeAppBase extends Entities_1.RequestHandler {
+    constructor(handler) {
+        super();
+        this.requestType = "DISPOSE_APP";
+        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.UnsupportedRequestVerion(this.requestType, version);
+            }
+        };
+        handler.registerRequestHandler(this);
+    }
+}
+exports.DisposeAppBase = DisposeAppBase;

package/lib/UseCases/Handlers/SetAppStateBase.d.ts

@@ -0,0 +1,10 @@
+import { AppHandler, RequestHandler } from "../../Entities";
+export declare type SetAppStateAction = (finalState: string, duration?: number) => void;
+export declare class SetAppStateBase extends RequestHandler {
+    readonly requestType = "SET_APP_STATE";
+    readonly payloadVersion = 2;
+    action: SetAppStateAction;
+    handleRequest: (version: number, payload: unknown) => void;
+    private castPayload;
+    constructor(handler: AppHandler);
+}

package/lib/UseCases/Handlers/SetAppStateBase.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SetAppStateBase = void 0;
+const Entities_1 = require("../../Entities");
+class SetAppStateBase extends Entities_1.RequestHandler {
+    constructor(handler) {
+        super();
+        this.requestType = "SET_APP_STATE";
+        this.payloadVersion = 2;
+        this.action = (finalState, duration) => {
+            throw new Entities_1.ActionNotImplemented(this.requestType);
+        };
+        this.handleRequest = (version, payload) => {
+            if (version === this.payloadVersion) {
+                const { finalState, duration } = this.castPayload(payload);
+                this.action(finalState, duration);
+            }
+            else {
+                throw new Entities_1.UnsupportedRequestVerion(this.requestType, version);
+            }
+        };
+        handler.registerRequestHandler(this);
+    }
+    castPayload(payload) {
+        const castPayload = payload;
+        if (castPayload.finalState === undefined) {
+            throw new Entities_1.UnableToParsePayload(this.requestType, 1, JSON.stringify(payload));
+        }
+        return castPayload;
+    }
+}
+exports.SetAppStateBase = SetAppStateBase;

package/lib/UseCases/Handlers/SetDevicePreviewBase.d.ts

@@ -0,0 +1,10 @@
+import { AppHandler, RequestHandler } from "../../Entities";
+export declare type SetDevicePreviewAction = (px: number, py: number) => void;
+export declare class SetDevicePreviewBase extends RequestHandler {
+    readonly requestType = "SET_DEVICE_PREVIEW";
+    readonly payloadVersion = 1;
+    action: SetDevicePreviewAction;
+    handleRequest: (version: number, payload: unknown) => void;
+    private castPayloadV1;
+    constructor(handler: AppHandler);
+}

package/lib/UseCases/Handlers/SetDevicePreviewBase.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SetDevicePreviewBase = void 0;
+const Entities_1 = require("../../Entities");
+class SetDevicePreviewBase extends Entities_1.RequestHandler {
+    constructor(handler) {
+        super();
+        this.requestType = "SET_DEVICE_PREVIEW";
+        this.payloadVersion = 1;
+        this.action = (px, py) => {
+            throw new Entities_1.ActionNotImplemented(this.requestType);
+        };
+        this.handleRequest = (version, payload) => {
+            if (version === this.payloadVersion) {
+                const { x, y } = this.castPayloadV1(payload);
+                this.action(x, y);
+            }
+            else {
+                throw new Entities_1.UnsupportedRequestVerion(this.requestType, version);
+            }
+        };
+        handler.registerRequestHandler(this);
+    }
+    castPayloadV1(payload) {
+        const castPayload = payload;
+        if (castPayload.x === undefined || castPayload.y === undefined) {
+            throw new Entities_1.UnableToParsePayload(this.requestType, 1, JSON.stringify(payload));
+        }
+        return castPayload;
+    }
+}
+exports.SetDevicePreviewBase = SetDevicePreviewBase;

package/lib/UseCases/Handlers/SetIsAuthoringBase.d.ts

@@ -0,0 +1,10 @@
+import { AppHandler, RequestHandler } from "../../Entities";
+export declare type SetIsAuthoringAction = (isAuthoring: boolean) => void;
+export declare class SetIsAuthoringBase extends RequestHandler {
+    readonly requestType = "SET_IS_AUTHORING";
+    readonly payloadVersion = 1;
+    action: SetIsAuthoringAction;
+    handleRequest: (version: number, payload: unknown) => void;
+    private castPayloadV1;
+    constructor(handler: AppHandler);
+}

package/lib/UseCases/Handlers/SetIsAuthoringBase.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SetIsAuthoringBase = void 0;
+const Entities_1 = require("../../Entities");
+class SetIsAuthoringBase extends Entities_1.RequestHandler {
+    constructor(handler) {
+        super();
+        this.requestType = "SET_IS_AUTHORING";
+        this.payloadVersion = 1;
+        this.action = (show) => {
+            throw new Entities_1.ActionNotImplemented(this.requestType);
+        };
+        this.handleRequest = (version, payload) => {
+            if (version === this.payloadVersion) {
+                const { isAuthoring: setIsAuthoring } = this.castPayloadV1(payload);
+                this.action(setIsAuthoring);
+            }
+            else {
+                throw new Entities_1.UnsupportedRequestVerion(this.requestType, version);
+            }
+        };
+        handler.registerRequestHandler(this);
+    }
+    castPayloadV1(payload) {
+        const castPayload = payload;
+        if (castPayload.isAuthoring === undefined) {
+            throw new Entities_1.UnableToParsePayload(this.requestType, 1, JSON.stringify(payload));
+        }
+        return castPayload;
+    }
+}
+exports.SetIsAuthoringBase = SetIsAuthoringBase;

package/lib/UseCases/Handlers/ShowBabylonInspectorBase.d.ts

@@ -0,0 +1,10 @@
+import { AppHandler, RequestHandler } from "../../Entities";
+export declare type ShowBabylonInspectorAction = (show: boolean) => void;
+export declare class ShowBabylonInspectorBase extends RequestHandler {
+    readonly requestType = "SHOW_BABYLON_INSPECTOR";
+    readonly payloadVersion = 1;
+    action: ShowBabylonInspectorAction;
+    handleRequest: (version: number, payload: unknown) => void;
+    private castPayloadV1;
+    constructor(handler: AppHandler);
+}

package/lib/UseCases/Handlers/ShowBabylonInspectorBase.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ShowBabylonInspectorBase = void 0;
+const Entities_1 = require("../../Entities");
+class ShowBabylonInspectorBase extends Entities_1.RequestHandler {
+    constructor(handler) {
+        super();
+        this.requestType = "SHOW_BABYLON_INSPECTOR";
+        this.payloadVersion = 1;
+        this.action = (show) => {
+            throw new Entities_1.ActionNotImplemented(this.requestType);
+        };
+        this.handleRequest = (version, payload) => {
+            if (version === this.payloadVersion) {
+                const { showBabylonInspector } = this.castPayloadV1(payload);
+                this.action(showBabylonInspector);
+            }
+            else {
+                throw new Entities_1.UnsupportedRequestVerion(this.requestType, version);
+            }
+        };
+        handler.registerRequestHandler(this);
+    }
+    castPayloadV1(payload) {
+        const castPayload = payload;
+        if (castPayload.showBabylonInspector === undefined) {
+            throw new Entities_1.UnableToParsePayload(this.requestType, 1, JSON.stringify(payload));
+        }
+        return castPayload;
+    }
+}
+exports.ShowBabylonInspectorBase = ShowBabylonInspectorBase;

package/lib/UseCases/Handlers/StartAppBase.d.ts

@@ -0,0 +1,10 @@
+import { AppHandler, RequestHandler } from "../../Entities";
+export declare type StartAppAction = (container: HTMLElement) => void;
+export declare class StartAppBase extends RequestHandler {
+    readonly requestType = "START_APP";
+    readonly payloadVersion = 2;
+    action: StartAppAction;
+    handleRequest: (version: number, payload: unknown) => void;
+    private castPayloadV2;
+    constructor(handler: AppHandler);
+}

package/lib/UseCases/Handlers/StartAppBase.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StartAppBase = void 0;
+const Entities_1 = require("../../Entities");
+class StartAppBase extends Entities_1.RequestHandler {
+    constructor(handler) {
+        super();
+        this.requestType = "START_APP";
+        this.payloadVersion = 2;
+        this.action = (container) => {
+            throw new Entities_1.ActionNotImplemented(this.requestType);
+        };
+        this.handleRequest = (version, payload) => {
+            if (version === this.payloadVersion) {
+                const { container } = this.castPayloadV2(payload);
+                this.action(container);
+            }
+            else {
+                throw new Entities_1.UnsupportedRequestVerion(this.requestType, version);
+            }
+        };
+        handler.registerRequestHandler(this);
+    }
+    castPayloadV2(payload) {
+        const castPayload = payload;
+        if (castPayload.container === undefined) {
+            throw new Entities_1.UnableToParsePayload(this.requestType, 1, JSON.stringify(payload));
+        }
+        return castPayload;
+    }
+}
+exports.StartAppBase = StartAppBase;

package/lib/UseCases/Handlers/StopAppBase.d.ts

@@ -0,0 +1,8 @@
+import { AppHandler, RequestHandler } from "../../Entities";
+export declare class StopAppBase extends RequestHandler {
+    readonly requestType = "STOP_APP";
+    readonly payloadVersion = 1;
+    action: () => void;
+    handleRequest: (version: number) => void;
+    constructor(handler: AppHandler);
+}

package/lib/UseCases/Handlers/StopAppBase.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StopAppBase = void 0;
+const Entities_1 = require("../../Entities");
+class StopAppBase extends Entities_1.RequestHandler {
+    constructor(handler) {
+        super();
+        this.requestType = "STOP_APP";
+        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.UnsupportedRequestVerion(this.requestType, version);
+            }
+        };
+        handler.registerRequestHandler(this);
+    }
+}
+exports.StopAppBase = StopAppBase;

package/lib/UseCases/Handlers/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./DisposeAppBase";
+export * from "./SetAppStateBase";
+export * from "./SetDevicePreviewBase";
+export * from "./SetIsAuthoringBase";
+export * from "./ShowBabylonInspectorBase";
+export * from "./StartAppBase";
+export * from "./StopAppBase";

package/lib/UseCases/Handlers/index.js

@@ -0,0 +1,19 @@
+"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("./DisposeAppBase"), exports);
+__exportStar(require("./SetAppStateBase"), exports);
+__exportStar(require("./SetDevicePreviewBase"), exports);
+__exportStar(require("./SetIsAuthoringBase"), exports);
+__exportStar(require("./ShowBabylonInspectorBase"), exports);
+__exportStar(require("./StartAppBase"), exports);
+__exportStar(require("./StopAppBase"), exports);

package/lib/UseCases/index.d.ts

@@ -1,5 +1,5 @@
 export * from "./setDevicePreview";
-export * from "./FocusCamera";
+export * from "./Handlers";
 export * from "./QuestionChallenge";
 export * from "./LerpVector3";
 export * from "./SceneRoot";

package/lib/UseCases/index.js

@@ -11,7 +11,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./setDevicePreview"), exports);
-__exportStar(require("./FocusCamera"), exports);
+__exportStar(require("./Handlers"), exports);
 __exportStar(require("./QuestionChallenge"), exports);
 __exportStar(require("./LerpVector3"), exports);
 __exportStar(require("./SceneRoot"), exports);

package/package.json

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