@vived/app 4.1.0 → 4.3.0

package/lib/UseCases/FocusCamera/PixelPlanePanFocusCamera.d.ts

@@ -0,0 +1,11 @@
+import { Babylon, FocusCamera } from "../../Entities";
+import { ParametricPlane, Vector2 } from "../../ValueObjects";
+export declare class PixelPlanePanFocusCamera {
+    private focusCamera;
+    private babylon;
+    private plane?;
+    private previousPixelPos?;
+    doPan: (pixelPosition: Vector2) => void;
+    initializePan: (initialPixelPos: Vector2, panPlane: ParametricPlane) => void;
+    constructor(focusCamera: FocusCamera, babylon: Babylon);
+}

package/lib/UseCases/FocusCamera/PixelPlanePanFocusCamera.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PixelPlanePanFocusCamera = void 0;
+const ValueObjects_1 = require("../../ValueObjects");
+class PixelPlanePanFocusCamera {
+    constructor(focusCamera, babylon) {
+        this.focusCamera = focusCamera;
+        this.babylon = babylon;
+        this.doPan = (pixelPosition) => {
+            if (!this.plane || !this.previousPixelPos) {
+                console.error("[PixelPlanePan_OrbitCamera] You must initialize first!");
+                return;
+            }
+            const initialRay = this.babylon.sceneRay(this.previousPixelPos);
+            const finalRay = this.babylon.sceneRay(pixelPosition);
+            const p1 = this.plane.intersectLine(initialRay);
+            const p2 = this.plane.intersectLine(finalRay);
+            if (!p1 || !p2)
+                return;
+            const delta = ValueObjects_1.Vector3.Subtract(p2, p1);
+            const currentTarget = this.focusCamera.target;
+            const newTarget = new ValueObjects_1.Vector3(currentTarget.x - delta.x, currentTarget.y - delta.y, currentTarget.z - delta.z);
+            this.focusCamera.target = new ValueObjects_1.Vector3(newTarget.x, newTarget.y, newTarget.z);
+            this.previousPixelPos = pixelPosition;
+        };
+        this.initializePan = (initialPixelPos, panPlane) => {
+            this.plane = panPlane;
+            this.previousPixelPos = initialPixelPos;
+            this.focusCamera.cancelLerp();
+        };
+    }
+}
+exports.PixelPlanePanFocusCamera = PixelPlanePanFocusCamera;

package/lib/UseCases/FocusCamera/SerializeFocusCamera.d.ts

@@ -0,0 +1,22 @@
+import { FocusCamera, SerializedSystem, StateMachine } from "../../Entities";
+export declare class SerializeFocusCamera implements SerializedSystem {
+    name: string;
+    seriliziationVersion: number;
+    private focusCamera;
+    private stateMachine;
+    getSystemState(): object;
+    applySystemState(serializedState: object, version: number, transitionTime: number): void;
+    applyDefaultState(transitionDuration: number): void;
+    private applyV1Data;
+    private applyImmediate;
+    private applyLerp;
+    constructor(focusCamera: FocusCamera, stateMachine: StateMachine);
+}
+export interface FocusCameraDataV1 {
+    alpha: number;
+    beta: number;
+    radius: number;
+    target_x: number;
+    target_y: number;
+    target_z: number;
+}

package/lib/UseCases/FocusCamera/SerializeFocusCamera.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SerializeFocusCamera = void 0;
+const _1 = require(".");
+const ValueObjects_1 = require("../../ValueObjects");
+class SerializeFocusCamera {
+    constructor(focusCamera, stateMachine) {
+        this.name = "focusCamera";
+        this.seriliziationVersion = 1;
+        this.focusCamera = focusCamera;
+        this.stateMachine = stateMachine;
+        stateMachine.registerSerializedSystem(this);
+    }
+    getSystemState() {
+        const data = {
+            alpha: this.focusCamera.alpha,
+            beta: this.focusCamera.beta,
+            radius: this.focusCamera.radius,
+            target_x: this.focusCamera.target.x,
+            target_y: this.focusCamera.target.y,
+            target_z: this.focusCamera.target.z,
+        };
+        return data;
+    }
+    applySystemState(serializedState, version, transitionTime) {
+        try {
+            if (version === 1) {
+                const castState = serializedState;
+                this.applyV1Data(castState, transitionTime);
+            }
+            else {
+                console.warn(`[SerializeFocusCamera] Unsupported version number ${version}. Defaulting`);
+                this.applyDefaultState(transitionTime);
+            }
+        }
+        catch (e) {
+            console.warn(`[SerializeFocusCamera] Caught when deserializing ${e}. Defaulting`);
+            this.applyDefaultState(transitionTime);
+        }
+    }
+    applyDefaultState(transitionDuration) {
+        const alpha = this.focusCamera.defaultAlpha;
+        const beta = this.focusCamera.defaultBeta;
+        const radius = this.focusCamera.defaultRadius;
+        const target = this.focusCamera.defaultTarget;
+        if (transitionDuration === 0) {
+            this.applyImmediate(alpha, beta, radius, target);
+        }
+        else {
+            this.applyLerp(alpha, beta, radius, target, transitionDuration);
+        }
+    }
+    applyV1Data(data, transitionTime) {
+        const { alpha, beta, radius, target_x, target_y, target_z } = data;
+        const target = new ValueObjects_1.Vector3(target_x, target_y, target_z);
+        if (transitionTime === 0) {
+            this.applyImmediate(alpha, beta, radius, target);
+        }
+        else {
+            this.applyLerp(alpha, beta, radius, target, transitionTime);
+        }
+    }
+    applyImmediate(alpha, beta, radius, target) {
+        this.focusCamera.cancelLerp();
+        this.focusCamera.alpha = alpha;
+        this.focusCamera.beta = beta;
+        this.focusCamera.radius = radius;
+        this.focusCamera.target = target;
+    }
+    applyLerp(alpha, beta, radius, target, transitionTime) {
+        const lerpParams = {
+            duration: transitionTime,
+            finalRadius: radius,
+            finalBeta: beta,
+            finalAlpha: alpha,
+            finalTarget: target,
+        };
+        new _1.LerpFocusCamera(this.focusCamera, this.stateMachine.transitionEaseFunction, lerpParams);
+    }
+}
+exports.SerializeFocusCamera = SerializeFocusCamera;

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

