@vived/app 4.27.1 → 4.28.1

package/lib/Entities/SceneRoot.js

@@ -1,145 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeSceneRoot = exports.SceneRoot = exports.SCENE_ROOT_ID = void 0;
-const ValueObjects_1 = require("../ValueObjects");
-const ObservableEntity_1 = require("./ObservableEntity");
-exports.SCENE_ROOT_ID = "scene-root";
-class SceneRoot extends ObservableEntity_1.ObservableEntity {
-}
-exports.SceneRoot = SceneRoot;
-function makeSceneRoot() {
-    return new SceneRootImp();
-}
-exports.makeSceneRoot = makeSceneRoot;
-class SceneRootImp extends SceneRoot {
-    constructor() {
-        super(...arguments);
-        this._defaultPosition = ValueObjects_1.Vector3.Zero();
-        this._defaultRoation = ValueObjects_1.Quaternion.Identity();
-        this._defaultScale = 1;
-        this._minScale = 0.01;
-        this._maxScale = 10;
-        this.applyDefaultData = (data) => {
-            this._defaultPosition = ValueObjects_1.Vector3.FromArray(data.position);
-            this._defaultRoation = ValueObjects_1.Quaternion.FromArray(data.rotation);
-            this._defaultScale = data.scale;
-            this._maxScale = data.maxScale;
-            this._minScale = data.minScale;
-        };
-        this.centerOnPoint = (point, durationMS, easeFn, onCompleted) => {
-            if (!this.sceneObject) {
-                console.warn("SceneRoot does not have a scene object");
-                return;
-            }
-            const finalPosition = ValueObjects_1.Vector3.Subtract(this.sceneObject.transform.worldPosition, point);
-            this.sceneObject.transform.lerp(durationMS, easeFn, finalPosition, undefined, undefined, onCompleted);
-        };
-        this.bumpScaleAboutPoint = (amount, worldPoint) => {
-            if (!this.sceneObject) {
-                console.warn("SceneRoot does not have a scene object");
-                return;
-            }
-            const localPickOffset = this.sceneObject.transform.worldPointToLocal(worldPoint);
-            const currentScale = this.sceneObject.transform.worldScale.x;
-            let newScale = currentScale + amount;
-            if (newScale < this.minScale) {
-                newScale = this.minScale;
-            }
-            else if (newScale > this.maxScale) {
-                newScale = this.maxScale;
-            }
-            this.sceneObject.transform.worldScale = new ValueObjects_1.Vector3(newScale, newScale, newScale);
-            const worldPickOffset = this.sceneObject.transform.localPointToWorld(localPickOffset);
-            const bump = ValueObjects_1.Vector3.Subtract(worldPoint, worldPickOffset);
-            this.sceneObject.transform.worldPosition = ValueObjects_1.Vector3.Add(bump, this.sceneObject.transform.worldPosition);
-        };
-        this.lerpToDefault = (durationMS, easeFn, onCompleted) => {
-            if (!this.sceneObject) {
-                console.warn("SceneRoot does not have a scene object");
-                return;
-            }
-            this.sceneObject.transform.lerp(durationMS, easeFn, this.defaultPosition, this.defaultRoation, new ValueObjects_1.Vector3(this.defaultScale, this.defaultScale, this.defaultScale), onCompleted);
-        };
-    }
-    get position() {
-        if (this.sceneObject) {
-            return this.sceneObject.transform.localPosition;
-        }
-        else {
-            console.warn("SceneRoot does not have a scene object");
-            return ValueObjects_1.Vector3.Zero();
-        }
-    }
-    set position(p) {
-        if (this.sceneObject) {
-            this.sceneObject.transform.localPosition = p;
-        }
-        else {
-            console.warn("SceneRoot does not have a scene object");
-        }
-    }
-    get rotation() {
-        if (this.sceneObject) {
-            return this.sceneObject.transform.localRotation;
-        }
-        else {
-            console.warn("SceneRoot does not have a scene object");
-            return ValueObjects_1.Quaternion.Identity();
-        }
-    }
-    set rotation(r) {
-        if (this.sceneObject) {
-            this.sceneObject.transform.localRotation = r;
-        }
-        else {
-            console.warn("SceneRoot does not have a scene object");
-        }
-    }
-    get scale() {
-        if (this.sceneObject) {
-            return this.sceneObject.transform.localScale.x;
-        }
-        else {
-            console.warn("SceneRoot does not have a scene object");
-            return 1;
-        }
-    }
-    set scale(s) {
-        if (this.sceneObject) {
-            this.sceneObject.transform.localScale = new ValueObjects_1.Vector3(s, s, s);
-        }
-        else {
-            console.warn("SceneRoot does not have a scene object");
-        }
-    }
-    get sceneObject() {
-        return this._sceneObject;
-    }
-    set sceneObject(so) {
-        if (this._sceneObject) {
-            this._sceneObject.removeObserver(this.notify);
-        }
-        this._sceneObject = so;
-        if (this._sceneObject) {
-            this._sceneObject.addObserver(this.notify);
-        }
-    }
-    get defaultPosition() {
-        return this._defaultPosition;
-    }
-    get defaultRoation() {
-        return this._defaultRoation;
-    }
-    get defaultScale() {
-        return this._defaultScale;
-    }
-    get minScale() {
-        return this._minScale;
-    }
-    get maxScale() {
-        return this._maxScale;
-    }
-    get id() {
-        return exports.SCENE_ROOT_ID;
-    }
-}

