@vived/app 4.27.0 → 4.27.1

package/lib/PresentationManagers/index.js

@@ -0,0 +1,25 @@
+"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("./DevicePreviewPM"), exports);
+__exportStar(require("./FramedScreenContainerPM"), exports);
+__exportStar(require("./IsAuthoringPM"), exports);
+__exportStar(require("./PresentationManager"), exports);
+__exportStar(require("./ShowBabylonInspectorPM"), exports);
+__exportStar(require("./HasRedoPM"), exports);
+__exportStar(require("./HasUndoPM"), exports);
+__exportStar(require("./QuestionChallenge"), exports);
+__exportStar(require("./SceneModel"), exports);
+__exportStar(require("./SceneObject"), exports);
+__exportStar(require("./ToolPM"), exports);
+__exportStar(require("./TransformNodePM"), exports);
+__exportStar(require("./HoverLabels"), exports);

package/lib/Types/ChannelModelData.d.ts

@@ -0,0 +1,68 @@
+export interface ChannelModelDataMeshDTOv1 {
+    version: number;
+    id: string;
+    meshPaths: string[];
+    label: string;
+}
+export interface ChannelModelDataMeshDTOv0 {
+    id: string;
+    meshPaths: string[];
+    label: string;
+}
+export declare type ChannelModelDTO = ChannelModelDTOv0 | ChannelModelDTOv1;
+export interface ChannelModelDTOv0 {
+    version: number;
+    objects: ChannelModelDataMeshDTOv0[];
+    name: string;
+    description: string;
+    bounds_min: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    bounds_max: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    defaultPosition: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    defaultRotation: {
+        x: number;
+        y: number;
+        z: number;
+        w: number;
+    };
+    defaultScale: number;
+}
+export interface ChannelModelDTOv1 {
+    version: number;
+    objects: ChannelModelDataMeshDTOv1[];
+    name: string;
+    bounds_min: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    bounds_max: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    defaultPosition: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    defaultRotation: {
+        x: number;
+        y: number;
+        z: number;
+        w: number;
+    };
+    defaultScale: number;
+}
+export declare function convertChannelModelDataV0toV1(v0: ChannelModelDTOv0): ChannelModelDTOv1;

package/lib/Types/ChannelModelData.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertChannelModelDataV0toV1 = void 0;
+function convertChannelModelDataV0toV1(v0) {
+    const { objects, name, bounds_max, bounds_min, defaultPosition, defaultRotation, defaultScale } = v0;
+    const objectsV2 = objects.map(obj => {
+        const { id, label, meshPaths } = obj;
+        return {
+            version: 1,
+            id, label, meshPaths
+        };
+    });
+    return {
+        version: 1,
+        objects: objectsV2,
+        name,
+        bounds_max,
+        bounds_min, defaultPosition, defaultRotation, defaultScale
+    };
+}
+exports.convertChannelModelDataV0toV1 = convertChannelModelDataV0toV1;

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

@@ -0,0 +1,17 @@
+import { FocusCamera } from "../../Entities";
+import { Vector3 } from "../../ValueObjects";
+export declare class BumpDollyFocusCamera {
+    private focusCamera;
+    bumpDurationMS: number;
+    bumpLerp: (percent: number) => number;
+    bumpAmount: number;
+    private interval?;
+    private chrono;
+    private delta;
+    private initialRadius;
+    private finalRadius;
+    private pickPoint?;
+    private onTick;
+    bump(direction: "IN" | "OUT", target?: Vector3): void;
+    constructor(focusCamera: FocusCamera);
+}

