@vived/app 4.1.0 → 4.3.0

package/lib/UseCases/HoverLabels/trySetHoverLabel.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeTrySetHoverLabel = void 0;
+function makeTrySetHoverLabel(hoverLabels, babylon) {
+    return function trySetHoverLabel(position) {
+        const sceneObjectID = babylon.sceneObjectPixelPick(position);
+        if (sceneObjectID) {
+            hoverLabels.showLabelForSceneObject(sceneObjectID, position);
+        }
+    };
+}
+exports.makeTrySetHoverLabel = makeTrySetHoverLabel;

package/lib/UseCases/LerpVector3.d.ts

@@ -0,0 +1,26 @@
+import { Vector3 } from "../ValueObjects";
+export interface LerpVector3DTO {
+    initial: Vector3;
+    final: Vector3;
+    durationMS: number;
+    tickInterval?: number;
+    ease?: (percent: number) => number;
+    onTick?: (v: Vector3) => void;
+    onComplete?: () => void;
+    onCanceled?: () => void;
+}
+export declare class LerpVector3 {
+    private initial;
+    private final;
+    private durationMS;
+    private tickInterval;
+    private ease;
+    private onTick;
+    private onComplete;
+    private onCanceled;
+    private interval?;
+    private chrono;
+    cancel: () => void;
+    private tick;
+    constructor(lerpParams: LerpVector3DTO);
+}

package/lib/UseCases/LerpVector3.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LerpVector3 = void 0;
+const ValueObjects_1 = require("../ValueObjects");
+class LerpVector3 {
+    constructor(lerpParams) {
+        this.tickInterval = 10;
+        this.ease = (p) => p;
+        this.onTick = () => {
+            // Override as needed
+        };
+        this.onComplete = () => {
+            // Override as needed
+        };
+        this.onCanceled = () => {
+            // Override as needed
+        };
+        this.chrono = 0;
+        this.cancel = () => {
+            if (this.interval) {
+                clearInterval(this.interval);
+                this.onCanceled();
+                this.interval = undefined;
+            }
+        };
+        this.tick = () => {
+            this.chrono = this.chrono + this.tickInterval;
+            let nomralizedTime = this.chrono / this.durationMS;
+            if (nomralizedTime > 1) {
+                nomralizedTime = 1;
+            }
+            const percent = this.ease(nomralizedTime);
+            const lerpedVec = ValueObjects_1.Vector3.Lerp(this.initial, this.final, percent);
+            this.onTick(lerpedVec);
+            if (nomralizedTime >= 1 && this.interval) {
+                clearInterval(this.interval);
+                this.interval = undefined;
+                if (this.onComplete) {
+                    this.onComplete();
+                }
+            }
+        };
+        this.initial = lerpParams.initial;
+        this.final = lerpParams.final;
+        this.durationMS = lerpParams.durationMS;
+        if (lerpParams.onTick) {
+            this.onTick = lerpParams.onTick;
+        }
+        if (lerpParams.tickInterval) {
+            this.tickInterval = lerpParams.tickInterval;
+        }
+        if (lerpParams.onComplete) {
+            this.onComplete = lerpParams.onComplete;
+        }
+        if (lerpParams.ease) {
+            this.ease = lerpParams.ease;
+        }
+        if (lerpParams.onCanceled) {
+            this.onCanceled = lerpParams.onCanceled;
+        }
+        this.interval = setInterval(() => {
+            this.tick();
+        }, this.tickInterval);
+    }
+}
+exports.LerpVector3 = LerpVector3;

package/lib/UseCases/QuestionChallenge/SerializeQuestionChallenge.d.ts

@@ -0,0 +1,25 @@
+import { QuestionChallenge, SerializedSystem, StateMachine } from "../../Entities";
+export declare class SerializeQuestionChallenge implements SerializedSystem {
+    private questionChallenge;
+    name: string;
+    seriliziationVersion: number;
+    getSystemState(): object;
+    applySystemState(state: object, version: number): void;
+    applyDefaultState(): void;
+    private applyDataV1;
+    private applyDataV2;
+    constructor(questionChallenge: QuestionChallenge, stateMachine: StateMachine);
+}
+export interface ChallengeDataV2 {
+    questionText: string;
+    answers: AnswerDataV1[];
+}
+export interface ChallengeDataV1 {
+    answers: AnswerDataV1[];
+}
+export interface AnswerDataV1 {
+    id: string;
+    text: string;
+    feedback: string;
+    isCorrect: boolean;
+}

