@vived/app 2.18.1 → 2.18.2

package/lib/Core/DevicePreview/DevicePreviewUC_Imp.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DevicePreviewUCImp = void 0;
+class DevicePreviewUCImp {
+    constructor() {
+        this.observers = [];
+        this.entity = {
+            useDevicePreview: false,
+            x: -1,
+            y: -1,
+        };
+    }
+    setDevicePreview(x, y) {
+        if (this.entity.useDevicePreview &&
+            x === this.entity.x &&
+            y === this.entity.y) {
+            return;
+        }
+        this.entity = {
+            useDevicePreview: true,
+            x,
+            y,
+        };
+        this.notify();
+    }
+    clearDevicePreview() {
+        if (this.entity.useDevicePreview) {
+            this.entity = {
+                useDevicePreview: false,
+                x: -1,
+                y: -1,
+            };
+            this.notify();
+        }
+    }
+    getUseDevicePreview() {
+        return this.entity.useDevicePreview;
+    }
+    getDevicePreviewSize() {
+        const { x, y } = this.entity;
+        return { x, y };
+    }
+    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((obs) => obs.onDevicePreviewChange());
+    }
+}
+exports.DevicePreviewUCImp = DevicePreviewUCImp;

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

@@ -0,0 +1,14 @@
+export interface OnDevicePreviewChange {
+    onDevicePreviewChange: () => void;
+}
+export interface DevicePreviewUC {
+    setDevicePreview(x: number, y: number): void;
+    clearDevicePreview(): void;
+    getUseDevicePreview(): boolean;
+    getDevicePreviewSize(): {
+        x: number;
+        y: number;
+    };
+    addObserver(observer: OnDevicePreviewChange): void;
+    removeObserver(observer: OnDevicePreviewChange): void;
+}

package/lib/Core/DevicePreview/boundary.js

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

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

@@ -0,0 +1,5 @@
+export interface DevicePreview {
+    useDevicePreview: boolean;
+    x: number;
+    y: number;
+}

package/lib/Core/DevicePreview/entity.js

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

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

@@ -0,0 +1,4 @@
+export interface DispatchToHostEntity {
+    handler?: unknown;
+    appAssetsURL?: string;
+}

package/lib/Core/DispatchToHost/Entity.js

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

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

@@ -0,0 +1,12 @@
+import { Handler } from "@vived/app-host-boundary";
+import { DispatchToHostUC } from "./boundary";
+export declare class DispatchToHostUCImp implements DispatchToHostUC {
+    private entity;
+    setHostHandler(handler: Handler): void;
+    hasHostHandler(): boolean;
+    onStateChange(stateObject: object): void;
+    onStateComplete(): void;
+    submitResults(results: object): void;
+    getAssetURL(): string;
+    private dispatch;
+}

