@vived/app 4.1.0 → 4.3.0

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

@@ -0,0 +1,48 @@
+import { ParametricLine, Vector2, Vector3 } from "../ValueObjects";
+export declare type OnBabylonChange = () => void;
+export interface ScenePick {
+    mouseRay: ParametricLine;
+    hit: boolean;
+    worldPickPoint?: Vector3;
+    objectPickMeta?: object;
+    normal?: Vector3;
+}
+export interface IScreenshotSize {
+    /**
+     * number in pixels for canvas height
+     */
+    height?: number;
+    /**
+     * multiplier allowing render at a higher or lower resolution
+     * If value is defined then height and width will be ignored and taken from camera
+     */
+    precision?: number;
+    /**
+     * number in pixels for canvas width
+     */
+    width?: number;
+}
+export interface Babylon {
+    engine: unknown;
+    scene: unknown;
+    workingCanvas?: HTMLCanvasElement;
+    showInspector: boolean;
+    renderCanvas?: HTMLCanvasElement;
+    isRendering: boolean;
+    pixelToSceneRay: (pixelPos: Vector2) => ParametricLine;
+    sceneRayPick: (ray: ParametricLine) => ScenePick | undefined;
+    scenePixelPick: (pixelPos: Vector2) => ScenePick | undefined;
+    sceneObjectRayPick: (ray: ParametricLine) => string | undefined;
+    sceneObjectPixelPick: (pixelPos: Vector2) => string | undefined;
+    captureScreenshot: (size: IScreenshotSize | number) => Promise<Blob>;
+    makeSceneObjectMeta: (id: string) => object;
+    updateCanvasSize: () => void;
+    submitRenderCanvas: (canvas: HTMLCanvasElement) => void;
+    clearRenderCanvas: () => void;
+    registerResizeEnging: (resizeEngine: () => void) => void;
+    registerStartRendering: (startRendering: (canvas: HTMLCanvasElement) => void) => void;
+    registerStopRendering: (stopRendering: (canvas: HTMLCanvasElement) => void) => void;
+    addObserver: (observer: OnBabylonChange) => void;
+    removeObserver: (observer: OnBabylonChange) => void;
+}
+export declare function makeBabylon(): Babylon;

