@vived/app 3.4.0 → 3.5.1

package/lib/UseCases/FocusCamera/PixelOrbitFocusCamera.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PixelOrbitFocusCamera = void 0;
+const ValueObjects_1 = require("../../ValueObjects");
+class PixelOrbitFocusCamera {
+    constructor(focusCamera) {
+        this.focusCamera = focusCamera;
+        this.sensitivity = 0.5;
+        this.doOrbit = (pixelPosition) => {
+            if (!this.previousPixelPos) {
+                console.error("[PixelOrbitFocusCamera] You must initialize first!");
+                return;
+            }
+            const pixelChange = ValueObjects_1.Vector2.Subtract(pixelPosition, this.previousPixelPos);
+            this.focusCamera.alpha += pixelChange.x * this.sensitivity;
+            this.focusCamera.beta += pixelChange.y * this.sensitivity;
+            this.previousPixelPos = pixelPosition;
+        };
+        this.initializeOrbit = (initialPixelPos, pickPoint) => {
+            this.previousPixelPos = initialPixelPos;
+            this.pickPoint = pickPoint;
+            this.focusCamera.cancelLerp();
+        };
+    }
+}
+exports.PixelOrbitFocusCamera = PixelOrbitFocusCamera;

package/lib/UseCases/FocusCamera/PixelPlanePanFocusCamera.d.ts

@@ -0,0 +1,11 @@
+import { Babylon, FocusCamera } from "../../Entities";
+import { ParametricPlane, Vector2 } from "../../ValueObjects";
+export declare class PixelPlanePanFocusCamera {
+    private focusCamera;
+    private babylon;
+    private plane?;
+    private previousPixelPos?;
+    doPan: (pixelPosition: Vector2) => void;
+    initializePan: (initialPixelPos: Vector2, panPlane: ParametricPlane) => void;
+    constructor(focusCamera: FocusCamera, babylon: Babylon);
+}

package/lib/UseCases/FocusCamera/PixelPlanePanFocusCamera.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PixelPlanePanFocusCamera = void 0;
+const ValueObjects_1 = require("../../ValueObjects");
+class PixelPlanePanFocusCamera {
+    constructor(focusCamera, babylon) {
+        this.focusCamera = focusCamera;
+        this.babylon = babylon;
+        this.doPan = (pixelPosition) => {
+            if (!this.plane || !this.previousPixelPos) {
+                console.error("[PixelPlanePan_OrbitCamera] You must initialize first!");
+                return;
+            }
+            const initialRay = this.babylon.sceneRay(this.previousPixelPos);
+            const finalRay = this.babylon.sceneRay(pixelPosition);
+            const p1 = this.plane.intersectLine(initialRay);
+            const p2 = this.plane.intersectLine(finalRay);
+            if (!p1 || !p2)
+                return;
+            const delta = ValueObjects_1.Vector3.Subtract(p2, p1);
+            const currentTarget = this.focusCamera.target;
+            const newTarget = new ValueObjects_1.Vector3(currentTarget.x - delta.x, currentTarget.y - delta.y, currentTarget.z - delta.z);
+            this.focusCamera.target = new ValueObjects_1.Vector3(newTarget.x, newTarget.y, newTarget.z);
+            this.previousPixelPos = pixelPosition;
+        };
+        this.initializePan = (initialPixelPos, panPlane) => {
+            this.plane = panPlane;
+            this.previousPixelPos = initialPixelPos;
+            this.focusCamera.cancelLerp();
+        };
+    }
+}
+exports.PixelPlanePanFocusCamera = PixelPlanePanFocusCamera;

package/lib/UseCases/FocusCamera/SerializeFocusCamera.d.ts

@@ -0,0 +1,22 @@
+import { FocusCamera, SerializedSystem, StateMachine } from "../../Entities";
+export declare class SerializeFocusCamera implements SerializedSystem {
+    name: string;
+    seriliziationVersion: number;
+    private focusCamera;
+    private stateMachine;
+    getSystemState(): object;
+    applySystemState(serializedState: object, version: number, transitionTime: number): void;
+    applyDefaultState(transitionDuration: number): void;
+    private applyV1Data;
+    private applyImmediate;
+    private applyLerp;
+    constructor(focusCamera: FocusCamera, stateMachine: StateMachine);
+}
+export interface FocusCameraDataV1 {
+    alpha: number;
+    beta: number;
+    radius: number;
+    target_x: number;
+    target_y: number;
+    target_z: number;
+}