package/lib/Entities/StateMachine.d.ts

@@ -1,29 +0,0 @@
-import { Result } from "../ValueObjects";
-export declare type OnStateHasBeenApplied = () => void;
-export interface SerializedStates {
-    version: number;
-    systems: SystemState[];
-}
-export interface SystemState {
-    name: string;
-    seriliziationVersion: number;
-    state: object;
-}
-export interface SerializedSystem {
-    name: string;
-    seriliziationVersion: number;
-    getSystemState(): object;
-    applySystemState(state: object, version: number, transitionDuration: number): void;
-    applyDefaultState(transitionDuration: number): void;
-}
-export interface StateMachine {
-    transitionEaseFunction: (normalizedTime: number) => number;
-    getSerializedStates(): SerializedStates;
-    setSerializedStates(state: SerializedStates, transitionTime: number): Result<null, Error>;
-    applySerializedStatesString: (state: string, duration?: number) => void;
-    setDefaultState(transitionTime: number): void;
-    registerSerializedSystem(serializedSystem: SerializedSystem): Result<null, Error>;
-    addStateHasBeenAppliedObserver: (observer: OnStateHasBeenApplied) => void;
-    removeStateHasBeenAppliedObserver: (observer: OnStateHasBeenApplied) => void;
-}
-export declare function makeStateMachine(): StateMachine;

package/lib/Entities/StateMachine.js

