@vived/app 4.6.1 → 4.6.2

package/lib/AppObject/AppObjectPM.js

@@ -13,7 +13,7 @@ class AppObjectPM extends AppObjectComponent_1.AppObjectComponent {
     }
     addView(updateView) {
         this.observerList.add(updateView);
-        if (this._lastVM) {
+        if (this._lastVM !== undefined) {
             updateView(this._lastVM);
         }
     }

package/lib/Components/App/UC/submitError.d.ts

@@ -0,0 +1,2 @@
+import { AppObjectRepo } from "../../../AppObject/AppObjectRepo";
+export declare function submitError(sender: string, message: string, appObjects: AppObjectRepo, showAlert?: boolean): void;

package/lib/Components/App/UC/submitError.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.submitError = void 0;
+const Dispatcher_1 = require("../../Dispatcher");
+const LogUC_1 = require("../../Dispatcher/UC/LogUC");
+function submitError(sender, message, appObjects, showAlert = true) {
+    const logUC = LogUC_1.LogUC.get(appObjects);
+    if (logUC) {
+        logUC.error(sender, message);
+    }
+    else {
+        console.error(`[${sender}]: ${message}`);
+    }
+    if (!showAlert)
+        return;
+    const alert = Dispatcher_1.ShowAlertUC.get(appObjects);
+    if (!alert)
+        return;
+    alert.showAlert({
+        title: "Error",
+        closeButtonLabel: "Close",
+        closeCallback: () => {
+            // done
+        },
+        message: `[${sender}]: ${message}`
+    });
+}
+exports.submitError = submitError;

package/lib/Components/App/UC/submitFatal.d.ts

@@ -0,0 +1,2 @@
+import { AppObjectRepo } from "../../../AppObject/AppObjectRepo";
+export declare function submitFatal(sender: string, message: string, appObjects: AppObjectRepo, showAlert?: boolean): void;

package/lib/Components/App/UC/submitFatal.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.submitFatal = void 0;
+const Dispatcher_1 = require("../../Dispatcher");
+const LogUC_1 = require("../../Dispatcher/UC/LogUC");
+function submitFatal(sender, message, appObjects, showAlert = true) {
+    const logUC = LogUC_1.LogUC.get(appObjects);
+    if (logUC) {
+        logUC.fatal(sender, message);
+    }
+    else {
+        console.error(`[${sender}]: ${message}`);
+    }
+    if (!showAlert)
+        return;
+    const alert = Dispatcher_1.ShowAlertUC.get(appObjects);
+    if (!alert)
+        return;
+    alert.showAlert({
+        title: "Fatal Error",
+        closeButtonLabel: "Close",
+        closeCallback: () => {
+            // done
+        },
+        message: `[${sender}]: ${message}`
+    });
+}
+exports.submitFatal = submitFatal;

package/lib/Components/App/UC/submitLog.d.ts

@@ -0,0 +1,2 @@
+import { AppObjectRepo } from "../../../AppObject/AppObjectRepo";
+export declare function submitLog(sender: string, message: string, appObjects: AppObjectRepo, showAlert?: boolean): void;

package/lib/Components/App/UC/submitLog.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.submitLog = void 0;
+const Dispatcher_1 = require("../../Dispatcher");
+const LogUC_1 = require("../../Dispatcher/UC/LogUC");
+function submitLog(sender, message, appObjects, showAlert = false) {
+    const logUC = LogUC_1.LogUC.get(appObjects);
+    if (logUC) {
+        logUC.log(sender, message);
+    }
+    else {
+        console.log(`[${sender}]: ${message}`);
+    }
+    if (!showAlert)
+        return;
+    const alert = Dispatcher_1.ShowAlertUC.get(appObjects);
+    if (!alert)
+        return;
+    alert.showAlert({
+        title: "Log",
+        closeButtonLabel: "Close",
+        closeCallback: () => {
+            // done
+        },
+        message: `[${sender}]: ${message}`
+    });
+}
+exports.submitLog = submitLog;

package/lib/Components/App/UC/submitWarning.d.ts

@@ -0,0 +1,2 @@
+import { AppObjectRepo } from "../../../AppObject/AppObjectRepo";
+export declare function submitWarning(sender: string, message: string, appObjects: AppObjectRepo, showAlert?: boolean): void;

package/lib/Components/App/UC/submitWarning.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.submitWarning = void 0;
+const Dispatcher_1 = require("../../Dispatcher");
+const LogUC_1 = require("../../Dispatcher/UC/LogUC");
+function submitWarning(sender, message, appObjects, showAlert = false) {
+    const logUC = LogUC_1.LogUC.get(appObjects);
+    if (logUC) {
+        logUC.warn(sender, message);
+    }
+    else {
+        console.warn(`[${sender}]: ${message}`);
+    }
+    if (!showAlert)
+        return;
+    const alert = Dispatcher_1.ShowAlertUC.get(appObjects);
+    if (!alert)
+        return;
+    alert.showAlert({
+        title: "Warning",
+        closeButtonLabel: "Close",
+        closeCallback: () => {
+            // done
+        },
+        message: `[${sender}]: ${message}`
+    });
+}
+exports.submitWarning = submitWarning;

package/lib/Components/Camera/Factory/CameraFactoryImp.d.ts

@@ -0,0 +1,4 @@
+import { AppObject } from "@vived/app";
+import { EntityContext } from "Entities/EntityContext";
+import { CameraFactory } from "../Entities/CameraFactory";
+export declare function makeCameraFactory(appObject: AppObject, entities: EntityContext): CameraFactory;

package/lib/Components/Camera/Factory/CameraFactoryImp.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeCameraFactory = void 0;
+const AppObjectComponents_1 = require("@vived/app/lib/AppObjectComponents");
+const CameraEntity_1 = require("../Entities/CameraEntity");
+const CameraFactory_1 = require("../Entities/CameraFactory");
+const CameraPM_1 = require("../PM/CameraPM");
+function makeCameraFactory(appObject, entities) {
+    return new CameraFactoryImp(appObject, entities);
+}
+exports.makeCameraFactory = makeCameraFactory;
+class CameraFactoryImp extends CameraFactory_1.CameraFactory {
+    constructor(appObject, entities) {
+        super(appObject, CameraFactory_1.CameraFactory.type);
+        this.entities = entities;
+        this.setupCamera = () => {
+            const appObjects = this.entities.appObjects;
+            const cameraEntityAo = appObjects.getOrCreate(CameraFactory_1.CameraFactory.entityAppObjectId);
+            new AppObjectComponents_1.Transform3D(cameraEntityAo);
+            const cameraEntity = CameraEntity_1.makeCameraEntity(cameraEntityAo);
+            CameraPM_1.makeCameraPM(cameraEntityAo);
+            return cameraEntity;
+        };
+    }
+}

package/lib/Components/Dispatcher/Mocks/MockLogUC.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="jest" />
+import { AppObject } from "../../../AppObject/AppObject";
+import { LogUC } from "../UC/LogUC";
+export declare class MockLogUC extends LogUC {
+    log: jest.Mock<any, any>;
+    warn: jest.Mock<any, any>;
+    error: jest.Mock<any, any>;
+    fatal: jest.Mock<any, any>;
+    constructor(appObject: AppObject);
+}

package/lib/Components/Dispatcher/Mocks/MockLogUC.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockLogUC = void 0;
+const LogUC_1 = require("../UC/LogUC");
+class MockLogUC extends LogUC_1.LogUC {
+    constructor(appObject) {
+        super(appObject, LogUC_1.LogUC.type);
+        this.log = jest.fn();
+        this.warn = jest.fn();
+        this.error = jest.fn();
+        this.fatal = jest.fn();
+    }
+}
+exports.MockLogUC = MockLogUC;

package/lib/Components/Landmarks/Controller/Mouse/MouseLandmark.d.ts

@@ -0,0 +1,22 @@
+import { AppObject, AppObjectController } from "../../../../AppObject";
+import { MouseController, MouseInputEvent } from "../../../MouseInput";
+export declare abstract class MouseLandmark extends AppObjectController implements MouseController {
+    static type: string;
+    addingLandmark: boolean;
+    pressed: boolean;
+    abstract onMove: (e: MouseInputEvent) => void;
+    abstract onDown: (e: MouseInputEvent) => void;
+}
+export declare function makeMouseLandmark(appObject: AppObject): MouseLandmarkImp;
+declare class MouseLandmarkImp extends MouseLandmark {
+    addingLandmark: boolean;
+    pressed: boolean;
+    private tryPreviewLandmarkUc?;
+    private tryAddLandmarkUc?;
+    allow: (e: MouseInputEvent) => boolean;
+    onMove: (e: MouseInputEvent) => void;
+    onDown: (e: MouseInputEvent) => void;
+    onUp: (e: MouseInputEvent) => void;
+    constructor(appObject: AppObject);
+}
+export {};

package/lib/Components/Landmarks/Controller/Mouse/MouseLandmark.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeMouseLandmark = exports.MouseLandmark = void 0;
+const AppObject_1 = require("../../../../AppObject");
+const Babylon_1 = require("../../../Babylon");
+const MouseInput_1 = require("../../../MouseInput");
+const LandmarkGlobals_1 = require("../../Entities/LandmarkGlobals");
+const TryAddNewLandmarkUC_1 = require("../../UseCases/TryAddNewLandmarkUC");
+const TryPreviewLandmarkUC_1 = require("../../UseCases/TryPreviewLandmarkUC");
+class MouseLandmark extends AppObject_1.AppObjectController {
+    constructor() {
+        super(...arguments);
+        this.addingLandmark = false;
+        this.pressed = false;
+    }
+}
+exports.MouseLandmark = MouseLandmark;
+MouseLandmark.type = "Mouse_Landmark_Controller";
+function makeMouseLandmark(appObject) {
+    return new MouseLandmarkImp(appObject);
+}
+exports.makeMouseLandmark = makeMouseLandmark;
+class MouseLandmarkImp extends MouseLandmark {
+    constructor(appObject) {
+        super(appObject, MouseLandmark.type);
+        this.addingLandmark = false;
+        this.pressed = false;
+        this.allow = (e) => {
+            return true;
+        };
+        this.onMove = (e) => {
+            if (!this.allow(e))
+                return;
+            if (!this.tryPreviewLandmarkUc) {
+                return;
+            }
+            const ray = Babylon_1.pixelToSceneRay(e.position, this.appObjects);
+            this.tryPreviewLandmarkUc.tryPreviewLandmark(ray, this.pressed);
+        };
+        this.onDown = (e) => {
+            this.addingLandmark = false;
+            if (e.button !== 0)
+                return;
+            if (!this.allow(e))
+                return;
+            if (!this.tryPreviewLandmarkUc) {
+                return;
+            }
+            const ray = Babylon_1.pixelToSceneRay(e.position, this.appObjects);
+            const pressed = true;
+            this.tryPreviewLandmarkUc.tryPreviewLandmark(ray, pressed);
+            this.addingLandmark = true;
+            this.pressed = true;
+        };
+        this.onUp = (e) => {
+            var _a;
+            if (!this.allow(e))
+                return;
+            if (!this.addingLandmark)
+                return;
+            if (!this.tryAddLandmarkUc)
+                return;
+            const landmarkPreview = (_a = this.appObject.getComponent(LandmarkGlobals_1.LandmarkGlobals.type)) === null || _a === void 0 ? void 0 : _a.previewLandmark;
+            if (!landmarkPreview) {
+                return;
+            }
+            const ray = Babylon_1.pixelToSceneRay(e.position, this.appObjects);
+            this.tryAddLandmarkUc.addFromRay(ray);
+            landmarkPreview.hideable.isHidden = true;
+            this.addingLandmark = false;
+            this.pressed = false;
+        };
+        this.tryPreviewLandmarkUc = TryPreviewLandmarkUC_1.TryPreviewLandmarkUC.get(appObject);
+        if (!this.tryPreviewLandmarkUc) {
+            this.warn("Unable to find TryPreviewLandmarkUC");
+            return;
+        }
+        this.tryAddLandmarkUc = TryAddNewLandmarkUC_1.TryAddNewLandmarkUC.get(appObject);
+        if (!this.tryAddLandmarkUc) {
+            this.warn("Unable to find TryAddNewLandmarkUC");
+            return;
+        }
+        const mouseInput = MouseInput_1.MouseInputEntity.get(this.appObjects);
+        if (mouseInput) {
+            mouseInput.registerController(this);
+        }
+        else {
+            this.warn("Unable to find MouseInputEntity");
+        }
+    }
+}

package/lib/Components/Landmarks/Controller/Touch/TouchLandmark.d.ts

@@ -0,0 +1,20 @@
+import { AppObject, AppObjectController } from "../../../../AppObject";
+import { TouchController, TouchInputEvent } from "../../../TouchController";
+export declare abstract class TouchLandmark extends AppObjectController implements TouchController {
+    static type: string;
+    abstract onTouchStart(e: TouchInputEvent): void;
+    abstract onTouchMove(e: TouchInputEvent): void;
+    abstract onTouchEnd(e: TouchInputEvent): void;
+}
+export declare function makeTouchLandmark(appObject: AppObject): TouchLandmarkImp;
+declare class TouchLandmarkImp extends TouchLandmark {
+    private lastTouch;
+    private tryPreviewLandmarkUc?;
+    private tryAddLandmarkUc?;
+    allow: (e: TouchInputEvent) => boolean;
+    onTouchStart: (e: TouchInputEvent) => void;
+    onTouchMove: (e: TouchInputEvent) => void;
+    onTouchEnd: (e: TouchInputEvent) => void;
+    constructor(appObject: AppObject);
+}
+export {};

package/lib/Components/Landmarks/Controller/Touch/TouchLandmark.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeTouchLandmark = exports.TouchLandmark = void 0;
+const AppObject_1 = require("../../../../AppObject");
+const ValueObjects_1 = require("../../../../ValueObjects");
+const Babylon_1 = require("../../../Babylon");
+const TouchController_1 = require("../../../TouchController");
+const LandmarkGlobals_1 = require("../../Entities/LandmarkGlobals");
+const TryAddNewLandmarkUC_1 = require("../../UseCases/TryAddNewLandmarkUC");
+const TryPreviewLandmarkUC_1 = require("../../UseCases/TryPreviewLandmarkUC");
+class TouchLandmark extends AppObject_1.AppObjectController {
+}
+exports.TouchLandmark = TouchLandmark;
+TouchLandmark.type = "TOUCH_LANDMARK_CONTROLLER";
+function makeTouchLandmark(appObject) {
+    return new TouchLandmarkImp(appObject);
+}
+exports.makeTouchLandmark = makeTouchLandmark;
+class TouchLandmarkImp extends TouchLandmark {
+    constructor(appObject) {
+        super(appObject, TouchLandmark.type);
+        this.lastTouch = ValueObjects_1.Vector2.Zero();
+        this.allow = (e) => {
+            return true;
+        };
+        this.onTouchStart = (e) => {
+            if (!this.allow(e))
+                return;
+            if (e.touchCount > 1)
+                return;
+            if (!this.tryPreviewLandmarkUc)
+                return;
+            const position = e.touches[0].position;
+            this.lastTouch = position;
+            const ray = Babylon_1.pixelToSceneRay(position, this.appObjects);
+            this.tryPreviewLandmarkUc.tryPreviewLandmark(ray, true);
+        };
+        this.onTouchMove = (e) => {
+            if (!this.allow(e))
+                return;
+            if (e.touchCount > 1)
+                return;
+            if (!this.tryPreviewLandmarkUc)
+                return;
+            const position = e.touches[0].position;
+            this.lastTouch = position;
+            const ray = Babylon_1.pixelToSceneRay(position, this.appObjects);
+            this.tryPreviewLandmarkUc.tryPreviewLandmark(ray, true);
+        };
+        this.onTouchEnd = (e) => {
+            var _a;
+            if (!this.allow(e))
+                return;
+            if (e.touchCount > 1)
+                return;
+            if (!this.tryAddLandmarkUc)
+                return;
+            const landmarkPreview = (_a = this.appObject.getComponent(LandmarkGlobals_1.LandmarkGlobals.type)) === null || _a === void 0 ? void 0 : _a.previewLandmark;
+            if (!landmarkPreview) {
+                return;
+            }
+            const ray = Babylon_1.pixelToSceneRay(this.lastTouch, this.appObjects);
+            this.tryAddLandmarkUc.addFromRay(ray);
+            landmarkPreview.hideable.isHidden = true;
+        };
+        this.tryPreviewLandmarkUc = TryPreviewLandmarkUC_1.TryPreviewLandmarkUC.get(appObject);
+        if (!this.tryPreviewLandmarkUc) {
+            this.warn("Unable to find TryPreviewLandmarkUC");
+            return;
+        }
+        this.tryAddLandmarkUc = TryAddNewLandmarkUC_1.TryAddNewLandmarkUC.get(appObject);
+        if (!this.tryAddLandmarkUc) {
+            this.warn("Unable to find TryAddNewLandmarkUC");
+            return;
+        }
+        const touchInput = TouchController_1.TouchInputEntity.get(this.appObjects);
+        if (touchInput) {
+            touchInput.registerController(this);
+        }
+        else {
+            this.warn("Unable to find TouchInputEntity");
+        }
+    }
+}

package/lib/Components/Landmarks/UseCases/SetOverlayColorUC.d.ts

@@ -0,0 +1,11 @@
+import { AppObject, AppObjectUC } from "../../../AppObject";
+import { OverlayColorEnums } from "../../OverlayColor";
+export declare class SetOverlayColorUC extends AppObjectUC {
+    static readonly type = "SetOverlayColorUC";
+    private overlayColor?;
+    private landmarkGlobals?;
+    setOverlayColor: (color: OverlayColorEnums) => void;
+    dispose: () => void;
+    constructor(appObject: AppObject);
+    static get(appObj: AppObject): SetOverlayColorUC | undefined;
+}

package/lib/Components/Landmarks/UseCases/SetOverlayColorUC.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SetOverlayColorUC = void 0;
+const AppObject_1 = require("../../../AppObject");
+const Dispatcher_1 = require("../../Dispatcher");
+const OverlayColor_1 = require("../../OverlayColor");
+const LandmarkGlobals_1 = require("../Entities/LandmarkGlobals");
+const SetOverlayColorUndoRedo_1 = require("./SetOverlayColorUndoRedo");
+class SetOverlayColorUC extends AppObject_1.AppObjectUC {
+    constructor(appObject) {
+        super(appObject, SetOverlayColorUC.type);
+        this.setOverlayColor = (color) => {
+            if (!this.overlayColor)
+                return;
+            if (!this.landmarkGlobals)
+                return;
+            if (this.overlayColor.overlayColor === color)
+                return;
+            const prevColor = this.overlayColor.overlayColor;
+            this.overlayColor.overlayColor = color;
+            Dispatcher_1.dispatchStateChange(this.appObjects);
+            new SetOverlayColorUndoRedo_1.SetOverlayColorUndoRedo(color, prevColor, this.appObject);
+            this.landmarkGlobals.lastColor = color;
+        };
+        this.dispose = () => {
+            var _a;
+            super.dispose();
+            (_a = this.overlayColor) === null || _a === void 0 ? void 0 : _a.removeOnDisposeObserver(this.dispose);
+        };
+        this.landmarkGlobals = LandmarkGlobals_1.LandmarkGlobals.get(this.appObjects);
+        if (!this.landmarkGlobals) {
+            this.warn("SetOverlayColorUC has been added to an App Object but LandmarkGlobals Entity was not added. Add a LandmarkGlobals Entity");
+            return;
+        }
+        this.overlayColor = appObject.getComponent(OverlayColor_1.OverlayColor.type);
+        if (!this.overlayColor) {
+            this.warn("SetOverlayColorUC has been added to an App Object that does not have a Overlay Color Entity. Add a Overlay Color Entity before adding the UC");
+            return;
+        }
+    }
+    static get(appObj) {
+        return appObj.getComponent(this.type);
+    }
+}
+exports.SetOverlayColorUC = SetOverlayColorUC;
+SetOverlayColorUC.type = "SetOverlayColorUC";

package/lib/Components/Landmarks/UseCases/SetOverlayColorUndoRedo.d.ts

@@ -0,0 +1,12 @@
+import { AppObject } from "../../../AppObject";
+import { OverlayColorEnums } from "../../OverlayColor";
+import { UndoRedoAction } from "../../UndoRedo/Entities/UndoRedoEntity";
+export declare class SetOverlayColorUndoRedo implements UndoRedoAction {
+    private color;
+    private preColor;
+    private appObject;
+    private overlayColor?;
+    undoAction: () => void;
+    redoAction: () => void;
+    constructor(color: OverlayColorEnums, preColor: OverlayColorEnums, appObject: AppObject);
+}

package/lib/Components/Landmarks/UseCases/SetOverlayColorUndoRedo.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SetOverlayColorUndoRedo = void 0;
+const DispatchStateChangeUC_1 = require("../../Dispatcher/UC/DispatchStateChangeUC");
+const OverlayColor_1 = require("../../OverlayColor");
+const UndoRedoEntity_1 = require("../../UndoRedo/Entities/UndoRedoEntity");
+class SetOverlayColorUndoRedo {
+    constructor(color, preColor, appObject) {
+        this.color = color;
+        this.preColor = preColor;
+        this.appObject = appObject;
+        this.undoAction = () => {
+            if (!this.overlayColor)
+                return;
+            this.overlayColor.overlayColor = this.preColor;
+            DispatchStateChangeUC_1.dispatchStateChange(this.appObject.appObjectRepo);
+        };
+        this.redoAction = () => {
+            if (!this.overlayColor)
+                return;
+            this.overlayColor.overlayColor = this.color;
+            DispatchStateChangeUC_1.dispatchStateChange(this.appObject.appObjectRepo);
+        };
+        this.overlayColor = OverlayColor_1.OverlayColor.get(this.appObject);
+        if (!this.overlayColor) {
+            appObject.appObjectRepo.submitWarning("SetOverlayColorUndoRedo", "Unable to find OverlayColorEntity");
+            return;
+        }
+        const undoRedo = UndoRedoEntity_1.UndoRedoEntity.get(appObject.appObjectRepo);
+        if (!undoRedo) {
+            appObject.appObjectRepo.submitWarning("SetOverlayColorUndoRedo", "Unable to find UndoRedoEntity");
+            return;
+        }
+        undoRedo.submitAction(this);
+    }
+}
+exports.SetOverlayColorUndoRedo = SetOverlayColorUndoRedo;

package/lib/Components/Tools/Factory/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./setupTool";
+export * from "./setupToolRepo";

package/lib/{PresentationManagers/SceneModel → Components/Tools/Factory}/index.js

@@ -10,4 +10,5 @@ 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("./SceneModelPM"), exports);
+__exportStar(require("./setupTool"), exports);
+__exportStar(require("./setupToolRepo"), exports);