package/lib/UseCases/FocusCamera/SerializeFocusCamera.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SerializeFocusCamera = void 0;
+const _1 = require(".");
+const ValueObjects_1 = require("../../ValueObjects");
+class SerializeFocusCamera {
+    constructor(focusCamera, stateMachine) {
+        this.name = "focusCamera";
+        this.seriliziationVersion = 1;
+        this.focusCamera = focusCamera;
+        this.stateMachine = stateMachine;
+        stateMachine.registerSerializedSystem(this);
+    }
+    getSystemState() {
+        const data = {
+            alpha: this.focusCamera.alpha,
+            beta: this.focusCamera.beta,
+            radius: this.focusCamera.radius,
+            target_x: this.focusCamera.target.x,
+            target_y: this.focusCamera.target.y,
+            target_z: this.focusCamera.target.z,
+        };
+        return data;
+    }
+    applySystemState(serializedState, version, transitionTime) {
+        try {
+            if (version === 1) {
+                const castState = serializedState;
+                this.applyV1Data(castState, transitionTime);
+            }
+            else {
+                console.warn(`[SerializeFocusCamera] Unsupported version number ${version}. Defaulting`);
+                this.applyDefaultState(transitionTime);
+            }
+        }
+        catch (e) {
+            console.warn(`[SerializeFocusCamera] Caught when deserializing ${e}. Defaulting`);
+            this.applyDefaultState(transitionTime);
+        }
+    }
+    applyDefaultState(transitionDuration) {
+        const alpha = this.focusCamera.defaultAlpha;
+        const beta = this.focusCamera.defaultBeta;
+        const radius = this.focusCamera.defaultRadius;
+        const target = this.focusCamera.defaultTarget;
+        if (transitionDuration === 0) {
+            this.applyImmediate(alpha, beta, radius, target);
+        }
+        else {
+            this.applyLerp(alpha, beta, radius, target, transitionDuration);
+        }
+    }
+    applyV1Data(data, transitionTime) {
+        const { alpha, beta, radius, target_x, target_y, target_z } = data;
+        const target = new ValueObjects_1.Vector3(target_x, target_y, target_z);
+        if (transitionTime === 0) {
+            this.applyImmediate(alpha, beta, radius, target);
+        }
+        else {
+            this.applyLerp(alpha, beta, radius, target, transitionTime);
+        }
+    }
+    applyImmediate(alpha, beta, radius, target) {
+        this.focusCamera.cancelLerp();
+        this.focusCamera.alpha = alpha;
+        this.focusCamera.beta = beta;
+        this.focusCamera.radius = radius;
+        this.focusCamera.target = target;
+    }
+    applyLerp(alpha, beta, radius, target, transitionTime) {
+        const lerpParams = {
+            duration: transitionTime,
+            finalRadius: radius,
+            finalBeta: beta,
+            finalAlpha: alpha,
+            finalTarget: target,
+        };
+        new _1.LerpFocusCamera(this.focusCamera, this.stateMachine.transitionEaseFunction, lerpParams);
+    }
+}
+exports.SerializeFocusCamera = SerializeFocusCamera;

package/lib/UseCases/FocusCamera/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./PixelPlanePanFocusCamera";
+export * from "./LerpFocusCamera";
+export * from "./SerializeFocusCamera";
+export * from "./PixelDollyFocusCamera";
+export * from "./BumpDollyFocusCamera";
+export * from "./PinchDollyFocusCamera";
+export * from "./PixelOrbitFocusCamera";

package/lib/UseCases/FocusCamera/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./PixelPlanePanFocusCamera"), exports);
+__exportStar(require("./LerpFocusCamera"), exports);
+__exportStar(require("./SerializeFocusCamera"), exports);
+__exportStar(require("./PixelDollyFocusCamera"), exports);
+__exportStar(require("./BumpDollyFocusCamera"), exports);
+__exportStar(require("./PinchDollyFocusCamera"), exports);
+__exportStar(require("./PixelOrbitFocusCamera"), exports);

package/lib/UseCases/SceneModel/SerializeActiveModel.d.ts