package/lib/Core/DispatchToHost/UseCase.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DispatchToHostUCImp = void 0;
+const app_host_boundary_1 = require("@vived/app-host-boundary");
+class DispatchToHostUCImp {
+    constructor() {
+        this.entity = {};
+    }
+    setHostHandler(handler) {
+        this.entity.handler = handler;
+    }
+    hasHostHandler() {
+        if (this.entity.handler) {
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
+    onStateChange(stateObject) {
+        const request = {
+            type: app_host_boundary_1.ON_STATE_CHANGE,
+            version: 1,
+            payload: {
+                stateObject,
+            },
+        };
+        this.dispatch(request);
+    }
+    onStateComplete() {
+        const request = {
+            type: app_host_boundary_1.ON_STATE_COMPLETED,
+            version: 1,
+        };
+        this.dispatch(request);
+    }
+    submitResults(results) {
+        const request = {
+            type: app_host_boundary_1.SUBMIT_RESULTS,
+            version: 1,
+            payload: {
+                results,
+            },
+        };
+        this.dispatch(request);
+    }
+    getAssetURL() {
+        var _a;
+        const callback = (url) => {
+            this.entity.appAssetsURL = url;
+        };
+        const request = {
+            type: app_host_boundary_1.GET_APP_ASSET_URL,
+            version: 1,
+            payload: {
+                callback,
+            },
+        };
+        this.dispatch(request);
+        return (_a = this.entity.appAssetsURL) !== null && _a !== void 0 ? _a : "";
+    }
+    dispatch(request) {
+        if (!this.entity.handler) {
+            throw new Error("No host handler has been set");
+        }
+        const handler = this.entity.handler;
+        handler(request);
+    }
+}
+exports.DispatchToHostUCImp = DispatchToHostUCImp;

package/lib/Core/DispatchToHost/boundary.d.ts

@@ -0,0 +1,9 @@
+import { Handler } from "@vived/app-host-boundary";
+export interface DispatchToHostUC {
+    setHostHandler(handler: Handler): void;
+    hasHostHandler(): boolean;
+    onStateChange(stateObject: object): void;
+    onStateComplete(): void;
+    submitResults(results: object): void;
+    getAssetURL(): string;
+}

package/lib/Core/DispatchToHost/boundary.js

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

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

@@ -0,0 +1,20 @@
+export interface SerilizationUC {
+    getSerializedState(): SerializedStates;
+    setSerializedState(state: SerializedStates): void;
+    registerSerializableSystem(serializedSystem: SerializableSystem): 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;
+    applySerailizedObject(state: object, version: number): void;
+}

package/lib/Core/Serilization/Boundary.js

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

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

@@ -0,0 +1,3 @@
+export interface Serilization {
+    version: number;
+}

package/lib/Core/Serilization/Entity.js

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

package/lib/Core/Serilization/ErrorDuplicateSystemName.d.ts

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

package/lib/Core/Serilization/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/Serilization/ErrorUnsupportedVersionNumber.d.ts

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

package/lib/Core/Serilization/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/Serilization/Errors.d.ts

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

package/lib/Core/Serilization/Errors.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnsupportedVersionNumber = 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;
+class UnsupportedVersionNumber extends Error {
+    constructor(version) {
+        const msg = "Serialization version " + version + " is not supported";
+        super(msg);
+    }
+}
+exports.UnsupportedVersionNumber = UnsupportedVersionNumber;

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

@@ -0,0 +1,10 @@
+import { SerializedStates, SerializableSystem, SerilizationUC } from "./Boundary";
+import * as Entity from "./Entity";
+export declare class SerilizationUCImp implements SerilizationUC {
+    serilizationEntity: Entity.Serilization;
+    private systems;
+    constructor();
+    registerSerializableSystem(serializedSystem: SerializableSystem): void;
+    getSerializedState(): SerializedStates;
+    setSerializedState(state: SerializedStates): void;
+}

package/lib/Core/Serilization/UseCase.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SerilizationUCImp = void 0;
+const ErrorDuplicateSystemName_1 = require("./ErrorDuplicateSystemName");
+const ErrorUnsupportedVersionNumber_1 = require("./ErrorUnsupportedVersionNumber");
+class SerilizationUCImp {
+    constructor() {
+        this.systems = new Map();
+        this.serilizationEntity = {
+            version: 2,
+        };
+    }
+    registerSerializableSystem(serializedSystem) {
+        if (this.systems.has(serializedSystem.name)) {
+            throw new ErrorDuplicateSystemName_1.DuplicateSystemNameError(serializedSystem.name);
+        }
+        this.systems.set(serializedSystem.name, serializedSystem);
+    }
+    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.serilizationEntity.version,
+            systems: serializedStates,
+        };
+    }
+    setSerializedState(state) {
+        if (state.version === 2) {
+            state.systems.forEach((systemState) => {
+                const seriliazableSystem = this.systems.get(systemState.name);
+                if (seriliazableSystem) {
+                    seriliazableSystem.applySerailizedObject(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 ErrorUnsupportedVersionNumber_1.UnsupportedVersionNumber(state.version);
+        }
+    }
+}
+exports.SerilizationUCImp = SerilizationUCImp;

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

@@ -0,0 +1,10 @@
+import { SerializedStates, SerializableSystem, SerilizationUC } from "./Boundary";
+import * as Entity from "./Entity";
+export declare class SerilizationUC_Imp implements SerilizationUC {
+    serilizationEntity: Entity.Serilization;
+    private systems;
+    constructor();
+    registerSerializableSystem(serializedSystem: SerializableSystem): void;
+    getSerializedState(): SerializedStates;
+    setSerializedState(state: SerializedStates): void;
+}

package/lib/Core/Serilization/UseCase_Imp.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SerilizationUC_Imp = void 0;
+const Errors_1 = require("./Errors");
+class SerilizationUC_Imp {
+    constructor() {
+        this.systems = new Map();
+        this.serilizationEntity = {
+            version: 2,
+        };
+    }
+    registerSerializableSystem(serializedSystem) {
+        if (this.systems.has(serializedSystem.name)) {
+            throw new Errors_1.DuplicateSystemNameError(serializedSystem.name);
+        }
+        this.systems.set(serializedSystem.name, serializedSystem);
+    }
+    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.serilizationEntity.version,
+            systems: serializedStates,
+        };
+    }
+    setSerializedState(state) {
+        if (state.version === 2) {
+            state.systems.forEach((systemState) => {
+                const seriliazableSystem = this.systems.get(systemState.name);
+                if (seriliazableSystem) {
+                    seriliazableSystem.applySerailizedObject(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);
+        }
+    }
+}
+exports.SerilizationUC_Imp = SerilizationUC_Imp;

package/lib/Core/index.d.ts

@@ -0,0 +1,3 @@
+import { BaseAppUC } from "./BaseApp/Boundary";
+export * from "./BaseApp/Boundary";
+export declare function makeBaseAppUC(): BaseAppUC;

package/lib/Core/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 });
+exports.makeBaseAppUC = void 0;
+const UseCase_1 = require("./BaseApp/UseCase");
+__exportStar(require("./BaseApp/Boundary"), exports);
+function makeBaseAppUC() {
+    return new UseCase_1.BaseAppUCImp();
+}
+exports.makeBaseAppUC = makeBaseAppUC;

package/lib/Entities/Babylon.js

@@ -29,11 +29,16 @@ class BabylonImp {
                 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)

package/lib/Entities/Color.d.ts

@@ -0,0 +1,20 @@
+export declare class Color {
+    static White(): Color;
+    static Black(): Color;
+    static Red(): Color;
+    static Green(): Color;
+    static Blue(): Color;
+    static Yellow(): Color;
+    static Gray(): Color;
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+    get rPercent(): number;
+    get gPercent(): number;
+    get bPercent(): number;
+    get aPercent(): number;
+    equal: (otherColor: Color) => boolean;
+    copy: () => Color;
+    constructor(r: number, g: number, b: number, a?: number);
+}

package/lib/Entities/Color.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Color = void 0;
+class Color {
+    constructor(r, g, b, a = 255) {
+        this.equal = (otherColor) => {
+            if (otherColor.r === this.r &&
+                otherColor.g === this.g &&
+                otherColor.b === this.b &&
+                otherColor.a === this.a) {
+                return true;
+            }
+            else {
+                return false;
+            }
+        };
+        this.copy = () => {
+            return new Color(this.r, this.g, this.b, this.a);
+        };
+        this.r = r;
+        this.g = g;
+        this.b = b;
+        this.a = a;
+    }
+    static White() {
+        return new Color(255, 255, 255, 255);
+    }
+    static Black() {
+        return new Color(0, 0, 0, 255);
+    }
+    static Red() {
+        return new Color(255, 0, 0, 255);
+    }
+    static Green() {
+        return new Color(0, 255, 0, 255);
+    }
+    static Blue() {
+        return new Color(0, 0, 255, 255);
+    }
+    static Yellow() {
+        return new Color(255, 0, 255, 255);
+    }
+    static Gray() {
+        return new Color(192, 192, 192, 255);
+    }
+    get rPercent() {
+        return this.r / 255;
+    }
+    get gPercent() {
+        return this.g / 255;
+    }
+    get bPercent() {
+        return this.b / 255;
+    }
+    get aPercent() {
+        return this.a / 255;
+    }
+}
+exports.Color = Color;

package/lib/Entities/LineSegment2D.d.ts

@@ -0,0 +1,11 @@
+import { Vector2 } from "./Vector2";
+export declare class LineSegment2D {
+    start: Vector2;
+    end: Vector2;
+    get length(): number;
+    get direction(): Vector2;
+    getPositionAtPercent(percent: number): Vector2;
+    closestPointOnLine(point: Vector2): Vector2;
+    intersect(otherLine: LineSegment2D, tolerance?: number): Vector2 | undefined;
+    constructor(start: Vector2, end: Vector2);
+}

package/lib/Entities/LineSegment2D.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LineSegment2D = void 0;
+const Vector2_1 = require("./Vector2");
+class LineSegment2D {
+    constructor(start, end) {
+        this.start = start;
+        this.end = end;
+    }
+    get length() {
+        return this.end.subtract(this.start).magnitued;
+    }
+    get direction() {
+        return this.end.subtract(this.start).unit;
+    }
+    getPositionAtPercent(percent) {
+        const dir = this.direction;
+        const length = percent * this.length;
+        dir.setLength(length);
+        return this.start.add(dir);
+    }
+    closestPointOnLine(point) {
+        // see https://monkeyproofsolutions.nl/wordpress/how-to-calculate-the-shortest-distance-between-a-point-and-a-line/
+        const direction = this.end.subtract(this.start);
+        const tNumerator = direction.dot(point.subtract(this.start));
+        const tDenominator = direction.dot(direction);
+        const t = tNumerator / tDenominator;
+        if (t < 0) {
+            return this.start.copy();
+        }
+        else if (t > 1) {
+            return this.end.copy();
+        }
+        else {
+            const length = t * direction.magnitued;
+            direction.setLength(length);
+            return this.start.add(direction);
+        }
+    }
+    intersect(otherLine, tolerance = 0) {
+        // See https://en.wikipedia.org/wiki/Line%E2%80%93line_intersection
+        const x1 = this.start.x;
+        const y1 = this.start.y;
+        const x2 = this.end.x;
+        const y2 = this.end.y;
+        const x3 = otherLine.start.x;
+        const y3 = otherLine.start.y;
+        const x4 = otherLine.end.x;
+        const y4 = otherLine.end.y;
+        const denominator = (x1 - x2) * (y3 - y4) - (y1 - y2) * (x3 - x4);
+        if (denominator === 0) {
+            return undefined;
+        }
+        const tNumerator = (x1 - x3) * (y3 - y4) - (y1 - y3) * (x3 - x4);
+        const t = tNumerator / denominator;
+        const tTolearnce = tolerance / this.length;
+        if (t < -tTolearnce || t > 1 + tTolearnce) {
+            return undefined;
+        }
+        const uNumerator = (x2 - x1) * (y1 - y3) - (y2 - y1) * (x1 - x3);
+        const u = uNumerator / denominator;
+        const uTolearnce = tolerance / otherLine.length;
+        if (u < -uTolearnce || u > 1 + uTolearnce)
+            return undefined;
+        const px = x1 + t * (x2 - x1);
+        const py = y1 + t * (y2 - y1);
+        return new Vector2_1.Vector2(px, py);
+    }
+}
+exports.LineSegment2D = LineSegment2D;

package/lib/Entities/MouseSceneInput.d.ts

@@ -0,0 +1,15 @@
+export interface MouseController {
+    onClick?: (e: MouseEvent) => void;
+    onDown?: (e: MouseEvent) => void;
+    onUp?: (e: MouseEvent) => void;
+    onMove?: (e: MouseEvent) => void;
+    onWheel?: (e: WheelEvent) => void;
+}
+export interface MouseSceneInput {
+    eventElement: HTMLElement | undefined;
+    setEventElement: (eventElement: HTMLElement) => void;
+    clearInputElement: () => void;
+    registerController: (controller: MouseController) => void;
+    removeController: (controller: MouseController) => void;
+}
+export declare function makeMouseSceneInput(): MouseSceneInput;