package/lib/UseCases/FocusCamera/BumpDollyFocusCamera.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BumpDollyFocusCamera = void 0;
+const ValueObjects_1 = require("../../ValueObjects");
+class BumpDollyFocusCamera {
+    constructor(focusCamera) {
+        this.focusCamera = focusCamera;
+        this.bumpDurationMS = 500;
+        this.bumpLerp = (p) => {
+            return p;
+        }; // Linear
+        this.bumpAmount = 0.1;
+        this.chrono = 0;
+        this.delta = 10;
+        this.initialRadius = 0;
+        this.finalRadius = 0;
+        this.onTick = () => {
+            this.chrono = this.chrono + this.delta;
+            let nomralizedTime = this.chrono / this.bumpDurationMS;
+            if (nomralizedTime > 1) {
+                nomralizedTime = 1;
+            }
+            const percent = this.bumpLerp(nomralizedTime);
+            const range = this.finalRadius - this.initialRadius;
+            const currentRadius = this.focusCamera.radius;
+            this.focusCamera.radius = this.initialRadius + range * percent;
+            if (this.pickPoint !== undefined) {
+                const percentChange = this.focusCamera.radius / currentRadius;
+                let pickToTarget = ValueObjects_1.Vector3.Subtract(this.focusCamera.target, this.pickPoint);
+                const newLength = pickToTarget.magnitued * percentChange;
+                pickToTarget = ValueObjects_1.Vector3.NewVectorOfLength(pickToTarget, newLength);
+                const newTargetPos = ValueObjects_1.Vector3.Add(this.pickPoint, pickToTarget);
+                this.focusCamera.target = newTargetPos;
+            }
+            if (nomralizedTime >= 1 && this.interval) {
+                this.focusCamera.radius = this.finalRadius;
+                clearInterval(this.interval);
+                this.interval = undefined;
+                this.pickPoint = undefined;
+            }
+        };
+    }
+    bump(direction, target) {
+        let delta = this.bumpAmount;
+        if (direction === "IN") {
+            delta *= -1;
+        }
+        this.initialRadius = this.focusCamera.radius;
+        if (this.interval) {
+            clearInterval(this.interval);
+            this.interval = undefined;
+            this.finalRadius = this.finalRadius + delta;
+        }
+        else {
+            this.finalRadius = this.initialRadius + delta;
+        }
+        this.chrono = 0;
+        this.pickPoint = target;
+        this.interval = setInterval(() => {
+            this.onTick();
+        }, 10);
+    }
+}
+exports.BumpDollyFocusCamera = BumpDollyFocusCamera;

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

@@ -0,0 +1,36 @@
+import { FocusCamera } from "../../Entities";
+export interface LerpFocusCameraParameters {
+    duration: number;
+    finalRadius?: number;
+    finalBeta?: number;
+    finalAlpha?: number;
+    finalTarget?: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    onComplete?: () => void;
+    onAbort?: () => void;
+}
+export declare class LerpFocusCamera {
+    get isLerping(): boolean;
+    private _isLerping;
+    private focusCamera;
+    private easeFn;
+    private lerpDuration;
+    private lerpRadius;
+    private lerpBeta;
+    private lerpAlpha;
+    private lerpX;
+    private lerpY;
+    private lerpZ;
+    private onComplete?;
+    private onAbort?;
+    private interval;
+    private chrono;
+    private delta;
+    cancelLerp: () => void;
+    private onTick;
+    constructor(focusCamera: FocusCamera, easeFn: (normalizedTime: number) => number, parameters: LerpFocusCameraParameters);
+    private makeLerpNumber;
+}

