@vived/app 4.27.0 → 4.27.1

package/lib/Entities/TouchInput.js

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeTouchInput = void 0;
+const ValueObjects_1 = require("../ValueObjects");
+function makeTouchInput() {
+    return new TouchInputImp();
+}
+exports.makeTouchInput = makeTouchInput;
+class TouchInputImp {
+    constructor() {
+        this.controllers = [];
+        this._eventElement = undefined;
+        this.updateInputElementBounds = () => {
+            if (!this._eventElement)
+                return;
+            this.eventElementBounds = this._eventElement.getBoundingClientRect(); // Expensive so we cache
+        };
+        this.getTouchOffsetPosition = (touch) => {
+            if (!this.eventElementBounds) {
+                console.warn("No target bounds");
+                return ValueObjects_1.Vector2.Zero();
+            }
+            const x = touch.clientX - this.eventElementBounds.x;
+            const y = touch.clientY - this.eventElementBounds.y;
+            return new ValueObjects_1.Vector2(x, y);
+        };
+        this.setEventElement = (eventElement) => {
+            if (this._eventElement)
+                this.clearInputElement();
+            eventElement.addEventListener("touchstart", this.onTouchStart, false);
+            eventElement.addEventListener("touchmove", this.onTouchMove, false);
+            eventElement.addEventListener("touchend", this.onTouchEnd, false);
+            eventElement.addEventListener("touchcancel", this.onTouchCancel, false);
+            this.eventElementBounds = eventElement.getBoundingClientRect();
+            this._eventElement = eventElement;
+        };
+        this.onTouchStart = (e) => {
+            if (e.cancelable)
+                e.preventDefault();
+            const touchInput = this.createTouchInputEvent(e);
+            this.controllers.forEach((c) => {
+                if (c.onTouchStart) {
+                    c.onTouchStart(touchInput);
+                }
+            });
+        };
+        this.onTouchMove = (e) => {
+            if (e.cancelable)
+                e.preventDefault();
+            const touchInput = this.createTouchInputEvent(e);
+            this.controllers.forEach((c) => {
+                if (c.onTouchMove) {
+                    c.onTouchMove(touchInput);
+                }
+            });
+        };
+        this.onTouchEnd = (e) => {
+            if (e.cancelable)
+                e.preventDefault();
+            const touchInput = this.createTouchInputEvent(e);
+            this.controllers.forEach((c) => {
+                if (c.onTouchEnd) {
+                    c.onTouchEnd(touchInput);
+                }
+            });
+        };
+        this.onTouchCancel = (e) => {
+            if (e.cancelable)
+                e.preventDefault();
+            const touchInput = this.createTouchInputEvent(e);
+            this.controllers.forEach((c) => {
+                if (c.onTouchCancel) {
+                    c.onTouchCancel(touchInput);
+                }
+            });
+        };
+        this.clearInputElement = () => {
+            if (!this._eventElement)
+                return;
+            this._eventElement.removeEventListener("touchstart", this.onTouchStart);
+            this._eventElement.removeEventListener("touchmove", this.onTouchMove);
+            this._eventElement.removeEventListener("touchend", this.onTouchEnd);
+            this._eventElement.removeEventListener("touchcancel", this.onTouchCancel);
+            this._eventElement = undefined;
+        };
+        this.registerController = (controller) => {
+            this.controllers.push(controller);
+        };
+        this.removeController = (controller) => {
+            const index = this.controllers.indexOf(controller);
+            if (index >= 0) {
+                this.controllers.splice(index, 1);
+            }
+        };
+    }
+    get eventElement() {
+        return this._eventElement;
+    }
+    createTouchInputEvent(event) {
+        const touches = [];
+        const touchCount = event.touches.length;
+        let minX = 0;
+        let maxX = 0;
+        let minY = 0;
+        let maxY = 0;
+        for (let i = 0; i < touchCount; i++) {
+            const touch = event.touches[i];
+            const position = this.getTouchOffsetPosition(touch);
+            touches.push({
+                id: touch.identifier,
+                touch,
+                position,
+            });
+            if (i === 0) {
+                minX = position.x;
+                maxX = position.x;
+                minY = position.y;
+                maxY = position.y;
+            }
+            else {
+                minX = Math.min(minX, position.x);
+                maxX = Math.max(maxX, position.x);
+                minY = Math.min(minY, position.y);
+                maxY = Math.max(maxY, position.y);
+            }
+        }
+        let cntX = 0;
+        let cntY = 0;
+        if (touchCount === 1) {
+            cntX = maxX;
+            cntY = maxY;
+        }
+        else {
+            cntX = minX + (maxX - minX) / 2;
+            cntY = minY + (maxY - minY) / 2;
+        }
+        return {
+            touchCenter: new ValueObjects_1.Vector2(cntX, cntY),
+            touchCount,
+            touches,
+            event,
+        };
+    }
+}

