@vived/app 4.1.0 → 4.3.0

package/lib/Entities/SceneModelRepo.d.ts

@@ -0,0 +1,11 @@
+import { ObservableEntityRepo } from "./ObservableEntityRepo";
+import { SceneModel, SceneModelDTO } from "./SceneModel";
+export declare abstract class SceneModelRepo extends ObservableEntityRepo<SceneModel> {
+    abstract get activeModel(): SceneModel | undefined;
+    abstract activeModelID: string;
+    abstract isLoadingSceneModel: boolean;
+    abstract modelLoader(modelID: string): Promise<void>;
+    abstract dataLoader(dataID: string): Promise<SceneModelDTO>;
+    abstract clearActiveModel(): void;
+}
+export declare function makeSceneModelRepo(): SceneModelRepo;

package/lib/Entities/SceneModelRepo.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeSceneModelRepo = exports.SceneModelRepo = void 0;
+const MemoizedBoolean_1 = require("./Memoized/MemoizedBoolean");
+const MemoizedString_1 = require("./Memoized/MemoizedString");
+const ObservableEntityRepo_1 = require("./ObservableEntityRepo");
+class SceneModelRepo extends ObservableEntityRepo_1.ObservableEntityRepo {
+}
+exports.SceneModelRepo = SceneModelRepo;
+function makeSceneModelRepo() {
+    return new SceneModelRepoImp();
+}
+exports.makeSceneModelRepo = makeSceneModelRepo;
+class SceneModelRepoImp extends SceneModelRepo {
+    constructor() {
+        super(...arguments);
+        this.memoizedActiveModelID = new MemoizedString_1.MemoizedString("", this.notify);
+        this.memoizedIsLoading = new MemoizedBoolean_1.MemoizedBoolean(false, this.notify);
+    }
+    modelLoader( /*modelID: string*/) {
+        return Promise.reject(new Error(`SceneModelRepo function modelLoader has not been injected`));
+    }
+    dataLoader( /*dataID: string*/) {
+        return Promise.reject(new Error(`SceneModelRepo function dataLoader has not been injected`));
+    }
+    get activeModelID() {
+        return this.memoizedActiveModelID.val;
+    }
+    set activeModelID(id) {
+        if (!this.has(id)) {
+            console.warn("[SceneModelRepo] Unknown Model ID ", id);
+            return;
+        }
+        this.memoizedActiveModelID.val = id;
+    }
+    get isLoadingSceneModel() {
+        return this.memoizedIsLoading.val;
+    }
+    set isLoadingSceneModel(val) {
+        this.memoizedIsLoading.val = val;
+    }
+    clearActiveModel() {
+        this.memoizedActiveModelID.val = "";
+    }
+    get activeModel() {
+        return this.get(this.memoizedActiveModelID.val);
+    }
+}

package/lib/Entities/SceneObject.d.ts

@@ -0,0 +1,23 @@
+import { ObservableEntity } from "./ObservableEntity";
+import { TransformNode } from "./TransformNode";
+export declare abstract class SceneObject extends ObservableEntity {
+    abstract readonly id: string;
+    abstract get shown(): boolean;
+    abstract set shown(shown: boolean);
+    abstract get enabled(): boolean;
+    abstract set enabled(enabled: boolean);
+    abstract get selected(): boolean;
+    abstract set selected(selected: boolean);
+    abstract get hovered(): boolean;
+    abstract set hovered(hovered: boolean);
+    abstract get pressed(): boolean;
+    abstract set pressed(pressed: boolean);
+    abstract get defaultLabel(): string;
+    abstract set defaultLabel(defaultLabel: string);
+    abstract get customLabel(): string;
+    abstract set customLabel(customLabel: string);
+    abstract get validationMessage(): string | null;
+    abstract transform: TransformNode;
+    abstract sceneTransform: unknown;
+}
+export declare function makeSceneObject(id: string): SceneObject;

package/lib/Entities/SceneObject.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeSceneObject = exports.SceneObject = void 0;
+const MemoizedBoolean_1 = require("./Memoized/MemoizedBoolean");
+const MemoizedString_1 = require("./Memoized/MemoizedString");
+const ObservableEntity_1 = require("./ObservableEntity");
+const TransformNode_1 = require("./TransformNode");
+class SceneObject extends ObservableEntity_1.ObservableEntity {
+}
+exports.SceneObject = SceneObject;
+function makeSceneObject(id) {
+    return new SceneObjectImp(id);
+}
+exports.makeSceneObject = makeSceneObject;
+class SceneObjectImp extends SceneObject {
+    constructor(id) {
+        super();
+        this.memoizedDefaultLabel = new MemoizedString_1.MemoizedString("", this.notify);
+        this.memoizedCustomLabel = new MemoizedString_1.MemoizedString("", this.notify);
+        this.memoizedShown = new MemoizedBoolean_1.MemoizedBoolean(true, this.notify);
+        this.memoizedEnabled = new MemoizedBoolean_1.MemoizedBoolean(true, this.notify);
+        this.memoizedSelected = new MemoizedBoolean_1.MemoizedBoolean(false, this.notify);
+        this.memoizedHovered = new MemoizedBoolean_1.MemoizedBoolean(false, this.notify);
+        this.memoizedPressed = new MemoizedBoolean_1.MemoizedBoolean(false, this.notify);
+        this.transform = TransformNode_1.makeTransformNode();
+        this.id = id;
+        this.transform.addObserver(this.notify);
+    }
+    get defaultLabel() {
+        return this.memoizedDefaultLabel.val;
+    }
+    set defaultLabel(defaultLabel) {
+        this.memoizedDefaultLabel.val = defaultLabel;
+    }
+    get customLabel() {
+        return this.memoizedCustomLabel.val;
+    }
+    set customLabel(customLabel) {
+        this.memoizedCustomLabel.val = customLabel;
+    }
+    get validationMessage() {
+        if (this.customLabel.length > 40) {
+            return "Object labels are limited to 40 characters";
+        }
+        else {
+            return null;
+        }
+    }
+    get shown() {
+        return this.memoizedShown.val;
+    }
+    set shown(shown) {
+        this.memoizedShown.val = shown;
+    }
+    get enabled() {
+        return this.memoizedEnabled.val;
+    }
+    set enabled(enabled) {
+        this.memoizedEnabled.val = enabled;
+    }
+    get selected() {
+        return this.memoizedSelected.val;
+    }
+    set selected(selected) {
+        this.memoizedSelected.val = selected;
+    }
+    get hovered() {
+        return this.memoizedHovered.val;
+    }
+    set hovered(hovered) {
+        this.memoizedHovered.val = hovered;
+    }
+    get pressed() {
+        return this.memoizedPressed.val;
+    }
+    set pressed(pressed) {
+        this.memoizedPressed.val = pressed;
+    }
+}