package/lib/Components/Tools/Factory/setupTool.d.ts

@@ -0,0 +1,3 @@
+import { AppObjectRepo } from "../../../AppObject/AppObjectRepo";
+import { ToolData, ToolEntity } from "../Entities/ToolEntity";
+export declare function setupTool<ToolTypes>(toolData: ToolData<ToolTypes>, appObjects: AppObjectRepo): ToolEntity<ToolTypes>;

package/lib/Components/Tools/Factory/setupTool.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupTool = void 0;
+const ToolEntity_1 = require("../Entities/ToolEntity");
+const ToolPM_1 = require("../PM/ToolPM");
+function setupTool(toolData, appObjects) {
+    const tool = appObjects.getOrCreate(toolData.label);
+    const toolEntity = ToolEntity_1.makeToolEntity(toolData, tool);
+    const pm = new ToolPM_1.ToolPM(tool);
+    return toolEntity;
+}
+exports.setupTool = setupTool;

package/lib/Components/Tools/Factory/setupToolRepo.d.ts

@@ -0,0 +1,4 @@
+import { AppObjectRepo } from "../../../AppObject/AppObjectRepo";
+import { ToolData } from "../Entities/ToolEntity";
+import { ToolRepository } from "../Entities/ToolRepository";
+export declare function setupToolRepo<ToolTypes>(data: ToolData<ToolTypes>[], appObjects: AppObjectRepo): ToolRepository<ToolTypes>;