package/lib/Entities/UndoRedo.d.ts

@@ -0,0 +1,22 @@
+export declare type OnUndoRedoChange = () => void;
+export interface UndoRedoer {
+    undoAction: (action: UndoRedoAction) => void;
+    redoAction: (action: UndoRedoAction) => void;
+}
+export declare type DoUndoRedoAction = (action: UndoRedoAction) => void;
+export interface UndoRedo {
+    hasUndo: boolean;
+    hasRedo: boolean;
+    submitAction: (action: UndoRedoAction) => void;
+    doUndo: () => void;
+    doRedo: () => void;
+    clearStack: () => void;
+    registerUndoRedoer: (undoRedoer: UndoRedoer) => void;
+    addObserver: (observer: OnUndoRedoChange) => void;
+    removeObserver: (observer: OnUndoRedoChange) => void;
+}
+export declare function makeUndoRedo(): UndoRedo;
+export declare type UndoRedoAction = {
+    type: string;
+    payload: object;
+};

package/lib/Entities/UndoRedo.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeUndoRedo = void 0;
+const _1 = require(".");
+function makeUndoRedo() {
+    return new UndoRedoImp();
+}
+exports.makeUndoRedo = makeUndoRedo;
+class UndoRedoImp {
+    constructor() {
+        this.observers = new _1.ObserverList();
+        this.undoRedoers = [];
+        this.undoStack = [];
+        this.redoStack = [];
+        this.doUndo = () => {
+            const action = this.undoStack.pop();
+            if (!action) {
+                console.warn("[UndoRedo] nothing to undo");
+                return;
+            }
+            this.redoStack.push(action);
+            this.undoRedoers.forEach(undoers => undoers.undoAction(action));
+            this.observers.notify();
+        };
+        this.doRedo = () => {
+            const action = this.redoStack.pop();
+            if (!action) {
+                console.warn("[UndoRedo] nothing to redo");
+                return;
+            }
+            this.undoStack.push(action);
+            this.undoRedoers.forEach(redoers => redoers.redoAction(action));
+            this.observers.notify();
+        };
+        this.submitAction = (action) => {
+            this.undoStack.push(action);
+            this.redoStack = [];
+            this.observers.notify();
+        };
+        this.clearStack = () => {
+            this.redoStack = [];
+            this.undoStack = [];
+            this.observers.notify();
+        };
+        this.registerUndoRedoer = (undoredoer) => {
+            this.undoRedoers.push(undoredoer);
+        };
+        this.addObserver = (observer) => {
+            this.observers.add(observer);
+        };
+        this.removeObserver = (observer) => {
+            this.observers.remove(observer);
+        };
+    }
+    get hasUndo() {
+        return this.undoStack.length > 0;
+    }
+    get hasRedo() {
+        return this.redoStack.length > 0;
+    }
+}

package/lib/PresentationManagers/DevicePreviewPM.d.ts

@@ -0,0 +1,14 @@
+import { DevicePreview } from "../Entities";
+export interface DevicePreviewVM {
+    x: number;
+    y: number;
+    useDevicePreview: boolean;
+}
+export declare class DevicePreviewPM {
+    devicePreview: DevicePreview;
+    updateView: (vm: DevicePreviewVM) => void;
+    doUpdateView: () => void;
+    dispose(): void;
+    constructor(devicePreview: DevicePreview, updateView: (vm: DevicePreviewVM) => void);
+}
+export declare const defaultDevicePreviewVM: DevicePreviewVM;

package/lib/PresentationManagers/DevicePreviewPM.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultDevicePreviewVM = exports.DevicePreviewPM = void 0;
+class DevicePreviewPM {
+    constructor(devicePreview, updateView) {
+        this.doUpdateView = () => {
+            const useDevicePreview = this.devicePreview.useDevicePreview;
+            const x = this.devicePreview.previewSize.x;
+            const y = this.devicePreview.previewSize.y;
+            this.updateView({
+                x,
+                y,
+                useDevicePreview,
+            });
+        };
+        this.devicePreview = devicePreview;
+        this.updateView = updateView;
+        this.doUpdateView();
+        this.devicePreview.addObserver(this.doUpdateView);
+    }
+    dispose() {
+        this.devicePreview.removeObserver(this.doUpdateView);
+    }
+}
+exports.DevicePreviewPM = DevicePreviewPM;
+exports.defaultDevicePreviewVM = {
+    x: 0,
+    y: 0,
+    useDevicePreview: false,
+};