package/lib/UseCases/FocusCamera/LerpFocusCamera.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LerpFocusCamera = void 0;
+const ValueObjects_1 = require("../../ValueObjects");
+class LerpFocusCamera {
+    constructor(focusCamera, easeFn, parameters) {
+        var _a, _b, _c;
+        this._isLerping = false;
+        this.chrono = 0;
+        this.delta = 10;
+        this.cancelLerp = () => {
+            if (!this._isLerping)
+                return;
+            clearInterval(this.interval);
+            if (this.onAbort) {
+                this.onAbort();
+            }
+            this._isLerping = false;
+        };
+        this.onTick = () => {
+            this.chrono = this.chrono + this.delta / 1000;
+            let nomralizedTime = this.chrono / this.lerpDuration;
+            if (nomralizedTime > 1) {
+                nomralizedTime = 1;
+            }
+            const percent = this.easeFn(nomralizedTime);
+            this.focusCamera.radius = this.lerpRadius(percent);
+            this.focusCamera.beta = this.lerpBeta(percent);
+            this.focusCamera.alpha = this.lerpAlpha(percent);
+            const x = this.lerpX(percent);
+            const y = this.lerpY(percent);
+            const z = this.lerpZ(percent);
+            this.focusCamera.target = new ValueObjects_1.Vector3(x, y, z);
+            if (nomralizedTime >= 1) {
+                clearInterval(this.interval);
+                if (this.onComplete) {
+                    this.onComplete();
+                }
+                this._isLerping = false;
+                this.focusCamera.lerpCompleted();
+            }
+        };
+        this.focusCamera = focusCamera;
+        this.easeFn = easeFn;
+        this.lerpDuration = parameters.duration;
+        this.onComplete = parameters.onComplete;
+        this.onAbort = parameters.onAbort;
+        this.lerpRadius = this.makeLerpNumber(this.focusCamera.radius, parameters.finalRadius);
+        this.lerpBeta = this.makeLerpNumber(this.focusCamera.beta, parameters.finalBeta);
+        this.lerpAlpha = this.makeLerpNumber(this.focusCamera.alpha, parameters.finalAlpha);
+        this.lerpX = this.makeLerpNumber(this.focusCamera.target.x, (_a = parameters.finalTarget) === null || _a === void 0 ? void 0 : _a.x);
+        this.lerpY = this.makeLerpNumber(this.focusCamera.target.y, (_b = parameters.finalTarget) === null || _b === void 0 ? void 0 : _b.y);
+        this.lerpZ = this.makeLerpNumber(this.focusCamera.target.z, (_c = parameters.finalTarget) === null || _c === void 0 ? void 0 : _c.z);
+        this.interval = setInterval(() => {
+            this.onTick();
+        }, this.delta);
+        this.focusCamera.registerLerp(this);
+        this._isLerping = true;
+    }
+    get isLerping() {
+        return this._isLerping;
+    }
+    makeLerpNumber(initial, final) {
+        const actualFinal = final !== null && final !== void 0 ? final : initial;
+        return function Lerp(percent) {
+            const range = actualFinal - initial;
+            return initial + range * percent;
+        };
+    }
+}
+exports.LerpFocusCamera = LerpFocusCamera;

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

@@ -0,0 +1,11 @@
+import { FocusCamera } from "../../Entities";
+import { Vector3 } from "../../ValueObjects";
+export declare class PinchDollyFocusCamera {
+    private focusCamera;
+    sensitivity: number;
+    private previousDistanceBetweenTouches;
+    private pickPoint?;
+    doDolly: (distanceBetweenTouches: number) => void;
+    initializeDolly: (distanceBetweenTouches: number, pickPoint?: Vector3 | undefined) => void;
+    constructor(focusCamera: FocusCamera);
+}

package/lib/UseCases/FocusCamera/PinchDollyFocusCamera.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PinchDollyFocusCamera = void 0;
+const ValueObjects_1 = require("../../ValueObjects");
+class PinchDollyFocusCamera {
+    constructor(focusCamera) {
+        this.focusCamera = focusCamera;
+        this.sensitivity = 0.05;
+        this.previousDistanceBetweenTouches = 0;
+        this.doDolly = (distanceBetweenTouches) => {
+            const pinchDelta = distanceBetweenTouches - this.previousDistanceBetweenTouches;
+            const deltaRadius = pinchDelta * this.sensitivity;
+            const currentRadius = this.focusCamera.radius;
+            this.focusCamera.radius = currentRadius - deltaRadius;
+            if (this.pickPoint !== undefined) {
+                const percentChange = this.focusCamera.radius / currentRadius;
+                let pickToTarget = ValueObjects_1.Vector3.Subtract(this.focusCamera.target, this.pickPoint);
+                const newLength = pickToTarget.magnitued * percentChange;
+                pickToTarget = ValueObjects_1.Vector3.NewVectorOfLength(pickToTarget, newLength);
+                const newTargetPos = ValueObjects_1.Vector3.Add(this.pickPoint, pickToTarget);
+                this.focusCamera.target = newTargetPos;
+            }
+            this.previousDistanceBetweenTouches = distanceBetweenTouches;
+        };
+        this.initializeDolly = (distanceBetweenTouches, pickPoint) => {
+            this.previousDistanceBetweenTouches = distanceBetweenTouches;
+            if (pickPoint) {
+                this.pickPoint = pickPoint;
+            }
+            else {
+                this.pickPoint = undefined;
+            }
+        };
+    }
+}
+exports.PinchDollyFocusCamera = PinchDollyFocusCamera;

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