package/lib/Entities/SceneObjectsRepo.d.ts

@@ -0,0 +1,12 @@
+import { ObservableEntityRepo } from "./ObservableEntityRepo";
+import { SceneObject } from "./SceneObject";
+export declare abstract class SceneObjectsRepo extends ObservableEntityRepo<SceneObject> {
+    abstract get pressedSceneObject(): string | null;
+    abstract set pressedSceneObject(sceneObjectId: string | null);
+    abstract get hoveredSceneObject(): string | null;
+    abstract set hoveredSceneObject(sceneObjectId: string | null);
+    abstract unselectAllSceneObjects: () => void;
+    abstract getSelectedSceneObjects: () => SceneObject[];
+    abstract selectSceneObject: (id: string) => void;
+}
+export declare function makeSceneObjectRepo(): SceneObjectsRepo;

package/lib/Entities/SceneObjectsRepo.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeSceneObjectRepo = exports.SceneObjectsRepo = void 0;
+const ObservableEntityRepo_1 = require("./ObservableEntityRepo");
+class SceneObjectsRepo extends ObservableEntityRepo_1.ObservableEntityRepo {
+}
+exports.SceneObjectsRepo = SceneObjectsRepo;
+function makeSceneObjectRepo() {
+    return new SceneObjectsRepoImp();
+}
+exports.makeSceneObjectRepo = makeSceneObjectRepo;
+class SceneObjectsRepoImp extends SceneObjectsRepo {
+    constructor() {
+        super(...arguments);
+        this._pressedSceneObject = null;
+        this._hoveredSceneObject = null;
+        this.unselectAllSceneObjects = () => {
+            this.getAll().forEach(sceneObject => {
+                sceneObject.selected = false;
+            });
+        };
+        this.getSelectedSceneObjects = () => {
+            const selectedObjects = [];
+            this.getAll().forEach(sceneObject => {
+                if (sceneObject.selected) {
+                    selectedObjects.push(sceneObject);
+                }
+            });
+            return selectedObjects;
+        };
+        this.selectSceneObject = (id) => {
+            const sceneObject = this.get(id);
+            if (sceneObject) {
+                sceneObject.selected = true;
+            }
+        };
+    }
+    get pressedSceneObject() {
+        return this._pressedSceneObject;
+    }
+    set pressedSceneObject(sceneObjectId) {
+        if (sceneObjectId === this._pressedSceneObject) {
+            return;
+        }
+        this._pressedSceneObject = sceneObjectId;
+        this.notify();
+    }
+    get hoveredSceneObject() {
+        return this._hoveredSceneObject;
+    }
+    set hoveredSceneObject(sceneObjectId) {
+        if (sceneObjectId === this._hoveredSceneObject) {
+            return;
+        }
+        this._hoveredSceneObject = sceneObjectId;
+        this.notify();
+    }
+}

package/lib/Entities/SceneRoot.d.ts

@@ -0,0 +1,29 @@
+import { Quaternion, Vector3 } from "../ValueObjects";
+import { ObservableEntity } from "./ObservableEntity";
+import { SceneObject } from "./SceneObject";
+import { EaseFn } from "./TransformNode";
+export declare const SCENE_ROOT_ID = "scene-root";
+export interface DefaultSceneRootData {
+    position: [number, number, number];
+    rotation: [number, number, number, number];
+    scale: number;
+    minScale: number;
+    maxScale: number;
+}
+export declare abstract class SceneRoot extends ObservableEntity {
+    abstract defaultPosition: Vector3;
+    abstract defaultRoation: Quaternion;
+    abstract defaultScale: number;
+    abstract minScale: number;
+    abstract maxScale: number;
+    abstract id: string;
+    abstract sceneObject: SceneObject | undefined;
+    abstract position: Vector3;
+    abstract rotation: Quaternion;
+    abstract scale: number;
+    abstract applyDefaultData: (data: DefaultSceneRootData) => void;
+    abstract centerOnPoint: (point: Vector3, durationMS: number, easeFn: EaseFn, onCompleted?: () => void) => void;
+    abstract lerpToDefault: (durationMS: number, easeFn: EaseFn, onCompleted?: () => void) => void;
+    abstract bumpScaleAboutPoint: (amount: number, worldPoint: Vector3) => void;
+}
+export declare function makeSceneRoot(): SceneRoot;

package/lib/Entities/SceneRoot.js

@@ -0,0 +1,145 @@
+"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

@@ -0,0 +1,29 @@
+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

@@ -0,0 +1,98 @@
+"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

@@ -0,0 +1,81 @@
+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>;