@@ -1,98 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeStateMachine = void 0;
-const ValueObjects_1 = require("../ValueObjects");
-const ObserverList_1 = require("./ObserverList");
-function makeStateMachine() {
-    return new StateMachineImp();
-}
-exports.makeStateMachine = makeStateMachine;
-class StateMachineImp {
-    constructor() {
-        this.serializedSystems = new Map();
-        this.serilizationVersion = 2;
-        this.stateAppliedObservers = new ObserverList_1.ObserverList();
-        this.transitionEaseFunction = (normalizedTime) => {
-            return normalizedTime; // default to a linear function
-        };
-        this.applySerializedStatesString = (state, duration = 0) => {
-            if (state === "") {
-                this.setDefaultState(duration);
-            }
-            else {
-                try {
-                    const stateObj = JSON.parse(state);
-                    this.setSerializedStates(stateObj, duration);
-                }
-                catch (e) {
-                    this.setDefaultState(duration);
-                    console.warn("[StateMachine] Failed to deserialize state string: " + e);
-                }
-            }
-        };
-        this.registerSerializedSystem = (serializedSystem) => {
-            if (this.serializedSystems.has(serializedSystem.name)) {
-                const err = new Error(`[StateMachine] Duplicate stateable systems encountered: ${serializedSystem.name}`);
-                console.error(err.message);
-                return ValueObjects_1.reject(err);
-            }
-            this.serializedSystems.set(serializedSystem.name, serializedSystem);
-            return ValueObjects_1.resolve(null);
-        };
-        this.getSerializedStates = () => {
-            const systems = Array.from(this.serializedSystems.values());
-            const serializedStates = systems.map((system) => {
-                const state = system.getSystemState();
-                return {
-                    seriliziationVersion: system.seriliziationVersion,
-                    name: system.name,
-                    state,
-                };
-            });
-            return {
-                version: this.serilizationVersion,
-                systems: serializedStates,
-            };
-        };
-        this.setSerializedStates = (state, duration) => {
-            if (state.version === 2) {
-                const appliedToSystems = [];
-                state.systems.forEach((systemState) => {
-                    const seriliazableSystem = this.serializedSystems.get(systemState.name);
-                    if (seriliazableSystem) {
-                        seriliazableSystem.applySystemState(systemState.state, systemState.seriliziationVersion, duration);
-                    }
-                    else {
-                        console.warn("Unable to find seriarializedSystem " + systemState.name);
-                    }
-                    appliedToSystems.push(systemState.name);
-                });
-                this.serializedSystems.forEach((system) => {
-                    if (!appliedToSystems.includes(system.name)) {
-                        system.applyDefaultState(duration);
-                    }
-                });
-                this.stateAppliedObservers.notify();
-                return ValueObjects_1.resolve(null);
-            }
-            // Here is where we will add support for future versions
-            else {
-                const err = new Error(`[StateMachine] Unsupported sereialized state encountered: ${state.version}`);
-                console.error(err.message);
-                return ValueObjects_1.reject(err);
-            }
-        };
-        this.setDefaultState = (duration) => {
-            this.serializedSystems.forEach((system) => {
-                system.applyDefaultState(duration);
-            });
-            this.stateAppliedObservers.notify();
-        };
-        this.addStateHasBeenAppliedObserver = (observer) => {
-            this.stateAppliedObservers.add(observer);
-        };
-        this.removeStateHasBeenAppliedObserver = (observer) => {
-            this.stateAppliedObservers.remove(observer);
-        };
-    }
-}

package/lib/Entities/Tool.d.ts

@@ -1,81 +0,0 @@
-import { ObservableEntity } from "./ObservableEntity";
-export declare enum ToolState {
-    HIDDEN = "HIDDEN",
-    DISABLED = "DISABLED",
-    ENABLED = "ENABLED",
-    ACTIVE = "ACTIVE"
-}
-export interface ToolData<ToolTypes> {
-    type: ToolTypes;
-    isDefault: boolean;
-    label: string;
-    shortcutLabel: string;
-    hotkeys: HotKey[];
-}
-export interface HotKey {
-    keyCode: string;
-    control?: boolean;
-    shift?: boolean;
-    meta?: boolean;
-    alt?: boolean;
-}
-export declare abstract class Tool<ToolTypes> extends ObservableEntity {
-    /**
-     * The tool's type
-     */
-    abstract readonly type: ToolTypes;
-    /**
-     * Gets label for this tool. This will be human readable
-     */
-    abstract get label(): string;
-    /**
-     * Sets label for this tool. This should be human readable. A change will notify
-     */
-    abstract set label(toolLabel: string);
-    /**
-     * Is this the default tool? The default tool is what is initiall set Active and
-     * is what will be set active if the currently active tool is hidden or disabled.
-     */
-    abstract readonly isDefault: boolean;
-    /**
-     * Gets the keyboard shorcut label. This will be displayed to the user via the tool tip
-     * Example 'z'
-     */
-    abstract get shortcutLabel(): string;
-    /**
-     * Sets the keyboard shorcut label. This will be displayed to the user via the tool tip
-     * Example 'z'. This will notify when changed
-     */
-    abstract set shortcutLabel(shorcut: string);
-    /**
-     * Get the current tool state
-     */
-    abstract get state(): ToolState;
-    /**
-     * Sets the current tool state. This will notify on change
-     */
-    abstract set state(val: ToolState);
-    /**
-     * The keyboard shortcuts for this tool
-     */
-    abstract readonly hotkeys: HotKey[];
-    /**
-     * Is this tool an action tool. In other words do you just click it and something should happen
-     */
-    abstract get isAction(): boolean;
-    /**
-     * If this is an action tool calling this will trigger any actions that have been registered
-     */
-    abstract triggerActions(): void;
-    /**
-     * Registers an action with this tool. This action will be called when this tool is triggered
-     * @param action The action to call when this tool is triggered
-     */
-    abstract registerAction(action: () => void): void;
-    /**
-     * Returns a true if the passed hotkey is in my hotkey list
-     * @param hotkey The Hotkey to chekc
-     */
-    abstract isMyHotkey(hotkey: HotKey): boolean;
-}
-export declare function makeTool<ToolTypes>(data: ToolData<ToolTypes>): Tool<ToolTypes>;

