@vived/app 2.20.1 → 2.21.0

package/lib/Core/BaseApp/Boundary.d.ts

@@ -0,0 +1,49 @@
+import { Handler } from "@vived/app-host-boundary";
+export interface BaseAppUC {
+    getIsAuthoring(): boolean;
+    setIsAuthoring(isAuthoring: boolean): void;
+    getShowBabylonInspector(): boolean;
+    setShowBabylonInspector(showInspector: boolean): void;
+    addObserver(observer: BaseAppStateObserver): void;
+    removeObserver(observer: BaseAppStateObserver): void;
+    setVerbose(verbose: boolean): void;
+    getSerializedState(): SerializedStates;
+    setSerializedState(state: SerializedStates, transitionTime: number): void;
+    setDefaultState(transitionTime: number): void;
+    registerSerializableSystem(serializedSystem: SerializableSystem): void;
+    getIsTransitioning(): boolean;
+    abortTransition(): void;
+    setTransitionEaseFn: (easeFn: (normalizedTime: number) => number) => void;
+    setHostHandler(handler: Handler): void;
+    hasHostHandler(): boolean;
+    dispatchOnStateChange(stateObject: object): void;
+    dispatchOnStateComplete(): void;
+    dispatchSubmitResults(results: object): void;
+    dispatchGetAppAssetsURL(): string;
+    setDevicePreview(x: number, y: number): void;
+    clearDevicePreview(): void;
+    getUseDevicePreview(): boolean;
+    getDevicePreviewSize(): {
+        x: number;
+        y: number;
+    };
+}
+export interface BaseAppStateObserver {
+    onBaseAppChange: () => void;
+}
+export interface SerializedStates {
+    version: number;
+    systems: SystemState[];
+}
+export interface SystemState {
+    name: string;
+    seriliziationVersion: number;
+    state: object;
+}
+export interface SerializableSystem {
+    name: string;
+    seriliziationVersion: number;
+    getSerializedObject(): object;
+    intializeStateForTransition(serializedState: object | null, version: number): void;
+    applyTransition(percent: number): void;
+}

package/lib/Core/BaseApp/Boundary.js

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

package/lib/Core/BaseApp/Entity.d.ts

@@ -0,0 +1,11 @@
+export interface BaseAppState {
+    isAuthoring: boolean;
+    showBabyonInspector: boolean;
+    handler?: unknown;
+    appAssetsURL?: string;
+    useDevicePreview: boolean;
+    x: number;
+    y: number;
+    isTransitioning: boolean;
+    verbose: boolean;
+}

package/lib/Core/BaseApp/Entity.js

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

package/lib/Core/BaseApp/Errors/ErrorDuplicateSystemName.d.ts

@@ -0,0 +1,3 @@
+export declare class DuplicateSystemNameError extends Error {
+    constructor(name: string);
+}

package/lib/Core/BaseApp/Errors/ErrorDuplicateSystemName.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuplicateSystemNameError = void 0;
+class DuplicateSystemNameError extends Error {
+    constructor(name) {
+        const msg = "Cannot add two serialized systems named " +
+            name +
+            ". Every system name must be unique";
+        super(msg);
+    }
+}
+exports.DuplicateSystemNameError = DuplicateSystemNameError;

package/lib/Core/BaseApp/Errors/ErrorNoHostHandler.d.ts

@@ -0,0 +1,3 @@
+export declare class ErrorNoHostHandler extends Error {
+    constructor();
+}

package/lib/Core/BaseApp/Errors/ErrorNoHostHandler.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ErrorNoHostHandler = void 0;
+class ErrorNoHostHandler extends Error {
+    constructor() {
+        const msg = "Host Handler has not been set";
+        super(msg);
+    }
+}
+exports.ErrorNoHostHandler = ErrorNoHostHandler;

package/lib/Core/BaseApp/Errors/ErrorUnsupportedVersionNumber.d.ts

@@ -0,0 +1,3 @@
+export declare class UnsupportedVersionNumber extends Error {
+    constructor(version: number);
+}

package/lib/Core/BaseApp/Errors/ErrorUnsupportedVersionNumber.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnsupportedVersionNumber = void 0;
+class UnsupportedVersionNumber extends Error {
+    constructor(version) {
+        const msg = "Serialization version " + version + " is not supported";
+        super(msg);
+    }
+}
+exports.UnsupportedVersionNumber = UnsupportedVersionNumber;