@@ -0,0 +1,11 @@
+import { FocusCamera } from "../../Entities";
+import { Vector2, Vector3 } from "../../ValueObjects";
+export declare class PixelDollyFocusCamera {
+    private focusCamera;
+    sensitivity: number;
+    private previousPixelPosition;
+    private pickPoint?;
+    doDolly: (pixelPosition: Vector2) => void;
+    initializeDolly: (pixelPosition: Vector2, pickPoint?: Vector3 | undefined) => void;
+    constructor(focusCamera: FocusCamera);
+}

package/lib/UseCases/FocusCamera/PixelDollyFocusCamera.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PixelDollyFocusCamera = void 0;
+const ValueObjects_1 = require("../../ValueObjects");
+class PixelDollyFocusCamera {
+    constructor(focusCamera) {
+        this.focusCamera = focusCamera;
+        this.sensitivity = 0.05;
+        this.previousPixelPosition = ValueObjects_1.Vector2.Zero();
+        this.doDolly = (pixelPosition) => {
+            const pixelDeltaY = pixelPosition.y - this.previousPixelPosition.y;
+            const deltaRadius = pixelDeltaY * this.sensitivity;
+            const currentRadius = this.focusCamera.radius;
+            this.focusCamera.radius = currentRadius - deltaRadius;
+            if (this.pickPoint !== undefined) {
+                const percentChange = this.focusCamera.radius / currentRadius;
+                let pickToTarget = ValueObjects_1.Vector3.Subtract(this.focusCamera.target, this.pickPoint);
+                const newLength = pickToTarget.magnitued * percentChange;
+                pickToTarget = ValueObjects_1.Vector3.NewVectorOfLength(pickToTarget, newLength);
+                const newTargetPos = ValueObjects_1.Vector3.Add(this.pickPoint, pickToTarget);
+                this.focusCamera.target = newTargetPos;
+            }
+            this.previousPixelPosition = pixelPosition;
+        };
+        this.initializeDolly = (pixelPosition, pickPoint) => {
+            this.previousPixelPosition = pixelPosition;
+            if (pickPoint) {
+                this.pickPoint = pickPoint;
+            }
+            else {
+                this.pickPoint = undefined;
+            }
+        };
+    }
+}
+exports.PixelDollyFocusCamera = PixelDollyFocusCamera;

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

@@ -0,0 +1,11 @@
+import { FocusCamera } from "../../Entities";
+import { Vector2, Vector3 } from "../../ValueObjects";
+export declare class PixelOrbitFocusCamera {
+    private focusCamera;
+    sensitivity: number;
+    private previousPixelPos?;
+    private pickPoint?;
+    doOrbit: (pixelPosition: Vector2) => void;
+    initializeOrbit: (initialPixelPos: Vector2, pickPoint?: Vector3 | undefined) => void;
+    constructor(focusCamera: FocusCamera);
+}

package/lib/UseCases/FocusCamera/PixelOrbitFocusCamera.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PixelOrbitFocusCamera = void 0;
+const ValueObjects_1 = require("../../ValueObjects");
+class PixelOrbitFocusCamera {
+    constructor(focusCamera) {
+        this.focusCamera = focusCamera;
+        this.sensitivity = 0.5;
+        this.doOrbit = (pixelPosition) => {
+            if (!this.previousPixelPos) {
+                console.error("[PixelOrbitFocusCamera] You must initialize first!");
+                return;
+            }
+            const pixelChange = ValueObjects_1.Vector2.Subtract(pixelPosition, this.previousPixelPos);
+            this.focusCamera.alpha += pixelChange.x * this.sensitivity;
+            this.focusCamera.beta += pixelChange.y * this.sensitivity;
+            this.previousPixelPos = pixelPosition;
+        };
+        this.initializeOrbit = (initialPixelPos, pickPoint) => {
+            this.previousPixelPos = initialPixelPos;
+            this.pickPoint = pickPoint;
+            this.focusCamera.cancelLerp();
+        };
+    }
+}
+exports.PixelOrbitFocusCamera = PixelOrbitFocusCamera;

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;