package/lib/Entities/Tool.js

@@ -1,94 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeTool = exports.Tool = exports.ToolState = void 0;
-const MemoizedString_1 = require("./Memoized/MemoizedString");
-const ObservableEntity_1 = require("./ObservableEntity");
-var ToolState;
-(function (ToolState) {
-    ToolState["HIDDEN"] = "HIDDEN";
-    ToolState["DISABLED"] = "DISABLED";
-    ToolState["ENABLED"] = "ENABLED";
-    ToolState["ACTIVE"] = "ACTIVE";
-})(ToolState = exports.ToolState || (exports.ToolState = {}));
-class Tool extends ObservableEntity_1.ObservableEntity {
-}
-exports.Tool = Tool;
-function makeTool(data) {
-    return new ToolImp(data);
-}
-exports.makeTool = makeTool;
-class ToolImp extends Tool {
-    constructor(data) {
-        super();
-        this.memoizedState = new MemoizedString_1.MemoizedString(ToolState.ENABLED, this.notify);
-        this.actions = [];
-        this._isAction = false;
-        this.registerAction = (action) => {
-            this.actions.push(action);
-            this._isAction = true;
-        };
-        this.triggerActions = () => {
-            this.actions.forEach((action) => {
-                action();
-            });
-        };
-        this.isMyHotkey = (hotkey) => {
-            let isMine = false;
-            this.hotkeys.forEach((myHotkey) => {
-                if (this.hotkeysMatch(myHotkey, hotkey)) {
-                    isMine = true;
-                }
-            });
-            return isMine;
-        };
-        this.type = data.type;
-        this.memoizedLabel = new MemoizedString_1.MemoizedString(data.label, this.notify);
-        this.isDefault = data.isDefault;
-        this.memoizedShortcut = new MemoizedString_1.MemoizedString(data.shortcutLabel, this.notify);
-        this.hotkeys = data.hotkeys;
-    }
-    get label() {
-        return this.memoizedLabel.val;
-    }
-    set label(toolLabel) {
-        this.memoizedLabel.val = toolLabel;
-    }
-    get shortcutLabel() {
-        return this.memoizedShortcut.val;
-    }
-    set shortcutLabel(shorcut) {
-        this.memoizedShortcut.val = shorcut;
-    }
-    get state() {
-        return this.memoizedState.val;
-    }
-    set state(val) {
-        this.memoizedState.val = val;
-    }
-    get isAction() {
-        return this._isAction;
-    }
-    hotkeysMatch(a, b) {
-        if (a.keyCode !== b.keyCode)
-            return false;
-        const aComplete = this.fillInMissingModifiers(a);
-        const bComplete = this.fillInMissingModifiers(b);
-        if (aComplete.alt !== bComplete.alt)
-            return false;
-        if (aComplete.control !== bComplete.control)
-            return false;
-        if (aComplete.meta !== bComplete.meta)
-            return false;
-        if (aComplete.shift !== bComplete.shift)
-            return false;
-        return true;
-    }
-    fillInMissingModifiers(hotkey) {
-        const rVal = Object.assign({}, hotkey);
-        rVal.alt = hotkey.alt === undefined ? false : hotkey.alt;
-        rVal.control = hotkey.control === undefined ? false : hotkey.control;
-        rVal.meta = hotkey.meta === undefined ? false : hotkey.meta;
-        rVal.shift = hotkey.shift === undefined ? false : hotkey.shift;
-        return rVal;
-    }
-}

