@vived/app 2.48.1 → 2.50.0

package/lib/Entities/Babylon.js

@@ -2,8 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeBabylon = void 0;
 const ValueObjects_1 = require("../ValueObjects");
-const MemoizedBoolean_1 = require("./MemoizedBoolean");
-const MemoizedVector2_1 = require("./MemoizedVector2");
+const MemoizedBoolean_1 = require("./Memoized/MemoizedBoolean");
+const MemoizedVector2_1 = require("./Memoized/MemoizedVector2");
 const ObserverList_1 = require("./ObserverList");
 function makeBabylon() {
     return new BabylonImp();

package/lib/Entities/BaseApp.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeBaseApp = exports.BaseApp = void 0;
-const MemoizedBoolean_1 = require("./MemoizedBoolean");
+const MemoizedBoolean_1 = require("./Memoized/MemoizedBoolean");
 const ObservableEntity_1 = require("./ObservableEntity");
 class BaseApp extends ObservableEntity_1.ObservableEntity {
 }

package/lib/Entities/FramedScreen.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeFramedScreen = exports.FramedScreen = void 0;
 const FramedScreenContainer_1 = require("./FramedScreenContainer");
-const MemoizedNumber_1 = require("./MemoizedNumber");
+const MemoizedNumber_1 = require("./Memoized/MemoizedNumber");
 const ObservableEntity_1 = require("./ObservableEntity");
 class FramedScreen extends ObservableEntity_1.ObservableEntity {
 }

package/lib/Entities/FramedScreenContainer.js

@@ -2,8 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeFramedScreenContainer = exports.FramedScreenContainer = void 0;
 const ValueObjects_1 = require("../ValueObjects");
-const MemoizedBoolean_1 = require("./MemoizedBoolean");
-const MemoizedVector2_1 = require("./MemoizedVector2");
+const MemoizedBoolean_1 = require("./Memoized/MemoizedBoolean");
+const MemoizedVector2_1 = require("./Memoized/MemoizedVector2");
 const ObservableEntity_1 = require("./ObservableEntity");
 class FramedScreenContainer extends ObservableEntity_1.ObservableEntity {
 }

package/lib/Entities/HoverLabels.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeHoverLabels = exports.HoverLabels = void 0;
 const ValueObjects_1 = require("../ValueObjects");
-const MemoizedBoolean_1 = require("./MemoizedBoolean");
+const MemoizedBoolean_1 = require("./Memoized/MemoizedBoolean");
 const ObservableEntity_1 = require("./ObservableEntity");
 class HoverLabels extends ObservableEntity_1.ObservableEntity {
 }

package/lib/Entities/Memoized/MemoizedAngle.d.ts

@@ -0,0 +1,9 @@
+import { Angle } from "../../ValueObjects";
+export declare class MemoizedAngle {
+    private _val;
+    get val(): Angle;
+    set val(b: Angle);
+    setValQuietly(val: Angle): void;
+    private onChangeCallback;
+    constructor(initialValue: Angle, onChangeCallback: () => void);
+}

package/lib/Entities/Memoized/MemoizedAngle.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoizedAngle = void 0;
+class MemoizedAngle {
+    constructor(initialValue, onChangeCallback) {
+        this._val = initialValue;
+        this.onChangeCallback = onChangeCallback;
+    }
+    get val() {
+        return this._val;
+    }
+    set val(b) {
+        if (this._val.degrees === b.degrees)
+            return;
+        this._val = b;
+        this.onChangeCallback();
+    }
+    setValQuietly(val) {
+        this._val = val;
+    }
+}
+exports.MemoizedAngle = MemoizedAngle;

package/lib/Entities/Memoized/MemoizedBoolean.d.ts

@@ -0,0 +1,8 @@
+export declare class MemoizedBoolean {
+    private _val;
+    get val(): boolean;
+    set val(b: boolean);
+    setValQuietly(val: boolean): void;
+    private onChangeCallback;
+    constructor(initialValue: boolean, onChangeCallback: () => void);
+}

package/lib/Entities/Memoized/MemoizedBoolean.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoizedBoolean = void 0;
+class MemoizedBoolean {
+    constructor(initialValue, onChangeCallback) {
+        this._val = initialValue;
+        this.onChangeCallback = onChangeCallback;
+    }
+    get val() {
+        return this._val;
+    }
+    set val(b) {
+        if (this._val === b)
+            return;
+        this._val = b;
+        this.onChangeCallback();
+    }
+    setValQuietly(val) {
+        this._val = val;
+    }
+}
+exports.MemoizedBoolean = MemoizedBoolean;

package/lib/Entities/Memoized/MemoizedColor.d.ts

@@ -0,0 +1,9 @@
+import { Color } from "../../ValueObjects";
+export declare class MemoizedColor {
+    private _val;
+    get val(): Color;
+    set val(v: Color);
+    setValQuietly(val: Color): void;
+    private onChangeCallback;
+    constructor(initialValue: Color, onChangeCallback: () => void);
+}

package/lib/Entities/Memoized/MemoizedColor.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoizedColor = void 0;
+const ValueObjects_1 = require("../../ValueObjects");
+class MemoizedColor {
+    constructor(initialValue, onChangeCallback) {
+        this._val = initialValue;
+        this.onChangeCallback = onChangeCallback;
+    }
+    get val() {
+        return this._val;
+    }
+    set val(v) {
+        if (ValueObjects_1.Color.Equal(v, this._val))
+            return;
+        this._val = v;
+        this.onChangeCallback();
+    }
+    setValQuietly(val) {
+        this._val = val;
+    }
+}
+exports.MemoizedColor = MemoizedColor;

package/lib/Entities/Memoized/MemoizedNumber.d.ts

@@ -0,0 +1,8 @@
+export declare class MemoizedNumber {
+    private _val;
+    get val(): number;
+    set val(b: number);
+    setValQuietly(val: number): void;
+    private onChangeCallback;
+    constructor(initialValue: number, onChangeCallback: () => void);
+}

package/lib/Entities/Memoized/MemoizedNumber.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoizedNumber = void 0;
+class MemoizedNumber {
+    constructor(initialValue, onChangeCallback) {
+        this._val = initialValue;
+        this.onChangeCallback = onChangeCallback;
+    }
+    get val() {
+        return this._val;
+    }
+    set val(b) {
+        if (this._val === b)
+            return;
+        this._val = b;
+        this.onChangeCallback();
+    }
+    setValQuietly(val) {
+        this._val = val;
+    }
+}
+exports.MemoizedNumber = MemoizedNumber;

package/lib/Entities/Memoized/MemoizedQuaternion.d.ts

@@ -0,0 +1,9 @@
+import { Quaternion } from "../../ValueObjects";
+export declare class MemoizedQuaternion {
+    private _val;
+    get val(): Quaternion;
+    set val(v: Quaternion);
+    setValQuietly(val: Quaternion): void;
+    private onChangeCallback;
+    constructor(initialValue: Quaternion, onChangeCallback: () => void);
+}

package/lib/Entities/Memoized/MemoizedQuaternion.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoizedQuaternion = void 0;
+const ValueObjects_1 = require("../../ValueObjects");
+class MemoizedQuaternion {
+    constructor(initialValue, onChangeCallback) {
+        this._val = initialValue;
+        this.onChangeCallback = onChangeCallback;
+    }
+    get val() {
+        return this._val;
+    }
+    set val(v) {
+        if (ValueObjects_1.Quaternion.Equal(v, this._val))
+            return;
+        this._val = v;
+        this.onChangeCallback();
+    }
+    setValQuietly(val) {
+        this._val = val;
+    }
+}
+exports.MemoizedQuaternion = MemoizedQuaternion;

package/lib/Entities/Memoized/MemoizedString.d.ts

@@ -0,0 +1,8 @@
+export declare class MemoizedString {
+    private _val;
+    get val(): string;
+    set val(b: string);
+    setValQuietly(val: string): void;
+    private onChangeCallback;
+    constructor(initialValue: string, onChangeCallback: () => void);
+}

package/lib/Entities/Memoized/MemoizedString.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoizedString = void 0;
+class MemoizedString {
+    constructor(initialValue, onChangeCallback) {
+        this._val = initialValue;
+        this.onChangeCallback = onChangeCallback;
+    }
+    get val() {
+        return this._val;
+    }
+    set val(b) {
+        if (this._val === b)
+            return;
+        this._val = b;
+        this.onChangeCallback();
+    }
+    setValQuietly(val) {
+        this._val = val;
+    }
+}
+exports.MemoizedString = MemoizedString;

package/lib/Entities/Memoized/MemoizedVector2.d.ts

@@ -0,0 +1,9 @@
+import { Vector2 } from "../../ValueObjects";
+export declare class MemoizedVector2 {
+    private _val;
+    get val(): Vector2;
+    set val(v: Vector2);
+    setValQuietly(val: Vector2): void;
+    private onChangeCallback;
+    constructor(initialValue: Vector2, onChangeCallback: () => void);
+}

package/lib/Entities/Memoized/MemoizedVector2.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoizedVector2 = void 0;
+const ValueObjects_1 = require("../../ValueObjects");
+class MemoizedVector2 {
+    constructor(initialValue, onChangeCallback) {
+        this._val = initialValue;
+        this.onChangeCallback = onChangeCallback;
+    }
+    get val() {
+        return this._val;
+    }
+    set val(v) {
+        if (ValueObjects_1.Vector2.Equal(v, this._val))
+            return;
+        this._val = v;
+        this.onChangeCallback();
+    }
+    setValQuietly(val) {
+        this._val = val;
+    }
+}
+exports.MemoizedVector2 = MemoizedVector2;

package/lib/Entities/Memoized/MemoizedVector3.d.ts

@@ -0,0 +1,9 @@
+import { Vector3 } from "../../ValueObjects";
+export declare class MemoizedVector3 {
+    private _val;
+    get val(): Vector3;
+    set val(v: Vector3);
+    setValQuietly(val: Vector3): void;
+    private onChangeCallback;
+    constructor(initialValue: Vector3, onChangeCallback: () => void);
+}

package/lib/Entities/Memoized/MemoizedVector3.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoizedVector3 = void 0;
+const ValueObjects_1 = require("../../ValueObjects");
+class MemoizedVector3 {
+    constructor(initialValue, onChangeCallback) {
+        this._val = initialValue;
+        this.onChangeCallback = onChangeCallback;
+    }
+    get val() {
+        return this._val;
+    }
+    set val(v) {
+        if (ValueObjects_1.Vector3.Equal(v, this._val))
+            return;
+        this._val = v;
+        this.onChangeCallback();
+    }
+    setValQuietly(val) {
+        this._val = val;
+    }
+}
+exports.MemoizedVector3 = MemoizedVector3;

package/lib/Entities/MemoizedColor.d.ts

@@ -0,0 +1,9 @@
+import { Color } from "../ValueObjects";
+export declare class MemoizedColor {
+    private _val;
+    get val(): Color;
+    set val(v: Color);
+    setValQuietly(val: Color): void;
+    private onChangeCallback;
+    constructor(initialValue: Color, onChangeCallback: () => void);
+}

package/lib/Entities/MemoizedColor.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoizedColor = void 0;
+const ValueObjects_1 = require("../ValueObjects");
+class MemoizedColor {
+    constructor(initialValue, onChangeCallback) {
+        this._val = initialValue;
+        this.onChangeCallback = onChangeCallback;
+    }
+    get val() {
+        return this._val;
+    }
+    set val(v) {
+        if (ValueObjects_1.Color.Equal(v, this._val))
+            return;
+        this._val = v;
+        this.onChangeCallback();
+    }
+    setValQuietly(val) {
+        this._val = val;
+    }
+}
+exports.MemoizedColor = MemoizedColor;

package/lib/Entities/ModelMesh.d.ts

@@ -0,0 +1,53 @@
+import { Vector3 } from "../ValueObjects";
+import { ObservableEntity } from "./ObservableEntity";
+import { SceneObject } from "./SceneObject";
+export declare abstract class ModelMesh extends ObservableEntity {
+    abstract readonly id: string;
+    abstract label: string;
+    abstract position: Vector3;
+    abstract get canBeStuck(): boolean;
+    abstract stick(durationMS: number, easeFn: (val: number) => number, onStickComplete?: () => void): void;
+    abstract shown: boolean;
+    abstract meshPaths: string[];
+    abstract addMeshPath(path: string): void;
+    abstract hasMeshPath(path: string): boolean;
+    abstract removeMeshPath(path: string): void;
+    abstract toData(): ModelMeshDTO;
+    abstract applyData(data: ModelMeshDTO): void;
+    abstract readonly sceneObject: SceneObject;
+}
+export declare function makeModelMesh(dto: ModelMeshDTO, sceneObject: SceneObject): ModelMeshImp;
+declare class ModelMeshImp extends ModelMesh {
+    readonly id: string;
+    readonly sceneObject: SceneObject;
+    get label(): string;
+    set label(l: string);
+    get position(): Vector3;
+    set position(p: Vector3);
+    get shown(): boolean;
+    set shown(show: boolean);
+    get canBeStuck(): boolean;
+    stick: (durationMS: number, easeFn: (val: number) => number, onStickComplete?: (() => void) | undefined) => void;
+    private _meshPaths;
+    get meshPaths(): string[];
+    set meshPaths(paths: string[]);
+    addMeshPath: (path: string) => void;
+    hasMeshPath: (path: string) => boolean;
+    removeMeshPath: (path: string) => void;
+    toData: () => ModelMeshDTO;
+    applyData: (data: ModelMeshDTO) => void;
+    constructor(dto: ModelMeshDTO, sceneObject: SceneObject);
+}
+export declare type ModelMeshDTO = ModelMeshDTOv0 | ModelMeshDTOv1;
+export interface ModelMeshDTOv1 {
+    version: number;
+    id: string;
+    meshPaths: string[];
+    label: string;
+}
+export interface ModelMeshDTOv0 {
+    id: string;
+    meshPaths: string[];
+    label: string;
+}
+export {};

package/lib/Entities/ModelMesh.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeModelMesh = exports.ModelMesh = void 0;
+const ValueObjects_1 = require("../ValueObjects");
+const ObservableEntity_1 = require("./ObservableEntity");
+class ModelMesh extends ObservableEntity_1.ObservableEntity {
+}
+exports.ModelMesh = ModelMesh;
+function makeModelMesh(dto, sceneObject) {
+    return new ModelMeshImp(dto, sceneObject);
+}
+exports.makeModelMesh = makeModelMesh;
+class ModelMeshImp extends ModelMesh {
+    constructor(dto, sceneObject) {
+        super();
+        this.stick = (durationMS, easeFn, onStickComplete) => {
+            if (!this.canBeStuck) {
+                if (onStickComplete)
+                    onStickComplete();
+                return;
+            }
+            this.sceneObject.transform.lerp(durationMS, easeFn, ValueObjects_1.Vector3.Zero(), undefined, undefined, onStickComplete);
+        };
+        this._meshPaths = [];
+        this.addMeshPath = (path) => {
+            if (this._meshPaths.includes(path))
+                return;
+            this._meshPaths.push(path);
+            this.notify();
+        };
+        this.hasMeshPath = (path) => {
+            return this._meshPaths.includes(path);
+        };
+        this.removeMeshPath = (path) => {
+            const index = this._meshPaths.indexOf(path);
+            if (index >= 0) {
+                this._meshPaths.splice(index, 1);
+                this.notify();
+            }
+        };
+        this.toData = () => {
+            const dto = {
+                version: 1,
+                id: this.id,
+                label: this.sceneObject.name,
+                meshPaths: [...this._meshPaths],
+            };
+            return dto;
+        };
+        this.applyData = (data) => {
+            this.sceneObject.name = data.label;
+            this.meshPaths = data.meshPaths;
+        };
+        this.id = dto.id;
+        this.sceneObject = sceneObject;
+        this.sceneObject.name = dto.label;
+        this.sceneObject.addObserver(this.notify);
+        this._meshPaths = [...dto.meshPaths];
+    }
+    get label() {
+        return this.sceneObject.name;
+    }
+    set label(l) {
+        this.sceneObject.name = l;
+    }
+    get position() {
+        return this.sceneObject.position;
+    }
+    set position(p) {
+        this.sceneObject.position = p;
+    }
+    get shown() {
+        return this.sceneObject.shown;
+    }
+    set shown(show) {
+        this.sceneObject.shown = show;
+    }
+    get canBeStuck() {
+        if (ValueObjects_1.Vector3.Equal(this.sceneObject.position, ValueObjects_1.Vector3.Zero())) {
+            return false;
+        }
+        else {
+            return true;
+        }
+    }
+    get meshPaths() {
+        return [...this._meshPaths];
+    }
+    set meshPaths(paths) {
+        let pathsHaveChanged = false;
+        if (paths.length !== this._meshPaths.length) {
+            pathsHaveChanged = true;
+        }
+        else {
+            paths.forEach((path, i) => {
+                if (path !== this._meshPaths[i]) {
+                    pathsHaveChanged = true;
+                }
+            });
+        }
+        if (!pathsHaveChanged)
+            return;
+        this._meshPaths = paths;
+        this.notify();
+    }
+}

package/lib/Entities/SceneModel.js

@@ -2,10 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeSceneModel = exports.SceneModel = exports.SceneModelState = void 0;
 const ValueObjects_1 = require("../ValueObjects");
-const MemoizedNumber_1 = require("./MemoizedNumber");
-const MemoizedQuaternion_1 = require("./MemoizedQuaternion");
-const MemoizedString_1 = require("./MemoizedString");
-const MemoizedVector3_1 = require("./MemoizedVector3");
+const MemoizedNumber_1 = require("./Memoized/MemoizedNumber");
+const MemoizedQuaternion_1 = require("./Memoized/MemoizedQuaternion");
+const MemoizedString_1 = require("./Memoized/MemoizedString");
+const MemoizedVector3_1 = require("./Memoized/MemoizedVector3");
 const ObservableEntity_1 = require("./ObservableEntity");
 const SceneModelMesh_1 = require("./SceneModelMesh");
 var SceneModelState;

package/lib/Entities/SceneModelMesh.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeSceneModelMesh = exports.SceneModelMesh = void 0;
 const ValueObjects_1 = require("../ValueObjects");
-const MemoizedString_1 = require("./MemoizedString");
+const MemoizedString_1 = require("./Memoized/MemoizedString");
 const ObservableEntity_1 = require("./ObservableEntity");
 class SceneModelMesh extends ObservableEntity_1.ObservableEntity {
 }

package/lib/Entities/SceneModelObject.d.ts

@@ -0,0 +1,40 @@
+import { ObservableEntity } from "./ObservableEntity";
+export declare abstract class SceneModelObject extends ObservableEntity {
+    abstract readonly id: string;
+    abstract label: string;
+    abstract meshPaths: string[];
+    abstract addMeshPath(path: string): void;
+    abstract hasMeshPath(path: string): boolean;
+    abstract removeMeshPath(path: string): void;
+    abstract toData(): SceneModelObjectDTO;
+    abstract applyData(data: SceneModelObjectDTO): void;
+}
+export declare function makeSceneModelObject(dto: SceneModelObjectDTO): SceneObjectImp;
+declare class SceneObjectImp extends SceneModelObject {
+    readonly id: string;
+    private _label;
+    get label(): string;
+    set label(label: string);
+    private _meshPaths;
+    get meshPaths(): string[];
+    set meshPaths(paths: string[]);
+    addMeshPath: (path: string) => void;
+    hasMeshPath: (path: string) => boolean;
+    removeMeshPath: (path: string) => void;
+    toData: () => SceneModelObjectDTO;
+    applyData: (data: SceneModelObjectDTO) => void;
+    constructor(dto: SceneModelObjectDTO);
+}
+export declare type SceneModelObjectDTO = SceneModelObjectDTOv0 | SceneModelObjectDTOv1;
+export interface SceneModelObjectDTOv1 {
+    version: number;
+    id: string;
+    meshPaths: string[];
+    label: string;
+}
+export interface SceneModelObjectDTOv0 {
+    id: string;
+    meshPaths: string[];
+    label: string;
+}
+export {};

package/lib/Entities/SceneModelObject.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeSceneModelObject = exports.SceneModelObject = void 0;
+const MemoizedString_1 = require("./MemoizedString");
+const ObservableEntity_1 = require("./ObservableEntity");
+class SceneModelObject extends ObservableEntity_1.ObservableEntity {
+}
+exports.SceneModelObject = SceneModelObject;
+function makeSceneModelObject(dto) {
+    return new SceneObjectImp(dto);
+}
+exports.makeSceneModelObject = makeSceneModelObject;
+class SceneObjectImp extends SceneModelObject {
+    constructor(dto) {
+        super();
+        this._label = new MemoizedString_1.MemoizedString("", this.notify);
+        this._meshPaths = [];
+        this.addMeshPath = (path) => {
+            if (this._meshPaths.includes(path))
+                return;
+            this._meshPaths.push(path);
+            this.notify();
+        };
+        this.hasMeshPath = (path) => {
+            return this._meshPaths.includes(path);
+        };
+        this.removeMeshPath = (path) => {
+            const index = this._meshPaths.indexOf(path);
+            if (index >= 0) {
+                this._meshPaths.splice(index, 1);
+                this.notify();
+            }
+        };
+        this.toData = () => {
+            const dto = {
+                version: 1,
+                id: this.id,
+                label: this.label,
+                meshPaths: [...this._meshPaths],
+            };
+            return dto;
+        };
+        this.applyData = (data) => {
+            this.label = data.label;
+            this.meshPaths = data.meshPaths;
+        };
+        this.id = dto.id;
+        this._label.setValQuietly(dto.label);
+        this._meshPaths = [...dto.meshPaths];
+    }
+    get label() {
+        return this._label.val;
+    }
+    set label(label) {
+        this._label.val = label;
+    }
+    get meshPaths() {
+        return [...this._meshPaths];
+    }
+    set meshPaths(paths) {
+        let pathsHaveChanged = false;
+        if (paths.length !== this._meshPaths.length) {
+            pathsHaveChanged = true;
+        }
+        else {
+            paths.forEach((path, i) => {
+                if (path !== this._meshPaths[i]) {
+                    pathsHaveChanged = true;
+                }
+            });
+        }
+        if (!pathsHaveChanged)
+            return;
+        this._meshPaths = paths;
+        this.notify();
+    }
+}