package/lib/Entities/Babylon.js

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeBabylon = void 0;
+const ValueObjects_1 = require("../ValueObjects");
+const MemoizedBoolean_1 = require("./Memoized/MemoizedBoolean");
+const MemoizedVector2_1 = require("./Memoized/MemoizedVector2");
+const ObserverList_1 = require("./ObserverList");
+function makeBabylon() {
+    return new BabylonImp();
+}
+exports.makeBabylon = makeBabylon;
+class BabylonImp {
+    constructor() {
+        this.observers = new ObserverList_1.ObserverList();
+        this.updateCanvasSize = () => {
+            if (!this.workingCanvas)
+                return;
+            if (!this._renderCanvas)
+                return;
+            if (this.workingCanvas.height === this._renderCanvas.height &&
+                this.workingCanvas.width === this._renderCanvas.width) {
+                return;
+            }
+            if (this.resizeEngine) {
+                this.resizeEngine();
+            }
+            this.workingCanvas.height = this._renderCanvas.height;
+            this.workingCanvas.width = this._renderCanvas.width;
+            this.observers.notify();
+        };
+        this.submitRenderCanvas = (canvas) => {
+            if (canvas === this._renderCanvas)
+                return;
+            if (this._renderCanvas && this.stopRendering) {
+                this.stopRendering(this._renderCanvas);
+            }
+            this._renderCanvas = canvas;
+            this.updateCanvasSize();
+            if (this.startRendering) {
+                this.startRendering(canvas);
+            }
+            this.observers.notify();
+        };
+        this.clearRenderCanvas = () => {
+            if (!this._renderCanvas)
+                return;
+            if (this.stopRendering) {
+                this.stopRendering(this._renderCanvas);
+            }
+            this._renderCanvas = undefined;
+            this.observers.notify();
+        };
+        this.registerResizeEnging = (resizeEngine) => {
+            this.resizeEngine = resizeEngine;
+        };
+        this.registerStartRendering = (startRendering) => {
+            this.startRendering = startRendering;
+        };
+        this.registerStopRendering = (stopRendering) => {
+            this.stopRendering = stopRendering;
+        };
+        this.addObserver = (observer) => {
+            this.observers.add(observer);
+        };
+        this.removeObserver = (observer) => {
+            this.observers.remove(observer);
+        };
+        this.makeSceneObjectMeta = (id) => {
+            return { sceneObjectID: id };
+        };
+        this.getSceneObjectIDFromMeta = (meta) => {
+            if (meta === null || meta === void 0 ? void 0 : meta.hasOwnProperty("sceneObjectID")) {
+                return meta.sceneObjectID;
+            }
+            else {
+                return;
+            }
+        };
+        this.memoizedIsRendering = new MemoizedBoolean_1.MemoizedBoolean(false, this.observers.notify);
+        this.sceneRayPick = (ray) => {
+            throw new Error("Scene ray pick has not been injected");
+        };
+        this.captureScreenshot = (size = 512) => {
+            throw new Error("CaptureScreenshot has not been injected");
+        };
+        this.sceneObjectRayPick = (ray) => {
+            try {
+                const pick = this.sceneRayPick(ray);
+                if (pick === undefined)
+                    return;
+                const sceneObjectId = this.getSceneObjectIDFromMeta(pick.objectPickMeta);
+                return sceneObjectId;
+            }
+            catch (e) {
+                console.warn(e);
+                return;
+            }
+        };
+        this.sceneObjectPixelPick = (pixelPos) => {
+            try {
+                const ray = this.pixelToSceneRay(pixelPos);
+                return this.sceneObjectRayPick(ray);
+            }
+            catch (e) {
+                console.warn(e);
+                return;
+            }
+        };
+        this.scenePixelPick = (pixelPos) => {
+            try {
+                const ray = this.pixelToSceneRay(pixelPos);
+                return this.sceneRayPick(ray);
+            }
+            catch (e) {
+                console.warn(e);
+                return;
+            }
+        };
+        this.pixelToSceneRay = (pixelPos) => {
+            throw new Error("Pixel to scene ray has not been injected");
+        };
+        this.memoizedShowInspector = new MemoizedBoolean_1.MemoizedBoolean(false, this.observers.notify);
+        this.memoizedCanvasSize = new MemoizedVector2_1.MemoizedVector2(ValueObjects_1.Vector2.One(), this.observers.notify);
+    }
+    get showInspector() {
+        return this.memoizedShowInspector.val;
+    }
+    set showInspector(val) {
+        this.memoizedShowInspector.val = val;
+    }
+    get renderCanvas() {
+        return this._renderCanvas;
+    }
+    get canvasSize() {
+        return this.memoizedCanvasSize.val;
+    }
+    set canvasSize(val) {
+        this.memoizedCanvasSize.val = val;
+    }
+    get isRendering() {
+        return this.memoizedIsRendering.val;
+    }
+    set isRendering(val) {
+        this.memoizedIsRendering.val = val;
+    }
+}

package/lib/Entities/BaseApp.d.ts

@@ -0,0 +1,9 @@
+import { ObservableEntity } from "./ObservableEntity";
+export declare type OnBaseAppChange = () => void;
+export declare abstract class BaseApp extends ObservableEntity {
+    abstract get isAuthoring(): boolean;
+    abstract set isAuthoring(val: boolean);
+    abstract startRendering: (container: HTMLElement) => void;
+    abstract stopRendering: () => void;
+}
+export declare function makeBaseApp(): BaseApp;

package/lib/Entities/BaseApp.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeBaseApp = exports.BaseApp = void 0;
+const MemoizedBoolean_1 = require("./Memoized/MemoizedBoolean");
+const ObservableEntity_1 = require("./ObservableEntity");
+class BaseApp extends ObservableEntity_1.ObservableEntity {
+}
+exports.BaseApp = BaseApp;
+function makeBaseApp() {
+    return new BaseAppImp();
+}
+exports.makeBaseApp = makeBaseApp;
+class BaseAppImp extends BaseApp {
+    constructor() {
+        super(...arguments);
+        this.startRendering = (container) => {
+            throw new Error("[Base App] Start rendering function has not been injected");
+        };
+        this.stopRendering = () => {
+            throw new Error("[Base App] Stop rendering function has not been injected");
+        };
+        this.memoizedIsAuthoring = new MemoizedBoolean_1.MemoizedBoolean(false, this.notify);
+    }
+    get isAuthoring() {
+        return this.memoizedIsAuthoring.val;
+    }
+    set isAuthoring(val) {
+        this.memoizedIsAuthoring.val = val;
+    }
+}