package/lib/Entities/ToolRepository.d.ts

@@ -1,46 +0,0 @@
-import { ObservableEntity } from "./ObservableEntity";
-import { HotKey, Tool, ToolData } from "./Tool";
-export declare abstract class ToolRepository<ToolTypes> extends ObservableEntity {
-    /**
-     * Retuns the active tool. If no tool is active it will return undefined.
-     */
-    abstract get activeTool(): Tool<ToolTypes> | undefined;
-    /**
-     * Returns all the tools.
-     */
-    abstract get allTools(): Tool<ToolTypes>[];
-    /**
-     * Set up the tools from a JSON data file. This should be called during construction.
-     * It is assumed this is only called once.
-     * @param toolData
-     */
-    abstract setupToolsFromData(toolData: ToolData<ToolTypes>[]): void;
-    /**
-     * Get's a tool by it's type. Retruns undefined if no tool could be found
-     * @param toolType The tool type
-     */
-    abstract getTool(toolType: ToolTypes): Tool<ToolTypes> | undefined;
-    /**
-     * Returns the tool that has been assinged to a particular key code.
-     * Will return undefined of no tool is found
-     * @param hotkey Key Code
-     */
-    abstract getToolForHotkey(hotkey: HotKey): Tool<ToolTypes> | undefined;
-    /**
-     * Call this to set the default tool as active
-     */
-    abstract setDefaultToolActive(): void;
-    /**
-     * Triggers a tool of type
-     * @param toolType Tool's type
-     */
-    abstract triggerTool(toolType: ToolTypes): void;
-    /**
-     * Toggls a tool between Hidden and shown.
-     * If the tool is tool is currently Active, the default tool will be set active
-     * The Default Tool cannot be toggled
-     * @param toolType Tool's type
-     */
-    abstract toggleToolVisibility(toolType: ToolTypes): void;
-}
-export declare function makeToolRepo<ToolTypes>(): ToolRepository<ToolTypes>;

package/lib/Entities/ToolRepository.js