@@ -0,0 +1,18 @@
+import { StateMachine, SceneModelMeshStateDTO, SerializedSystem, SceneModelRepo } from "../../Entities";
+export declare class SerializeActiveModel implements SerializedSystem {
+    private sceneModelRepo;
+    private easeFn;
+    name: string;
+    seriliziationVersion: number;
+    loadNewModel: (modelID: string, initialStateLookup: Map<string, SceneModelMeshStateDTO>) => void;
+    selectActiveModel: () => void;
+    getSystemState(): object;
+    applySystemState(state: object, version: number, transitionDurationSec: number): void;
+    private applyStateV1;
+    applyDefaultState: () => void;
+    constructor(sceneModelRepo: SceneModelRepo, easeFn: (normalizedTime: number) => number, stateMachine: StateMachine);
+}
+export interface SerializedActiveModelV1 {
+    modelID: string;
+    meshModelStates: SceneModelMeshStateDTO[];
+}

package/lib/UseCases/SceneModel/SerializeActiveModel.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SerializeActiveModel = void 0;
+const ValueObjects_1 = require("../../ValueObjects");
+class SerializeActiveModel {
+    constructor(sceneModelRepo, easeFn, stateMachine) {
+        this.sceneModelRepo = sceneModelRepo;
+        this.easeFn = easeFn;
+        this.name = "active-model";
+        this.seriliziationVersion = 1;
+        this.loadNewModel = () => {
+            throw new Error("setActiveModel has not been injected into SerializeActiveModel serializer");
+        };
+        this.selectActiveModel = () => {
+            throw new Error("selectActiveModel has not been injected into SerializeActiveModel serializer");
+        };
+        this.applyDefaultState = () => {
+            this.selectActiveModel();
+        };
+        stateMachine.registerSerializedSystem(this);
+    }
+    getSystemState() {
+        const modelStates = [];
+        if (this.sceneModelRepo.activeModel) {
+            this.sceneModelRepo.activeModel.getAllMeshes().forEach((mesh) => {
+                const meshState = mesh.getState();
+                if (meshState !== null) {
+                    modelStates.push(meshState);
+                }
+            });
+        }
+        const state = {
+            modelID: this.sceneModelRepo.activeModelID,
+            meshModelStates: modelStates,
+        };
+        return state;
+    }
+    applySystemState(state, version, transitionDurationSec) {
+        if (version === 1) {
+            this.applyStateV1(state, transitionDurationSec);
+        }
+        else {
+            this.applyDefaultState();
+        }
+    }
+    applyStateV1(state, transitionDurationSec) {
+        const { meshModelStates, modelID } = state;
+        if (meshModelStates === undefined || modelID === undefined) {
+            console.warn("[SerializeActiveModel] Unable to parse state: ", JSON.stringify(state));
+            this.applyDefaultState();
+            return;
+        }
+        const stateLookup = new Map();
+        meshModelStates.forEach((mmState) => {
+            stateLookup.set(mmState.id, mmState);
+        });
+        const existingModel = this.sceneModelRepo.get(modelID);
+        if (existingModel) {
+            this.sceneModelRepo.activeModelID = modelID;
+            existingModel.getAllMeshes().forEach((meshModel) => {
+                const mmState = stateLookup.get(meshModel.id);
+                const pos = mmState
+                    ? ValueObjects_1.Vector3.FromDTO(mmState.position)
+                    : ValueObjects_1.Vector3.Zero();
+                meshModel.moveTo(pos, transitionDurationSec * 1000, this.easeFn);
+                meshModel.shown = mmState ? mmState.shown : true;
+            });
+        }
+        else {
+            this.loadNewModel(modelID, stateLookup);
+        }
+    }
+}
+exports.SerializeActiveModel = SerializeActiveModel;

package/lib/UseCases/SceneModel/SetMeshesEnabledHook.d.ts

@@ -0,0 +1,7 @@
+import { SceneModelRepo } from "../../Entities";
+export declare class SetMeshesEnabledHook {
+    private sceneModelRepo;
+    private lastActiveModelID;
+    onSceneModelRepoChange: () => void;
+    constructor(sceneModelRepo: SceneModelRepo);
+}