package/lib/Core/BaseApp/Errors/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./ErrorDuplicateSystemName";
+export * from "./ErrorUnsupportedVersionNumber";
+export * from "./ErrorNoHostHandler";

package/lib/Core/BaseApp/Errors/index.js

@@ -0,0 +1,15 @@
+"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("./ErrorDuplicateSystemName"), exports);
+__exportStar(require("./ErrorUnsupportedVersionNumber"), exports);
+__exportStar(require("./ErrorNoHostHandler"), exports);

package/lib/Core/BaseApp/UseCase.d.ts

@@ -0,0 +1,43 @@
+import { Handler } from "@vived/app-host-boundary";
+import { BaseAppStateObserver, BaseAppUC, SerializableSystem, SerializedStates } from "./Boundary";
+export declare class BaseAppUCImp implements BaseAppUC {
+    private appState;
+    private observers;
+    private systems;
+    private serilizationVersion;
+    private currentInterval?;
+    private easeFunction;
+    constructor();
+    setVerbose(verbose: boolean): void;
+    abortTransition: () => void;
+    setTransitionEaseFn: (easeFn: (normalizedTime: number) => number) => void;
+    getIsTransitioning: () => boolean;
+    setDevicePreview: (x: number, y: number) => void;
+    clearDevicePreview: () => void;
+    getUseDevicePreview: () => boolean;
+    getDevicePreviewSize: () => {
+        x: number;
+        y: number;
+    };
+    setHostHandler: (handler: Handler) => void;
+    hasHostHandler: () => boolean;
+    dispatchOnStateChange: (stateObject: object) => void;
+    dispatchOnStateComplete: () => void;
+    dispatchSubmitResults: (results: object) => void;
+    dispatchGetAppAssetsURL: () => string;
+    registerSerializableSystem: (serializedSystem: SerializableSystem) => void;
+    getSerializedState: () => SerializedStates;
+    setSerializedState: (state: SerializedStates, duration: number) => void;
+    setDefaultState: (duration: number) => void;
+    getShowBabylonInspector: () => boolean;
+    setShowBabylonInspector: (showInspector: boolean) => void;
+    getIsAuthoring: () => boolean;
+    setIsAuthoring: (isAuthoring: boolean) => void;
+    addObserver: (observer: BaseAppStateObserver) => void;
+    removeObserver: (observer: BaseAppStateObserver) => void;
+    private logToConsole;
+    private startTransition;
+    private applyTransitionToSystems;
+    private notify;
+    private dispatch;
+}

package/lib/Core/BaseApp/UseCase.js