@@ -0,0 +1,7 @@
+export * from "./PixelPlanePanFocusCamera";
+export * from "./LerpFocusCamera";
+export * from "./SerializeFocusCamera";
+export * from "./PixelDollyFocusCamera";
+export * from "./BumpDollyFocusCamera";
+export * from "./PinchDollyFocusCamera";
+export * from "./PixelOrbitFocusCamera";

package/lib/UseCases/FocusCamera/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("./PixelPlanePanFocusCamera"), exports);
+__exportStar(require("./LerpFocusCamera"), exports);
+__exportStar(require("./SerializeFocusCamera"), exports);
+__exportStar(require("./PixelDollyFocusCamera"), exports);
+__exportStar(require("./BumpDollyFocusCamera"), exports);
+__exportStar(require("./PinchDollyFocusCamera"), exports);
+__exportStar(require("./PixelOrbitFocusCamera"), 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/StartZSpaceBase.d.ts

@@ -0,0 +1,10 @@
+import { AppHandler, RequestHandler } from "../../Entities";
+export declare type StartZSpaceAction = (session: any, emulate: boolean) => void;
+export declare class StartZSpaceBase extends RequestHandler {
+    readonly requestType = "START_ZSPACE";
+    readonly payloadVersion = 3;
+    action: StartZSpaceAction;
+    handleRequest: (version: number, payload: unknown) => void;
+    private castPayloadV3;
+    constructor(handler: AppHandler);
+}

package/lib/UseCases/Handlers/StartZSpaceBase.js

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

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/StopZSpaceBase.d.ts

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

package/lib/UseCases/Handlers/StopZSpaceBase.js

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

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

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

package/lib/UseCases/Handlers/index.js

@@ -0,0 +1,21 @@
+"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("./StartZSpaceBase"), exports);
+__exportStar(require("./ShowBabylonInspectorBase"), exports);
+__exportStar(require("./StartAppBase"), exports);
+__exportStar(require("./StopAppBase"), exports);
+__exportStar(require("./StopZSpaceBase"), exports);

package/lib/UseCases/HoverLabels/SerializeAllowHoverLabel.d.ts

@@ -0,0 +1,14 @@
+import { HoverLabels, SerializedSystem, StateMachine } from "../../Entities";
+export declare class SerializeAllowHoverLabel implements SerializedSystem {
+    private hoverLabels;
+    name: string;
+    seriliziationVersion: number;
+    getSystemState(): object;
+    applySystemState(state: object, version: number): void;
+    applyDefaultState(): void;
+    private applyDataV1;
+    constructor(hoverLabels: HoverLabels, stateMachine: StateMachine);
+}
+export interface AllowHoverLabelV1 {
+    allow: boolean;
+}

package/lib/UseCases/HoverLabels/SerializeAllowHoverLabel.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SerializeAllowHoverLabel = void 0;
+class SerializeAllowHoverLabel {
+    constructor(hoverLabels, stateMachine) {
+        this.hoverLabels = hoverLabels;
+        this.name = "allowHoverLabel";
+        this.seriliziationVersion = 1;
+        stateMachine.registerSerializedSystem(this);
+    }
+    getSystemState() {
+        const state = {
+            allow: this.hoverLabels.allowHoverLabels
+        };
+        return state;
+    }
+    applySystemState(state, version) {
+        if (state && version === 1) {
+            const castState = state;
+            this.applyDataV1(castState);
+        }
+        else {
+            // Unsupported version
+            console.warn(`Unsupported data version ${version} for serialized system ${this.name}. Reverting to default state`);
+            this.applyDefaultState();
+        }
+    }
+    applyDefaultState() {
+        this.hoverLabels.allowHoverLabels = true;
+    }
+    applyDataV1(data) {
+        this.hoverLabels.allowHoverLabels = data.allow;
+    }
+}
+exports.SerializeAllowHoverLabel = SerializeAllowHoverLabel;

package/lib/UseCases/HoverLabels/trySetHoverLabel.d.ts

@@ -0,0 +1,3 @@
+import { Babylon, HoverLabels } from "../../Entities";
+import { Vector2 } from "../../ValueObjects";
+export declare function makeTrySetHoverLabel(hoverLabels: HoverLabels, babylon: Babylon): (position: Vector2) => void;