package/lib/UseCases/SceneModel/SetMeshesEnabledHook.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SetMeshesEnabledHook = void 0;
+class SetMeshesEnabledHook {
+    constructor(sceneModelRepo) {
+        this.sceneModelRepo = sceneModelRepo;
+        this.onSceneModelRepoChange = () => {
+            if (this.lastActiveModelID === this.sceneModelRepo.activeModelID)
+                return;
+            this.lastActiveModelID = this.sceneModelRepo.activeModelID;
+            this.sceneModelRepo.getAll().forEach((sceneModel) => {
+                const enabled = sceneModel.id === this.sceneModelRepo.activeModelID;
+                sceneModel.getAllMeshes().forEach((mesh) => {
+                    if (mesh.sceneObject)
+                        mesh.sceneObject.enabled = enabled;
+                });
+            });
+        };
+        sceneModelRepo.addObserver(this.onSceneModelRepoChange);
+    }
+}
+exports.SetMeshesEnabledHook = SetMeshesEnabledHook;

package/lib/UseCases/SceneModel/SetSceneModelMeshOverlayColor.d.ts

@@ -0,0 +1,2 @@
+import { Color, SceneModel } from "../../Entities";
+export declare function makeSetSceneModelMeshOverlayColor(sceneModel: SceneModel): (id: string, color: Color | undefined) => void;

package/lib/UseCases/SceneModel/SetSceneModelMeshOverlayColor.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeSetSceneModelMeshOverlayColor = void 0;
+function makeSetSceneModelMeshOverlayColor(sceneModel) {
+    return (id, color) => {
+        const sceneModelMesh = sceneModel.getMeshById(id);
+        if (!sceneModelMesh) {
+            return;
+        }
+        sceneModelMesh.overlayColor = color;
+    };
+}
+exports.makeSetSceneModelMeshOverlayColor = makeSetSceneModelMeshOverlayColor;

package/lib/UseCases/SceneModel/index.d.ts

@@ -1,2 +1,5 @@
 export * from "./modelDataLoader";
 export * from "./loadNewModel";
+export * from "./SerializeActiveModel";
+export * from "./SetMeshesEnabledHook";
+export * from "./SetSceneModelMeshOverlayColor";

package/lib/UseCases/SceneModel/index.js

@@ -12,3 +12,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./modelDataLoader"), exports);
 __exportStar(require("./loadNewModel"), exports);
+__exportStar(require("./SerializeActiveModel"), exports);
+__exportStar(require("./SetMeshesEnabledHook"), exports);
+__exportStar(require("./SetSceneModelMeshOverlayColor"), exports);

package/lib/UseCases/SceneModel/loadNewModel.d.ts

@@ -1,2 +1,2 @@
-import { AppDispatcher, SceneModel, SceneModelRepo, SceneObjectsRepo, SceneRoot } from "../../Entities";
-export declare function makeLoadNewModel(sceneModelRepo: SceneModelRepo, sceneObjectRepo: SceneObjectsRepo, sceneRoot: SceneRoot, appDispatcher: AppDispatcher): (modelID: string) => Promise<SceneModel>;
+import { AppDispatcher, SceneModel, SceneModelMeshStateDTO, SceneModelRepo, SceneObjectsRepo, SceneRoot } from "../../Entities";
+export declare function makeLoadNewModel(sceneModelRepo: SceneModelRepo, sceneObjectRepo: SceneObjectsRepo, sceneRoot: SceneRoot, appDispatcher: AppDispatcher): (modelID: string, initialStateLookup: Map<string, SceneModelMeshStateDTO>) => Promise<SceneModel>;

package/lib/UseCases/SceneModel/loadNewModel.js

@@ -11,8 +11,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeLoadNewModel = void 0;
 const Entities_1 = require("../../Entities");