@@ -0,0 +1,250 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseAppUCImp = void 0;
+const app_host_boundary_1 = require("@vived/app-host-boundary");
+const Errors_1 = require("./Errors");
+class BaseAppUCImp {
+    constructor() {
+        this.observers = [];
+        this.systems = new Map();
+        this.serilizationVersion = 2;
+        this.easeFunction = (normalizedTime) => {
+            return normalizedTime; // default to a linear function
+        };
+        this.abortTransition = () => {
+            if (this.currentInterval) {
+                clearInterval(this.currentInterval);
+            }
+            this.appState.isTransitioning = false;
+        };
+        this.setTransitionEaseFn = (easeFn) => {
+            this.easeFunction = easeFn;
+        };
+        this.getIsTransitioning = () => {
+            return this.appState.isTransitioning;
+        };
+        this.setDevicePreview = (x, y) => {
+            if (this.appState.useDevicePreview &&
+                x === this.appState.x &&
+                y === this.appState.y) {
+                return;
+            }
+            this.appState.useDevicePreview = true;
+            this.appState.x = x;
+            this.appState.y = y;
+            this.notify();
+            this.logToConsole(`Device Preview set to ${x}, ${y}`);
+        };
+        this.clearDevicePreview = () => {
+            if (!this.appState.useDevicePreview)
+                return;
+            this.appState.useDevicePreview = false;
+            this.appState.x = -1;
+            this.appState.y = -1;
+            this.notify();
+            this.logToConsole(`Device Preview cleared`);
+        };
+        this.getUseDevicePreview = () => {
+            return this.appState.useDevicePreview;
+        };
+        this.getDevicePreviewSize = () => {
+            const { x, y } = this.appState;
+            return { x, y };
+        };
+        this.setHostHandler = (handler) => {
+            this.appState.handler = handler;
+            this.logToConsole("Handler set");
+        };
+        this.hasHostHandler = () => {
+            if (this.appState.handler) {
+                return true;
+            }
+            else {
+                return false;
+            }
+        };
+        this.dispatchOnStateChange = (stateObject) => {
+            const request = {
+                type: app_host_boundary_1.ON_STATE_CHANGE,
+                version: 1,
+                payload: {
+                    stateObject,
+                },
+            };
+            this.dispatch(request);
+        };
+        this.dispatchOnStateComplete = () => {
+            const request = {
+                type: app_host_boundary_1.ON_STATE_COMPLETED,
+                version: 1,
+            };
+            this.dispatch(request);
+        };
+        this.dispatchSubmitResults = (results) => {
+            const request = {
+                type: app_host_boundary_1.SUBMIT_RESULTS,
+                version: 1,
+                payload: {
+                    results,
+                },
+            };
+            this.dispatch(request);
+        };
+        this.dispatchGetAppAssetsURL = () => {
+            var _a;
+            const callback = (url) => {
+                this.appState.appAssetsURL = url;
+            };
+            const request = {
+                type: app_host_boundary_1.GET_APP_ASSET_URL,
+                version: 1,
+                payload: {
+                    callback,
+                },
+            };
+            this.dispatch(request);
+            return (_a = this.appState.appAssetsURL) !== null && _a !== void 0 ? _a : "";
+        };
+        this.registerSerializableSystem = (serializedSystem) => {
+            if (this.systems.has(serializedSystem.name)) {
+                throw new Errors_1.DuplicateSystemNameError(serializedSystem.name);
+            }
+            this.systems.set(serializedSystem.name, serializedSystem);
+        };
+        this.getSerializedState = () => {
+            const systems = Array.from(this.systems.values());
+            const serializedStates = systems.map((system) => {
+                const state = system.getSerializedObject();
+                return {
+                    seriliziationVersion: system.seriliziationVersion,
+                    name: system.name,
+                    state,
+                };
+            });
+            return {
+                version: this.serilizationVersion,
+                systems: serializedStates,
+            };
+        };
+        this.setSerializedState = (state, duration) => {
+            if (state.version === 2) {
+                state.systems.forEach((systemState) => {
+                    const seriliazableSystem = this.systems.get(systemState.name);
+                    if (seriliazableSystem) {
+                        seriliazableSystem.intializeStateForTransition(systemState.state, systemState.seriliziationVersion);
+                    }
+                    else {
+                        console.warn("Unable to find seriarializedSystem " + systemState.name);
+                    }
+                });
+            }
+            // Here is where we will add support for future versions
+            else {
+                throw new Errors_1.UnsupportedVersionNumber(state.version);
+            }
+            this.startTransition(duration);
+            this.logToConsole(`State set to ${JSON.stringify(state)} with a ${duration} second duration`);
+        };
+        this.setDefaultState = (duration) => {
+            this.systems.forEach((system) => {
+                system.intializeStateForTransition(null, -1);
+            });
+            this.startTransition(duration);
+            this.logToConsole(`State has been set to transition to default over ${duration} seconds`);
+        };
+        this.getShowBabylonInspector = () => {
+            return this.appState.showBabyonInspector;
+        };
+        this.setShowBabylonInspector = (showInspector) => {
+            if (this.appState.showBabyonInspector === showInspector)
+                return;
+            this.appState.showBabyonInspector = showInspector;
+            this.notify();
+            this.logToConsole(`Show Babylon Inspector set to ${showInspector}`);
+        };
+        this.getIsAuthoring = () => {
+            return this.appState.isAuthoring;
+        };
+        this.setIsAuthoring = (isAuthoring) => {
+            if (isAuthoring === this.appState.isAuthoring)
+                return;
+            this.appState.isAuthoring = isAuthoring;
+            this.notify();
+            this.logToConsole(`Is Authoring set to ${isAuthoring}`);
+        };
+        this.addObserver = (observer) => {
+            this.observers.push(observer);
+        };
+        this.removeObserver = (observer) => {
+            const index = this.observers.indexOf(observer);
+            if (index >= 0) {
+                this.observers.splice(index, 1);
+            }
+        };
+        this.appState = {
+            isAuthoring: false,
+            showBabyonInspector: false,
+            useDevicePreview: false,
+            x: -1,
+            y: -1,
+            isTransitioning: false,
+            verbose: false,
+        };
+    }
+    setVerbose(verbose) {
+        this.appState.verbose = verbose;
+    }
+    logToConsole(message) {
+        if (!this.appState.verbose)
+            return;
+        console.log("[Base App UC] " + message);
+    }
+    startTransition(duration) {
+        if (duration === 0) {
+            if (this.currentInterval) {
+                clearInterval(this.currentInterval);
+                this.appState.isTransitioning = false;
+            }
+            this.applyTransitionToSystems(1);
+        }
+        else {
+            if (this.currentInterval) {
+                clearInterval(this.currentInterval);
+            }
+            this.appState.isTransitioning = true;
+            const durationInMS = duration * 1000;
+            let chrono = 0;
+            const transitionDelta = 10;
+            this.currentInterval = setInterval(() => {
+                chrono = chrono + transitionDelta;
+                let normalizedTime = chrono / durationInMS;
+                if (normalizedTime > 1) {
+                    normalizedTime = 1;
+                }
+                const percent = this.easeFunction(normalizedTime);
+                this.applyTransitionToSystems(percent);
+                if (normalizedTime >= 1 && this.currentInterval) {
+                    clearInterval(this.currentInterval);
+                    this.appState.isTransitioning = false;
+                }
+            }, transitionDelta);
+        }
+    }
+    applyTransitionToSystems(percent) {
+        this.systems.forEach((system) => {
+            system.applyTransition(percent);
+        });
+    }
+    notify() {
+        this.observers.forEach((observer) => observer.onBaseAppChange());
+    }
+    dispatch(request) {
+        if (!this.appState.handler) {
+            throw new Errors_1.ErrorNoHostHandler();
+        }
+        const handler = this.appState.handler;
+        handler(request);
+        this.logToConsole(`Dispatched request: ${JSON.stringify(request)}`);
+    }
+}
+exports.BaseAppUCImp = BaseAppUCImp;