package/lib/Components/Tools/Factory/setupToolRepo.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupToolRepo = void 0;
+const ToolHotkeys_1 = require("../Controller/ToolHotkeys");
+const ToolRepository_1 = require("../Entities/ToolRepository");
+function setupToolRepo(data, appObjects) {
+    const toolRepo = appObjects.getOrCreate("ToolRepo");
+    const entity = ToolRepository_1.makeToolRepo(toolRepo);
+    entity.setupToolsFromData(data);
+    new ToolHotkeys_1.ToolHotkeys(toolRepo);
+    return entity;
+}
+exports.setupToolRepo = setupToolRepo;

package/package.json

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

package/lib/AppObjectComponents/ChannelModel/Entities/ChannelModel.d.ts

@@ -1,42 +0,0 @@
-import { AppObject, AppObjectEntity } from "../../../AppObject";
-import { Quaternion, Vector3 } from "../../../ValueObjects";
-export declare enum ChannelModelState {
-    INIT = "Initialized",
-    LOADING = "Loading",
-    READY = "Ready",
-    ERROR = "Error"
-}
-export declare class ChannelModel extends AppObjectEntity {
-    static readonly type = "CHANNEL_MODEL";
-    static addIfMissing(appObj: AppObject): ChannelModel;
-    static get(appObj: AppObject): ChannelModel | undefined;
-    private _name;
-    get name(): string;
-    set name(name: string);
-    private _boundsMin;
-    get bounds_min(): Vector3;
-    set bounds_min(bounds_min: Vector3);
-    private _boundsMax;
-    get bounds_max(): Vector3;
-    set bounds_max(bounds_max: Vector3);
-    private _defaultPosition;
-    get defaultPosition(): Vector3;
-    set defaultPosition(position: Vector3);
-    private _defaultRotation;
-    get defaultRotation(): Quaternion;
-    set defaultRotation(rotation: Quaternion);
-    private _defaultScale;
-    get defaultScale(): number;
-    set defaultScale(scale: number);
-    private _state;
-    get state(): ChannelModelState;
-    set state(val: ChannelModelState);
-    private _error;
-    get error(): Error | undefined;
-    set error(val: Error | undefined);
-    private _meshList;
-    get meshList(): string[];
-    set meshList(val: string[]);
-    dispose: () => void;
-    constructor(appObject: AppObject);
-}