+const ValueObjects_1 = require("../../ValueObjects");
 function makeLoadNewModel(sceneModelRepo, sceneObjectRepo, sceneRoot, appDispatcher) {
-    return function loadNewModel(modelID) {
+    return function loadNewModel(modelID, initialStateLookup) {
         return __awaiter(this, void 0, void 0, function* () {
             let sceneModel = sceneModelRepo.get(modelID);
             if (sceneModel === undefined) {
@@ -38,20 +39,21 @@ function makeLoadNewModel(sceneModelRepo, sceneObjectRepo, sceneRoot, appDispatc
                 const dataDTO = yield sceneModelRepo.dataLoader(modelID);
                 sceneModel.applyData(dataDTO);
                 sceneModel.getAllMeshes().forEach((meshObject) => {
-                    // let so = sceneObjectRepo.get(meshObject.id);
-                    // if (!so) {
-                    //   so = makeSceneObject(meshObject.id);
-                    //   sceneObjectRepo.add(meshObject.id, so);
-                    // }
-                    // so.transform.parent = sceneRoot.sceneObject?.transform;
-                    // meshObject.sceneObject = so;
-                    // const initialState = initialStateLookup.get(meshObject.id);
-                    // meshObject.position = initialState
-                    //   ? Vector3.FromDTO(initialState.position)
-                    //   : Vector3.Zero();
-                    // meshObject.shown = initialState ? initialState.shown : true;
-                    // so.transform.localRotation = Quaternion.Identity();
-                    // so.transform.localScale = Vector3.One();
+                    var _a;
+                    let so = sceneObjectRepo.get(meshObject.id);
+                    if (!so) {
+                        so = Entities_1.makeSceneObject(meshObject.id);
+                        sceneObjectRepo.add(meshObject.id, so);
+                    }
+                    so.transform.parent = (_a = sceneRoot.sceneObject) === null || _a === void 0 ? void 0 : _a.transform;
+                    meshObject.sceneObject = so;
+                    const initialState = initialStateLookup.get(meshObject.id);
+                    meshObject.position = initialState
+                        ? ValueObjects_1.Vector3.FromDTO(initialState.position)
+                        : ValueObjects_1.Vector3.Zero();
+                    meshObject.shown = initialState ? initialState.shown : true;
+                    so.transform.localRotation = ValueObjects_1.Quaternion.Identity();
+                    so.transform.localScale = ValueObjects_1.Vector3.One();
                 });
                 yield sceneModelRepo.modelLoader(modelID);
                 sceneModel.state = Entities_1.SceneModelState.READY;

package/lib/UseCases/SceneObjects/PeelSceneObject.d.ts

@@ -0,0 +1,18 @@
+import { Babylon, SceneObject, SceneObjectsRepo } from "../../Entities";
+import { ParametricLine } from "../../ValueObjects";
+export declare class PeelSceneObject {
+    private babylon;
+    private sceneObjectRepo;
+    private _didPeel;
+    get didPeel(): boolean;
+    private _peelingSceneObject;
+    get peelingSceneObject(): SceneObject | undefined;
+    private _peelPlane;
+    private _rootPos;
+    private _allowPeel;
+    private _pickOffset;
+    tryInitializePeel: (pickRay: ParametricLine) => void;
+    updatePeel: (pickRay: ParametricLine) => void;
+    stopPeel: () => void;
+    constructor(babylon: Babylon, sceneObjectRepo: SceneObjectsRepo);
+}

package/lib/UseCases/SceneObjects/PeelSceneObject.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PeelSceneObject = void 0;
+const ValueObjects_1 = require("../../ValueObjects");
+class PeelSceneObject {
+    constructor(babylon, sceneObjectRepo) {
+        this.babylon = babylon;
+        this.sceneObjectRepo = sceneObjectRepo;
+        this._didPeel = false;
+        this._peelingSceneObject = undefined;
+        this._peelPlane = ValueObjects_1.ParametricPlane.XY();
+        this._allowPeel = false;
+        this._pickOffset = ValueObjects_1.Vector3.Zero();
+        this.tryInitializePeel = (pickRay) => {
+            var _a, _b;
+            this._allowPeel = false;
+            this._didPeel = false;
+            this._peelingSceneObject = undefined;
+            const sceneObjectID = this.babylon.sceneObjectRayPick(pickRay);
+            if (!sceneObjectID)
+                return;
+            const sceneObject = this.sceneObjectRepo.get(sceneObjectID);
+            if (!sceneObject)
+                return;
+            this._peelingSceneObject = sceneObject;
+            const scenePick = this.babylon.sceneRayPick(pickRay);
+            if (!scenePick)
+                return;
+            const pickPlaneDirection = ValueObjects_1.Vector3.Backward();
+            const planePickPos = (_a = scenePick.worldPickPoint) !== null && _a !== void 0 ? _a : ValueObjects_1.Vector3.Zero();
+            this._peelPlane = ValueObjects_1.ParametricPlane.FromPointNormal(planePickPos, pickPlaneDirection);
+            const pick = (_b = this._peelPlane.intersectLine(pickRay)) !== null && _b !== void 0 ? _b : ValueObjects_1.Vector3.Zero();
+            this._rootPos = this._peelingSceneObject.transform.worldPosition;
+            this._pickOffset = ValueObjects_1.Vector3.Subtract(this._rootPos, pick);
+            this._allowPeel = true;
+        };
+        this.updatePeel = (pickRay) => {
+            var _a;
+            if (!this._allowPeel)
+                return;
+            if (!this._peelingSceneObject)
+                return;
+            const pick = (_a = this._peelPlane.intersectLine(pickRay)) !== null && _a !== void 0 ? _a : ValueObjects_1.Vector3.Zero();
+            this._peelingSceneObject.transform.worldPosition = ValueObjects_1.Vector3.Add(pick, this._pickOffset);
+            this._didPeel = true;
+        };
+        this.stopPeel = () => {
+            this._allowPeel = false;
+            this._didPeel = false;
+            this._peelingSceneObject = undefined;
+            this._rootPos = undefined;
+        };
+    }
+    get didPeel() {
+        return this._didPeel;
+    }
+    get peelingSceneObject() {
+        return this._peelingSceneObject;
+    }
+}
+exports.PeelSceneObject = PeelSceneObject;

package/lib/UseCases/SceneObjects/index.d.ts

@@ -0,0 +1 @@
+export * from "./PeelSceneObject";

package/lib/UseCases/SceneObjects/index.js

@@ -0,0 +1,13 @@
+"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("./PeelSceneObject"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vived/app",
-  "version": "3.4.0",
+  "version": "3.5.1",
   "description": "Public package for the VIVED Learning App system",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",

package/lib/AppObject/IsEnabledPM.d.ts

@@ -1,11 +0,0 @@
-import { AppObject } from "./AppObject";
-import { AppObjectPM } from "./AppObjectPM";
-import { AppObjectRepo } from "./AppObjectRepo";
-export declare class IsEnabledPM extends AppObjectPM<boolean> {
-    static readonly type = "IsEnabledPM";
-    onEnabledChange: () => void;
-    dispose: () => void;
-    vmsAreEqual(a: boolean, b: boolean): boolean;
-    constructor(appObject: AppObject);
-    static getForID(appObjID: string, appObjects: AppObjectRepo): IsEnabledPM | undefined;
-}

package/lib/AppObject/IsEnabledPM.js

@@ -1,29 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.IsEnabledPM = void 0;
-const AppObjectPM_1 = require("./AppObjectPM");
-class IsEnabledPM extends AppObjectPM_1.AppObjectPM {
-    constructor(appObject) {
-        super(appObject, IsEnabledPM.type);
-        this.onEnabledChange = () => {
-            this.doUpdateView(this.appObject.enabled);
-        };
-        this.dispose = () => {
-            this.appObject.removeObserver(this.onEnabledChange);
-        };
-        appObject.addObserver(this.onEnabledChange);
-        this.onEnabledChange();
-    }
-    vmsAreEqual(a, b) {
-        return a === b;
-    }
-    static getForID(appObjID, appObjects) {
-        const appObj = appObjects.get(appObjID);
-        if (appObj === undefined) {
-            return undefined;
-        }
-        return appObj.getComponent(IsEnabledPM.type);
-    }
-}
-exports.IsEnabledPM = IsEnabledPM;
-IsEnabledPM.type = "IsEnabledPM";

package/lib/AppObjectComponents/Transform3D/UseCases/getStickUC.d.ts

@@ -1,3 +0,0 @@
-import { AppObject } from "../../../AppObject";
-import { StickTransform3D } from "./StickTransform3D";
-export declare function getStickUC(appObject: AppObject): StickTransform3D | undefined;

package/lib/AppObjectComponents/Transform3D/UseCases/getStickUC.js

@@ -1,8 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getStickUC = void 0;
-const StickTransform3D_1 = require("./StickTransform3D");
-function getStickUC(appObject) {
-    return appObject.getUC(StickTransform3D_1.STICK_TRANFORM3D_UC_TYPE);
-}
-exports.getStickUC = getStickUC;