package/lib/PresentationManagers/FocusCameraPM.d.ts

@@ -0,0 +1,15 @@
+import { FocusCamera } from "../Entities";
+import { Vector3 } from "../ValueObjects";
+export interface FocusCameraVM {
+    alphaEuler: Vector3;
+    betaEuler: Vector3;
+    cameraLocalPosition: Vector3;
+    target: Vector3;
+}
+export declare class FocusCameraPM {
+    private orbitCam;
+    private view;
+    dispose(): void;
+    private doUpdateView;
+    constructor(orbitCamera: FocusCamera, view: (vm: FocusCameraVM) => void);
+}

package/lib/PresentationManagers/FocusCameraPM.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FocusCameraPM = void 0;
+const Utilities_1 = require("../Utilities");
+const ValueObjects_1 = require("../ValueObjects");
+class FocusCameraPM {
+    constructor(orbitCamera, view) {
+        this.doUpdateView = () => {
+            const { alpha, beta, radius, target } = this.orbitCam;
+            const alphaRadians = Utilities_1.degreesToRadians(alpha);
+            const alphaEuler = new ValueObjects_1.Vector3(0, alphaRadians, 0);
+            const betaRadians = Utilities_1.degreesToRadians(beta);
+            const betaEuler = new ValueObjects_1.Vector3(betaRadians, 0, 0);
+            const cameraLocalPosition = new ValueObjects_1.Vector3(0, 0, -radius);
+            this.view({
+                alphaEuler,
+                betaEuler,
+                cameraLocalPosition,
+                target,
+            });
+        };
+        this.orbitCam = orbitCamera;
+        this.view = view;
+        this.doUpdateView();
+        this.orbitCam.addObserver(this.doUpdateView);
+    }
+    dispose() {
+        this.orbitCam.removeObserver(this.doUpdateView);
+    }
+}
+exports.FocusCameraPM = FocusCameraPM;

package/lib/PresentationManagers/FocusCameraPosRotPM.d.ts

@@ -0,0 +1,13 @@
+import { FocusCamera } from "../Entities";
+import { Vector3 } from "../ValueObjects";
+export interface FocusCameraPosRotVM {
+    position: Vector3;
+    rotation: Vector3;
+}
+export declare class FocusCameraPosRotPM {
+    private focusCam;
+    private view;
+    dispose(): void;
+    private doUpdateView;
+    constructor(orbitCamera: FocusCamera, view: (vm: FocusCameraPosRotVM) => void);
+}

package/lib/PresentationManagers/FocusCameraPosRotPM.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FocusCameraPosRotPM = void 0;
+const Utilities_1 = require("../Utilities");
+const ValueObjects_1 = require("../ValueObjects");
+class FocusCameraPosRotPM {
+    constructor(orbitCamera, view) {
+        this.doUpdateView = () => {
+            const { alpha, beta } = this.focusCam;
+            const alphaRadians = Utilities_1.degreesToRadians(alpha);
+            const betaRadians = Utilities_1.degreesToRadians(beta);
+            const position = this.focusCam.cameraPosition;
+            const rotation = new ValueObjects_1.Vector3(betaRadians, alphaRadians, 0);
+            this.view({
+                position,
+                rotation,
+            });
+        };
+        this.focusCam = orbitCamera;
+        this.view = view;
+        this.doUpdateView();
+        this.focusCam.addObserver(this.doUpdateView);
+    }
+    dispose() {
+        this.focusCam.removeObserver(this.doUpdateView);
+    }
+}
+exports.FocusCameraPosRotPM = FocusCameraPosRotPM;

package/lib/PresentationManagers/FramedScreenContainerPM.d.ts

@@ -0,0 +1,18 @@
+import { FramedScreen } from "../Entities";
+export interface FramedContainerVM {
+    top: number;
+    left: number;
+    width: number;
+    height: number;
+    show: boolean;
+}
+export declare class FramedContainerPM {
+    private updateView;
+    private container?;
+    private lastVM?;
+    doUpdateView: () => void;
+    private vmHadChanged;
+    dispose: () => void;
+    constructor(containerID: string, framedScreen: FramedScreen, updateView: (vm: FramedContainerVM) => void);
+}
+export declare const defaultFramedContainerVM: FramedContainerVM;