package/lib/Core/BaseAppState/Boundary.d.ts

@@ -0,0 +1,14 @@
+export interface BaseAppStateUC {
+    getIsAuthoring(): boolean;
+    setIsAuthoring(isAuthoring: boolean): void;
+    getShowBabylonInspector(): boolean;
+    setShowBabylonInspector(showInspector: boolean): void;
+    getAppContainer(): HTMLElement | undefined;
+    setAppContainer(container: HTMLElement): void;
+    clearAppContainer(): void;
+    addObserver(observer: BaseAppStateObserver): void;
+    removeObserver(observer: BaseAppStateObserver): void;
+}
+export interface BaseAppStateObserver {
+    onAppStateChange: () => void;
+}

package/lib/Core/BaseAppState/Boundary.js

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

package/lib/Core/BaseAppState/Entity.d.ts

@@ -0,0 +1,5 @@
+export interface BaseAppState {
+    isAuthoring: boolean;
+    showBabyonInspector: boolean;
+    appContainer?: HTMLElement;
+}

package/lib/Core/BaseAppState/Entity.js

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

package/lib/Core/BaseAppState/UseCase.d.ts

@@ -0,0 +1,16 @@
+import { BaseAppStateObserver, BaseAppStateUC } from "./Boundary";
+export declare class BaseAppStateUCImp implements BaseAppStateUC {
+    private appState;
+    private observers;
+    constructor();
+    getAppContainer(): HTMLElement | undefined;
+    setAppContainer(container: HTMLElement): void;
+    clearAppContainer(): void;
+    getShowBabylonInspector(): boolean;
+    setShowBabylonInspector(showInspector: boolean): void;
+    getIsAuthoring(): boolean;
+    setIsAuthoring(isAuthoring: boolean): void;
+    addObserver(observer: BaseAppStateObserver): void;
+    removeObserver(observer: BaseAppStateObserver): void;
+    private notify;
+}