package/lib/UseCases/QuestionChallenge/SerializeQuestionChallenge.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SerializeQuestionChallenge = void 0;
+const Entities_1 = require("../../Entities");
+class SerializeQuestionChallenge {
+    constructor(questionChallenge, stateMachine) {
+        this.questionChallenge = questionChallenge;
+        this.name = "question";
+        this.seriliziationVersion = 2;
+        stateMachine.registerSerializedSystem(this);
+    }
+    getSystemState() {
+        const answers = this.questionChallenge
+            .getAllAnswers()
+            .map((answer) => {
+            return {
+                id: answer.id,
+                feedback: answer.feedbackText,
+                isCorrect: answer.isCorrect,
+                text: answer.text,
+            };
+        });
+        const state = {
+            questionText: this.questionChallenge.text,
+            answers,
+        };
+        return state;
+    }
+    applySystemState(state, version) {
+        if (state && version === 1) {
+            const castState = state;
+            this.applyDataV1(castState);
+        }
+        else if (state && version === 2) {
+            const castState = state;
+            this.applyDataV2(castState);
+        }
+        else {
+            // Unsupported version
+            console.warn(`Unsupported data version ${version} for serialized system ${this.name}. Reverting to default state`);
+            this.applyDefaultState();
+        }
+    }
+    applyDefaultState() {
+        this.questionChallenge.setDefaultState();
+    }
+    applyDataV1(data) {
+        this.questionChallenge.removeAllAnswers();
+        this.questionChallenge.text = "";
+        data.answers.forEach((answerData) => {
+            const answer = Entities_1.makeQuestionChallengeAnswer(answerData.id);
+            answer.text = answerData.text;
+            answer.isCorrect = answerData.isCorrect;
+            answer.feedbackText = answerData.feedback;
+            this.questionChallenge.addAnswer(answer);
+        });
+    }
+    applyDataV2(data) {
+        this.questionChallenge.removeAllAnswers();
+        this.questionChallenge.text = data.questionText;
+        data.answers.forEach((answerData) => {
+            const answer = Entities_1.makeQuestionChallengeAnswer(answerData.id);
+            answer.text = answerData.text;
+            answer.isCorrect = answerData.isCorrect;
+            answer.feedbackText = answerData.feedback;
+            this.questionChallenge.addAnswer(answer);
+        });
+    }
+}
+exports.SerializeQuestionChallenge = SerializeQuestionChallenge;

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

@@ -0,0 +1,4 @@
+export * from "./SerializeQuestionChallenge";
+export * from "./setQuesionChallengeAnswerFeedback";
+export * from "./setQuesionChallengeAnswerText";
+export * from "./toggleQuesionChallengeAnswerIsCorrect";

package/lib/UseCases/QuestionChallenge/index.js

@@ -0,0 +1,16 @@
+"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("./SerializeQuestionChallenge"), exports);
+__exportStar(require("./setQuesionChallengeAnswerFeedback"), exports);
+__exportStar(require("./setQuesionChallengeAnswerText"), exports);
+__exportStar(require("./toggleQuesionChallengeAnswerIsCorrect"), exports);

package/lib/UseCases/QuestionChallenge/setQuesionChallengeAnswerFeedback.d.ts

@@ -0,0 +1,2 @@
+import { QuestionChallenge } from "../../Entities";
+export declare function makeSetQuestionChallengeAnswerFeedback(answerID: string, questionChallenge: QuestionChallenge): (feedback: string) => void;

package/lib/UseCases/QuestionChallenge/setQuesionChallengeAnswerFeedback.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeSetQuestionChallengeAnswerFeedback = void 0;
+function makeSetQuestionChallengeAnswerFeedback(answerID, questionChallenge) {
+    return function setQuestionChallengeAnswerFeedback(feedback) {
+        const answer = questionChallenge.getAnswer(answerID);
+        if (answer) {
+            answer.feedbackText = feedback;
+        }
+        else {
+            console.warn("[setQuestionChallengeAnswerFeedback] Unable to find question by id " +
+                answerID);
+        }
+    };
+}
+exports.makeSetQuestionChallengeAnswerFeedback = makeSetQuestionChallengeAnswerFeedback;

package/lib/UseCases/QuestionChallenge/setQuesionChallengeAnswerText.d.ts

@@ -0,0 +1,2 @@
+import { QuestionChallenge } from "../../Entities";
+export declare function makeSetQuestionChallengeAnswerText(answerID: string, questionChallenge: QuestionChallenge): (text: string) => void;

package/lib/UseCases/QuestionChallenge/setQuesionChallengeAnswerText.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeSetQuestionChallengeAnswerText = void 0;
+function makeSetQuestionChallengeAnswerText(answerID, questionChallenge) {
+    return function setQuestionChallengeAnswerText(text) {
+        const answer = questionChallenge.getAnswer(answerID);
+        if (answer) {
+            answer.text = text;
+        }
+        else {
+            console.warn("[setQuestionChallengeAnswerText] Unable to find question by id " +
+                answerID);
+        }
+    };
+}
+exports.makeSetQuestionChallengeAnswerText = makeSetQuestionChallengeAnswerText;