@@ -1,118 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeToolRepo = exports.ToolRepository = void 0;
-const ObservableEntity_1 = require("./ObservableEntity");
-const Tool_1 = require("./Tool");
-class ToolRepository extends ObservableEntity_1.ObservableEntity {
-}
-exports.ToolRepository = ToolRepository;
-function makeToolRepo() {
-    return new ToolRepositoryImp();
-}
-exports.makeToolRepo = makeToolRepo;
-class ToolRepositoryImp extends ToolRepository {
-    constructor() {
-        super(...arguments);
-        this.toolLookup = new Map();
-    }
-    get allTools() {
-        return Array.from(this.toolLookup.values());
-    }
-    setDefaultToolActive() {
-        if (this._defaultToolType !== undefined) {
-            this.triggerTool(this._defaultToolType);
-        }
-        else {
-            console.warn(`[ToolRepository] No default tools has been specified`);
-        }
-    }
-    setupToolsFromData(toolDatas) {
-        toolDatas.forEach((toolData) => {
-            const type = toolData.type;
-            if (this.toolLookup.has(type)) {
-                console.warn(`[ToolRepository] A tool with the ID ${toolData.type} already exists. Replacing`);
-            }
-            const tool = Tool_1.makeTool(toolData);
-            this.toolLookup.set(type, tool);
-            if (toolData.isDefault) {
-                if (this._defaultToolType) {
-                    console.warn(`[ToolRepository] More than one tools is marked as default. Replacing`);
-                }
-                this._defaultToolType = type;
-            }
-        });
-        if (!this._defaultToolType) {
-            console.warn(`[ToolRepository] No default tools was specified. Defaulting to the first tool in the list`);
-            this._defaultToolType = Array.from(this.toolLookup.keys())[0];
-        }
-        if (this._defaultToolType) {
-            this.triggerTool(this._defaultToolType);
-        }
-    }
-    getTool(type) {
-        return this.toolLookup.get(type);
-    }
-    getToolForHotkey(hotkey) {
-        let tool;
-        this.allTools.forEach((t) => {
-            if (t.isMyHotkey(hotkey)) {
-                tool = t;
-            }
-        });
-        return tool;
-    }
-    get activeTool() {
-        if (!this._activeToolType)
-            return undefined;
-        return this.getTool(this._activeToolType);
-    }
-    triggerTool(type) {
-        if (this._activeToolType === type)
-            return;
-        const newActiveTool = this.toolLookup.get(type);
-        if (!newActiveTool) {
-            console.warn(`[ToolRepository] Unable to find tool ${type}`);
-            return;
-        }
-        if (newActiveTool.isAction) {
-            newActiveTool.triggerActions();
-            return;
-        }
-        if (newActiveTool.state === Tool_1.ToolState.DISABLED) {
-            return;
-        }
-        if (newActiveTool.state === Tool_1.ToolState.HIDDEN) {
-            return;
-        }
-        this.toolLookup.forEach((tool) => {
-            if (tool.type === type) {
-                this._activeToolType = type;
-                tool.state = Tool_1.ToolState.ACTIVE;
-            }
-            else if (tool.state === Tool_1.ToolState.ACTIVE) {
-                tool.state = Tool_1.ToolState.ENABLED;
-            }
-        });
-        this.notify();
-    }
-    toggleToolVisibility(type) {
-        const tool = this.getTool(type);
-        if (!tool) {
-            console.warn(`[ToolRepository] Unable to find tool to toggle: ${type}`);
-            return;
-        }
-        if (tool.type === this._defaultToolType) {
-            console.warn(`[ToolRepository] The default tool's visibility cannot be toggled`);
-            return;
-        }
-        if (tool.state === Tool_1.ToolState.HIDDEN) {
-            tool.state = Tool_1.ToolState.ENABLED;
-        }
-        else {
-            if (tool.state === Tool_1.ToolState.ACTIVE) {
-                this.setDefaultToolActive();
-            }
-            tool.state = Tool_1.ToolState.HIDDEN;
-        }
-    }
-}

package/lib/Entities/TouchInput.d.ts

@@ -1,28 +0,0 @@
-import { Vector2 } from "../ValueObjects";
-export interface TouchInputEvent {
-    touchCount: number;
-    touchCenter: Vector2;
-    touches: TouchData[];
-    event: TouchEvent;
-}
-export interface TouchData {
-    id: number;
-    position: Vector2;
-    touch?: Touch;
-}
-export interface TouchController {
-    onTouchStart?: (e: TouchInputEvent) => void;
-    onTouchMove?: (e: TouchInputEvent) => void;
-    onTouchEnd?: (e: TouchInputEvent) => void;
-    onTouchCancel?: (e: TouchInputEvent) => void;
-}
-export interface TouchInput {
-    eventElement: HTMLElement | undefined;
-    eventElementBounds?: DOMRect;
-    setEventElement: (eventElement: HTMLElement) => void;
-    clearInputElement: () => void;
-    updateInputElementBounds: () => void;
-    registerController: (controller: TouchController) => void;
-    removeController: (controller: TouchController) => void;
-}
-export declare function makeTouchInput(): TouchInput;