package/lib/Core/BaseAppState/UseCase.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseAppStateUCImp = void 0;
+class BaseAppStateUCImp {
+    constructor() {
+        this.observers = [];
+        this.appState = {
+            isAuthoring: false,
+            showBabyonInspector: false,
+        };
+    }
+    getAppContainer() {
+        return this.appState.appContainer;
+    }
+    setAppContainer(container) {
+        this.appState.appContainer = container;
+        this.notify();
+    }
+    clearAppContainer() {
+        this.appState.appContainer = undefined;
+        this.notify();
+    }
+    getShowBabylonInspector() {
+        return this.appState.showBabyonInspector;
+    }
+    setShowBabylonInspector(showInspector) {
+        if (this.appState.showBabyonInspector === showInspector)
+            return;
+        this.appState.showBabyonInspector = showInspector;
+        this.notify();
+    }
+    getIsAuthoring() {
+        return this.appState.isAuthoring;
+    }
+    setIsAuthoring(isAuthoring) {
+        if (isAuthoring === this.appState.isAuthoring)
+            return;
+        this.appState.isAuthoring = isAuthoring;
+        this.notify();
+    }
+    addObserver(observer) {
+        this.observers.push(observer);
+    }
+    removeObserver(observer) {
+        const index = this.observers.indexOf(observer);
+        if (index >= 0) {
+            this.observers.splice(index, 1);
+        }
+    }
+    notify() {
+        this.observers.forEach((observer) => observer.onAppStateChange());
+    }
+}
+exports.BaseAppStateUCImp = BaseAppStateUCImp;

package/lib/Core/BaseAppState/UseCase_Imp.d.ts

@@ -0,0 +1,16 @@
+import { BaseAppStateObserver, BaseAppStateUC } from "./Boundary";
+export declare class BaseAppStateUC_Imp implements BaseAppStateUC {
+    private appState;
+    private observers;
+    constructor();
+    getAppContainer(): HTMLElement | undefined;
+    setAppContainer(container: HTMLElement): void;
+    clearAppContainer(): void;
+    getShowBabylonInspector(): boolean;
+    setShowBabylonInspector(showInspector: boolean): void;
+    getIsAuthoring(): boolean;
+    setIsAuthoring(isAuthoring: boolean): void;
+    addObserver(observer: BaseAppStateObserver): void;
+    removeObserver(observer: BaseAppStateObserver): void;
+    private notify;
+}

package/lib/Core/BaseAppState/UseCase_Imp.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseAppStateUC_Imp = void 0;
+class BaseAppStateUC_Imp {
+    constructor() {
+        this.observers = [];
+        this.appState = {
+            isAuthoring: false,
+            showBabyonInspector: false,
+        };
+    }
+    getAppContainer() {
+        return this.appState.appContainer;
+    }
+    setAppContainer(container) {
+        this.appState.appContainer = container;
+        this.notify();
+    }
+    clearAppContainer() {
+        this.appState.appContainer = undefined;
+        this.notify();
+    }
+    getShowBabylonInspector() {
+        return this.appState.showBabyonInspector;
+    }
+    setShowBabylonInspector(showInspector) {
+        if (this.appState.showBabyonInspector === showInspector)
+            return;
+        this.appState.showBabyonInspector = showInspector;
+        this.notify();
+    }
+    getIsAuthoring() {
+        return this.appState.isAuthoring;
+    }
+    setIsAuthoring(isAuthoring) {
+        if (isAuthoring === this.appState.isAuthoring)
+            return;
+        this.appState.isAuthoring = isAuthoring;
+        this.notify();
+    }
+    addObserver(observer) {
+        this.observers.push(observer);
+    }
+    removeObserver(observer) {
+        const index = this.observers.indexOf(observer);
+        if (index >= 0) {
+            this.observers.splice(index, 1);
+        }
+    }
+    notify() {
+        this.observers.forEach((observer) => observer.onAppStateChange());
+    }
+}
+exports.BaseAppStateUC_Imp = BaseAppStateUC_Imp;

package/lib/Core/DevicePreview/DevicePreviewUC_Imp.d.ts

@@ -0,0 +1,16 @@
+import { DevicePreviewUC, OnDevicePreviewChange } from "./boundary";
+export declare class DevicePreviewUCImp implements DevicePreviewUC {
+    private observers;
+    private entity;
+    constructor();
+    setDevicePreview(x: number, y: number): void;
+    clearDevicePreview(): void;
+    getUseDevicePreview(): boolean;
+    getDevicePreviewSize(): {
+        x: number;
+        y: number;
+    };
+    addObserver(observer: OnDevicePreviewChange): void;
+    removeObserver(observer: OnDevicePreviewChange): void;
+    private notify;
+}