package/lib/UseCases/QuestionChallenge/toggleQuesionChallengeAnswerIsCorrect.d.ts

@@ -0,0 +1,2 @@
+import { QuestionChallenge } from "../../Entities";
+export declare function makeToggleQuesionChallengeAnswerIsCorrect(answerID: string, questionChallenge: QuestionChallenge): () => void;

package/lib/UseCases/QuestionChallenge/toggleQuesionChallengeAnswerIsCorrect.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeToggleQuesionChallengeAnswerIsCorrect = void 0;
+function makeToggleQuesionChallengeAnswerIsCorrect(answerID, questionChallenge) {
+    return function toggleQuesionChallengeAnswerIsCorrect() {
+        const answer = questionChallenge.getAnswer(answerID);
+        if (answer) {
+            answer.isCorrect = !answer.isCorrect;
+        }
+        else {
+            console.warn("[toggleQuesionChallengeAnswerIsCorrect] Unable to find question by id " +
+                answerID);
+        }
+    };
+}
+exports.makeToggleQuesionChallengeAnswerIsCorrect = makeToggleQuesionChallengeAnswerIsCorrect;

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

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

package/lib/UseCases/SceneModel/index.js

@@ -0,0 +1,17 @@
+"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("./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

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

@@ -0,0 +1,84 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+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, initialStateLookup) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let sceneModel = sceneModelRepo.get(modelID);
+            if (sceneModel === undefined) {
+                sceneModel = Entities_1.makeSceneModel(modelID);
+                sceneModelRepo.add(modelID, sceneModel);
+            }
+            sceneModelRepo.activeModelID = modelID;
+            if (sceneModel.state === Entities_1.SceneModelState.LOADING) {
+                return Promise.resolve(sceneModel);
+            }
+            if (sceneModel.state === Entities_1.SceneModelState.READY) {
+                return Promise.resolve(sceneModel);
+            }
+            sceneModel.error = undefined;
+            sceneModel.state = Entities_1.SceneModelState.LOADING;
+            sceneModelRepo.isLoadingSceneModel = true;
+            const dto = {
+                title: "Loading active model and data",
+                message: "Loading...",
+            };
+            const closeSpinner = yield appDispatcher.showSpinner(dto);
+            try {
+                const dataDTO = yield sceneModelRepo.dataLoader(modelID);
+                sceneModel.applyData(dataDTO);
+                sceneModel.getAllMeshes().forEach((meshObject) => {
+                    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;
+                sceneModelRepo.isLoadingSceneModel = false;
+                closeSpinner();
+                return Promise.resolve(sceneModel);
+            }
+            catch (e) {
+                const error = e;
+                sceneModelRepo.isLoadingSceneModel = false;
+                sceneModelRepo.clearActiveModel();
+                sceneModel.error = error;
+                closeSpinner();
+                const alertDTO = {
+                    title: "Load Error",
+                    message: `Failed to Load the Model and Data. Error message: ${error.message}`,
+                    closeButtonLabel: "OK",
+                    closeCallback: () => {
+                        // nada
+                    },
+                };
+                appDispatcher.showAlert(alertDTO);
+                return Promise.reject(error);
+            }
+        });
+    };
+}
+exports.makeLoadNewModel = makeLoadNewModel;

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

@@ -0,0 +1,3 @@
+import { AppDispatcher, SceneModelDTO } from "../../Entities";
+export declare const SCENE_MODEL_DATA_ASSET_LINK_TYPE = "default_model_data";
+export declare function makeModelDataLoader(appDispatcher: AppDispatcher): (modelID: string) => Promise<SceneModelDTO>;

package/lib/UseCases/SceneModel/modelDataLoader.js

@@ -0,0 +1,33 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeModelDataLoader = exports.SCENE_MODEL_DATA_ASSET_LINK_TYPE = void 0;
+exports.SCENE_MODEL_DATA_ASSET_LINK_TYPE = "default_model_data";
+function makeModelDataLoader(appDispatcher) {
+    return function modelDataLoader(modelID) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const dataAssets = yield appDispatcher.getLinkedAssets(modelID, exports.SCENE_MODEL_DATA_ASSET_LINK_TYPE);
+                if (dataAssets.length === 0) {
+                    return Promise.reject(new Error("Model asset does not have data"));
+                }
+                const dataFileBlobURL = yield appDispatcher.getAssetBlobURL(dataAssets[0].id);
+                const fetchDataResp = yield fetch(dataFileBlobURL);
+                const modelJSONData = yield fetchDataResp.json();
+                return Promise.resolve(modelJSONData);
+            }
+            catch (e) {
+                return Promise.reject(e);
+            }
+        });
+    };
+}
+exports.makeModelDataLoader = makeModelDataLoader;

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);
+}