package/lib/PresentationManagers/FramedScreenContainerPM.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultFramedContainerVM = exports.FramedContainerPM = void 0;
+class FramedContainerPM {
+    constructor(containerID, framedScreen, updateView) {
+        this.updateView = updateView;
+        this.doUpdateView = () => {
+            const vm = Object.assign({}, exports.defaultFramedContainerVM);
+            if (!this.container) {
+                this.updateView(vm);
+                return;
+            }
+            vm.height = this.container.size.y;
+            vm.width = this.container.size.x;
+            vm.top = this.container.position.y;
+            vm.left = this.container.position.x;
+            vm.show = this.container.show;
+            if (!this.vmHadChanged(vm))
+                return;
+            this.updateView(vm);
+            this.lastVM = vm;
+        };
+        this.vmHadChanged = (newVM) => {
+            if (this.lastVM === undefined)
+                return true;
+            if (this.lastVM.height === newVM.height &&
+                this.lastVM.width === newVM.width &&
+                this.lastVM.top === newVM.top &&
+                this.lastVM.left === newVM.left &&
+                this.lastVM.show === newVM.show) {
+                return false;
+            }
+            else {
+                return true;
+            }
+        };
+        this.dispose = () => {
+            var _a;
+            (_a = this.container) === null || _a === void 0 ? void 0 : _a.removeObserver(this.doUpdateView);
+        };
+        this.container = framedScreen.getContainerByID(containerID);
+        if (this.container) {
+            this.container.addObserver(this.doUpdateView);
+        }
+        this.doUpdateView();
+    }
+}
+exports.FramedContainerPM = FramedContainerPM;
+exports.defaultFramedContainerVM = {
+    height: 0,
+    left: 0,
+    top: 0,
+    width: 0,
+    show: false
+};

package/lib/PresentationManagers/HasRedoPM.d.ts

@@ -0,0 +1,9 @@
+import { UndoRedo } from "../Entities";
+export declare class HasRedoPM {
+    updateView: (hasRedo: boolean) => void;
+    private undoRedo;
+    private lastValue?;
+    private onChange;
+    dispose(): void;
+    constructor(undoRedo: UndoRedo, updateView: (hasRedo: boolean) => void);
+}

package/lib/PresentationManagers/HasRedoPM.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HasRedoPM = void 0;
+class HasRedoPM {
+    constructor(undoRedo, updateView) {
+        this.updateView = updateView;
+        this.onChange = () => {
+            const currentVal = this.undoRedo.hasRedo;
+            if (this.lastValue === currentVal)
+                return;
+            this.updateView(currentVal);
+            this.lastValue = currentVal;
+        };
+        this.undoRedo = undoRedo;
+        this.onChange();
+        this.undoRedo.addObserver(this.onChange);
+    }
+    dispose() {
+        this.undoRedo.removeObserver(this.onChange);
+    }
+}
+exports.HasRedoPM = HasRedoPM;

package/lib/PresentationManagers/HasUndoPM.d.ts

@@ -0,0 +1,9 @@
+import { UndoRedo } from "../Entities";
+export declare class HasUndoPM {
+    updateView: (hasUndo: boolean) => void;
+    private undoRedo;
+    private lastValue?;
+    private onChange;
+    dispose(): void;
+    constructor(undoRedo: UndoRedo, updateView: (hasUndo: boolean) => void);
+}

package/lib/PresentationManagers/HasUndoPM.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HasUndoPM = void 0;
+class HasUndoPM {
+    constructor(undoRedo, updateView) {
+        this.updateView = updateView;
+        this.onChange = () => {
+            const currentVal = this.undoRedo.hasUndo;
+            if (this.lastValue === currentVal)
+                return;
+            this.updateView(currentVal);
+            this.lastValue = currentVal;
+        };
+        this.undoRedo = undoRedo;
+        this.onChange();
+        this.undoRedo.addObserver(this.onChange);
+    }
+    dispose() {
+        this.undoRedo.removeObserver(this.onChange);
+    }
+}
+exports.HasUndoPM = HasUndoPM;

package/lib/PresentationManagers/HoverLabels/AllowHoverLabelPM.d.ts

@@ -0,0 +1,9 @@
+import { HoverLabels } from "../../Entities";
+import { PresentionManager } from "../PresentationManager";
+export declare class AllowHoverLabelPM extends PresentionManager {
+    private hoverLabel;
+    private updateView;
+    private lastState?;
+    doUpdateView: () => void;
+    constructor(hoverLabel: HoverLabels, updateView: (allow: boolean) => void);
+}

package/lib/PresentationManagers/HoverLabels/AllowHoverLabelPM.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AllowHoverLabelPM = void 0;
+const PresentationManager_1 = require("../PresentationManager");
+class AllowHoverLabelPM extends PresentationManager_1.PresentionManager {
+    constructor(hoverLabel, updateView) {
+        super(hoverLabel);
+        this.hoverLabel = hoverLabel;
+        this.updateView = updateView;
+        this.doUpdateView = () => {
+            if (this.lastState === this.hoverLabel.allowHoverLabels)
+                return;
+            this.updateView(this.hoverLabel.allowHoverLabels);
+            this.lastState = this.hoverLabel.allowHoverLabels;
+        };
+        this.doUpdateView();
+    }
+}
+exports.AllowHoverLabelPM = AllowHoverLabelPM;