package/lib/Entities/DevicePreview.d.ts

@@ -0,0 +1,11 @@
+import { Vector2 } from "../ValueObjects";
+export declare type OnDevicePreviewChange = () => void;
+export interface DevicePreview {
+    useDevicePreview: boolean;
+    previewSize: Vector2;
+    setDevicePreview(x: number, y: number): void;
+    clearDevicePreview(): void;
+    addObserver(observer: OnDevicePreviewChange): void;
+    removeObserver(observer: OnDevicePreviewChange): void;
+}
+export declare function makeDevicePreview(): DevicePreview;

package/lib/Entities/DevicePreview.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeDevicePreview = void 0;
+const _1 = require(".");
+const ValueObjects_1 = require("../ValueObjects");
+function makeDevicePreview() {
+    return new DevicePreviewImp();
+}
+exports.makeDevicePreview = makeDevicePreview;
+class DevicePreviewImp {
+    constructor() {
+        this.observers = new _1.ObserverList();
+        this._usePreview = false;
+        this._previewSize = ValueObjects_1.Vector2.Zero();
+        this.setDevicePreview = (x, y) => {
+            if (this._previewSize.x === x &&
+                this._previewSize.y === y)
+                return;
+            this._usePreview = true;
+            this._previewSize = new ValueObjects_1.Vector2(x, y);
+            if (x > 0 && y > 0) {
+                this._usePreview = true;
+            }
+            else {
+                this._usePreview = false;
+            }
+            this.observers.notify();
+        };
+        this.clearDevicePreview = () => {
+            if (!this._usePreview)
+                return;
+            this._previewSize = ValueObjects_1.Vector2.Zero();
+            this._usePreview = false;
+            this.observers.notify();
+        };
+        this.addObserver = (observer) => {
+            this.observers.add(observer);
+        };
+        this.removeObserver = (observer) => {
+            this.observers.remove(observer);
+        };
+    }
+    get useDevicePreview() {
+        return this._usePreview;
+    }
+    get previewSize() {
+        return this._previewSize;
+    }
+}

package/lib/Entities/FocusCamera.d.ts

@@ -0,0 +1,70 @@
+import { Vector3 } from "../ValueObjects";
+export declare type OnFocusCameraChange = () => void;
+export interface FocusCameraLerper {
+    cancelLerp: () => void;
+}
+export interface FocusCameraData {
+    defaultAlpha?: number;
+    defaultBeta?: number;
+    defaultRadius?: number;
+    defaultTarget?: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    nearClip?: number;
+    farClip?: number;
+    alphaLimit?: {
+        min: number;
+        max: number;
+    };
+    betaLimit?: {
+        min: number;
+        max: number;
+    };
+    radiusLimit?: {
+        min: number;
+        max: number;
+    };
+    targetLimit?: {
+        min: {
+            x: number;
+            y: number;
+            z: number;
+        };
+        max: {
+            x: number;
+            y: number;
+            z: number;
+        };
+    };
+}
+export interface FocusCamera {
+    alpha: number;
+    beta: number;
+    radius: number;
+    target: Vector3;
+    direction: Vector3;
+    cameraPosition: Vector3;
+    nearClip: number;
+    farClip: number;
+    defaultAlpha: number;
+    defaultBeta: number;
+    defaultRadius: number;
+    defaultTarget: Vector3;
+    setAlphaLimits: (min: number, max: number) => void;
+    clearAlphaLimits: () => void;
+    setBetaLimits: (min: number, max: number) => void;
+    clearBetaLimits: () => void;
+    setRadiusLimits: (min: number, max: number) => void;
+    clearRadiusLimits: () => void;
+    setTargetLimits: (min: Vector3, max: Vector3) => void;
+    clearTargetLimits: () => void;
+    registerLerp: (lerper: FocusCameraLerper) => void;
+    lerpCompleted: () => void;
+    cancelLerp: () => void;
+    applyData: (data: FocusCameraData) => void;
+    addObserver: (observer: OnFocusCameraChange) => void;
+    removeObserver: (observer: OnFocusCameraChange) => void;
+}
+export declare function makeFocusCamera(): FocusCamera;