package/lib/PresentationManagers/HoverLabels/HoverLabelPM.d.ts

@@ -0,0 +1,17 @@
+import { HoverLabels } from "../../Entities";
+import { PresentionManager } from "../PresentationManager";
+export interface HoverLabelVM {
+    show: boolean;
+    text: string;
+    position: {
+        x: number;
+        y: number;
+    };
+}
+export declare class HoverLabelPM extends PresentionManager {
+    private hoverLabel;
+    private updateView;
+    doUpdateView: () => void;
+    constructor(hoverLabel: HoverLabels, updateView: (vm: HoverLabelVM) => void);
+    static defaultHoverLabelVM: HoverLabelVM;
+}

package/lib/PresentationManagers/HoverLabels/HoverLabelPM.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HoverLabelPM = void 0;
+const PresentationManager_1 = require("../PresentationManager");
+class HoverLabelPM extends PresentationManager_1.PresentionManager {
+    constructor(hoverLabel, updateView) {
+        super(hoverLabel);
+        this.hoverLabel = hoverLabel;
+        this.updateView = updateView;
+        this.doUpdateView = () => {
+            const vm = {
+                show: false,
+                text: "",
+                position: { x: 0, y: 0 },
+            };
+            if (this.hoverLabel.show) {
+                vm.show = true;
+                vm.text = this.hoverLabel.label;
+                vm.position.x = this.hoverLabel.position.x;
+                vm.position.y = this.hoverLabel.position.y;
+            }
+            this.updateView(vm);
+        };
+        this.doUpdateView();
+    }
+}
+exports.HoverLabelPM = HoverLabelPM;
+HoverLabelPM.defaultHoverLabelVM = {
+    show: false,
+    text: "",
+    position: { x: 0, y: 0 },
+};

package/lib/PresentationManagers/HoverLabels/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./HoverLabelPM";
+export * from "./AllowHoverLabelPM";

package/lib/PresentationManagers/HoverLabels/index.js

@@ -0,0 +1,14 @@
+"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("./HoverLabelPM"), exports);
+__exportStar(require("./AllowHoverLabelPM"), exports);

package/lib/PresentationManagers/IsAuthoringPM.d.ts

@@ -0,0 +1,9 @@
+import { BaseApp } from "../Entities";
+import { PresentionManager } from "./PresentationManager";
+export declare class IsAuthoringPM extends PresentionManager {
+    private baseApp;
+    private updateView;
+    private lastSetState?;
+    doUpdateView: () => void;
+    constructor(baseApp: BaseApp, updateView: (isAuthoring: boolean) => void);
+}

package/lib/PresentationManagers/IsAuthoringPM.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IsAuthoringPM = void 0;
+const PresentationManager_1 = require("./PresentationManager");
+class IsAuthoringPM extends PresentationManager_1.PresentionManager {
+    constructor(baseApp, updateView) {
+        super(baseApp);
+        this.baseApp = baseApp;
+        this.updateView = updateView;
+        this.doUpdateView = () => {
+            const isAuthoring = this.baseApp.isAuthoring;
+            if (isAuthoring === this.lastSetState)
+                return;
+            this.updateView(isAuthoring);
+            this.lastSetState = isAuthoring;
+        };
+        this.doUpdateView();
+    }
+}
+exports.IsAuthoringPM = IsAuthoringPM;

package/lib/PresentationManagers/PresentationManager.d.ts

@@ -0,0 +1,8 @@
+import { EntityObserver, ObservableEntity } from "../Entities";
+export declare abstract class PresentionManager {
+    private observableEntity;
+    abstract doUpdateView: EntityObserver;
+    private internalDoUodateView;
+    dispose: () => void;
+    constructor(observableEntity: ObservableEntity);
+}

package/lib/PresentationManagers/PresentationManager.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PresentionManager = void 0;
+class PresentionManager {
+    constructor(observableEntity) {
+        this.observableEntity = observableEntity;
+        this.internalDoUodateView = () => {
+            this.doUpdateView();
+        };
+        this.dispose = () => {
+            this.observableEntity.removeObserver(this.internalDoUodateView);
+        };
+        observableEntity.addObserver(this.internalDoUodateView);
+    }
+}
+exports.PresentionManager = PresentionManager;