@vived/app 4.1.0 → 4.3.0

package/lib/Entities/ObservableEntityRepo.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObservableEntityRepo = void 0;
+const ObservableEntity_1 = require("./ObservableEntity");
+const ObserverList_1 = require("./ObserverList");
+class ObservableEntityRepo extends ObservableEntity_1.ObservableEntity {
+    constructor() {
+        super(...arguments);
+        this.entityLookup = new Map();
+        this.onEntityAddedObservers = new ObserverList_1.ObserverList();
+        this.addEntityAddedObserver = (observer) => {
+            this.onEntityAddedObservers.add(observer);
+        };
+        this.removeEntityAddedObserver = (observer) => {
+            this.onEntityAddedObservers.remove(observer);
+        };
+        this.onEntityRemovedObservers = new ObserverList_1.ObserverList();
+        this.addEntityRemovedObserver = (observer) => {
+            this.onEntityRemovedObservers.add(observer);
+        };
+        this.removeEntityRemovedObserver = (observer) => {
+            this.onEntityRemovedObservers.remove(observer);
+        };
+        this.has = (id) => {
+            return this.entityLookup.has(id);
+        };
+        this.add = (id, entity) => {
+            const existing = this.entityLookup.get(id);
+            if (existing) {
+                existing.removeObserver(this.notify);
+            }
+            this.entityLookup.set(id, entity);
+            entity.addObserver(this.notify);
+            this.notify();
+            this.onEntityAddedObservers.notify(entity);
+        };
+        this.remove = (id) => {
+            const existing = this.entityLookup.get(id);
+            if (!existing)
+                return;
+            this.entityLookup.delete(id);
+            existing.removeObserver(this.notify);
+            this.notify();
+            this.onEntityRemovedObservers.notify(existing);
+        };
+        this.clear = () => {
+            if (this.entityLookup.size === 0)
+                return;
+            this.entityLookup.forEach((entity) => {
+                entity.removeObserver(this.notify);
+                this.onEntityRemovedObservers.notify(entity);
+            });
+            this.entityLookup.clear();
+            this.notify();
+        };
+        this.get = (id) => {
+            return this.entityLookup.get(id);
+        };
+        this.getAll = () => {
+            return Array.from(this.entityLookup.values());
+        };
+        this.set = (entities) => {
+            if (this.entityLookup.size === 0 && entities.length === 0) {
+                return;
+            }
+            this.entityLookup.forEach((entity) => {
+                entity.removeObserver(this.notify);
+                this.onEntityRemovedObservers.notify(entity);
+            });
+            this.entityLookup.clear();
+            entities.forEach((e) => {
+                this.entityLookup.set(e.id, e.entity);
+                e.entity.addObserver(this.notify);
+                this.onEntityAddedObservers.notify(e.entity);
+            });
+            this.notify();
+        };
+    }
+}
+exports.ObservableEntityRepo = ObservableEntityRepo;

package/lib/Entities/QuestionChallenge.d.ts

@@ -0,0 +1,21 @@
+import { QuestionChallengeAnswer } from "./QuestionChallengeAnswer";
+export declare type OnQuestionChallengeChange = () => void;
+export interface QuestionChallenge {
+    gotItRight: boolean;
+    tries: number;
+    text: string;
+    addAnswer: (answer: QuestionChallengeAnswer) => void;
+    removeAnswer: (id: string) => void;
+    getAnswer: (id: string) => QuestionChallengeAnswer | undefined;
+    getAllAnswers: () => QuestionChallengeAnswer[];
+    hasAnswer: (id: string) => boolean;
+    createAnswer: (text: string) => QuestionChallengeAnswer;
+    removeAllAnswers: () => void;
+    setDefaultState: () => void;
+    reset: () => void;
+    submitAnswer: (id: string) => void;
+    setIDGenerator: (generator: () => string) => void;
+    addObserver: (observer: OnQuestionChallengeChange) => void;
+    removeObserver: (observer: OnQuestionChallengeChange) => void;
+}
+export declare function makeQuestionChallenge(): QuestionChallenge;

package/lib/Entities/QuestionChallenge.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeQuestionChallenge = void 0;
+const _1 = require(".");
+const QuestionChallengeAnswer_1 = require("./QuestionChallengeAnswer");
+function makeQuestionChallenge() {
+    return new QuestionChallengeImp();
+}
+exports.makeQuestionChallenge = makeQuestionChallenge;
+class QuestionChallengeImp {
+    constructor() {
+        this.answerLookup = new Map();
+        this.observers = new _1.ObserverList();
+        this._tries = 0;
+        this._gotItRight = false;
+        this.memoizedText = new _1.MemoizedString("", this.observers.notify);
+        this.generateID = () => {
+            const randomNumber = Math.random() * Date.now();
+            return `${randomNumber}`;
+        };
+        this.setIDGenerator = (generator) => {
+            this.generateID = generator;
+        };
+        this.getAllAnswers = () => {
+            return Array.from(this.answerLookup.values());
+        };
+        this.addAnswer = (answer) => {
+            if (this.answerLookup.has(answer.id)) {
+                console.warn(`Answer with ID ${answer.id} already exists. Overwriting`);
+            }
+            this.answerLookup.set(answer.id, answer);
+            this.reset();
+        };
+        this.removeAnswer = (id) => {
+            const answer = this.answerLookup.get(id);
+            if (!answer)
+                return;
+            this.answerLookup.delete(id);
+            this.reset();
+        };
+        this.getAnswer = (id) => {
+            return this.answerLookup.get(id);
+        };
+        this.hasAnswer = (id) => {
+            return this.answerLookup.has(id);
+        };
+        this.reset = () => {
+            this._gotItRight = false;
+            this._tries = 0;
+            this.answerLookup.forEach((ans) => (ans.showFeedback = false));
+            this.observers.notify();
+        };
+        this.submitAnswer = (id) => {
+            const ans = this.getAnswer(id);
+            if (!ans) {
+                console.warn(`[Question Challenge] Unable to find answer by ID:  ${id}`);
+                return;
+            }
+            this._tries++;
+            ans.showFeedback = true;
+            this._gotItRight = ans.isCorrect;
+            this.observers.notify();
+        };
+        this.createAnswer = (text) => {
+            const id = this.generateID();
+            const answer = QuestionChallengeAnswer_1.makeQuestionChallengeAnswer(id);
+            answer.text = text;
+            this.addAnswer(answer);
+            return answer;
+        };
+        this.removeAllAnswers = () => {
+            const allAnswers = Array.from(this.answerLookup.keys());
+            allAnswers.forEach((id) => this.removeAnswer(id));
+            this.reset();
+        };
+        this.setDefaultState = () => {
+            this.removeAllAnswers();
+            const trueAnswer = this.createAnswer("True");
+            trueAnswer.isCorrect = true;
+            this.createAnswer("False");
+            this.memoizedText.setValQuietly("True / False question text");
+            this.reset();
+        };
+        this.addObserver = (observer) => {
+            this.observers.add(observer);
+        };
+        this.removeObserver = (observer) => {
+            this.observers.remove(observer);
+        };
+    }
+    get tries() {
+        return this._tries;
+    }
+    get gotItRight() {
+        return this._gotItRight;
+    }
+    get text() {
+        return this.memoizedText.val;
+    }
+    set text(val) {
+        this.memoizedText.val = val;
+    }
+}

package/lib/Entities/QuestionChallengeAnswer.d.ts

@@ -0,0 +1,32 @@
+export declare type OnQuestionAnswerChange = () => void;
+export interface QuestionChallengeAnswer {
+    id: string;
+    text: string;
+    isCorrect: boolean;
+    feedbackText: string;
+    showFeedback: boolean;
+    addObserver(observer: OnQuestionAnswerChange): void;
+    removeObserver(observer: OnQuestionAnswerChange): void;
+}
+export declare function makeQuestionChallengeAnswer(id: string): QuestionChallengeAnswerImp;
+declare class QuestionChallengeAnswerImp implements QuestionChallengeAnswer {
+    private observers;
+    private _id;
+    get id(): string;
+    private memoizedText;
+    get text(): string;
+    set text(val: string);
+    private memoizedFeedback;
+    get feedbackText(): string;
+    set feedbackText(val: string);
+    private memoizedIsCorrect;
+    get isCorrect(): boolean;
+    set isCorrect(val: boolean);
+    private memoizedShowFeedback;
+    get showFeedback(): boolean;
+    set showFeedback(val: boolean);
+    addObserver(observer: OnQuestionAnswerChange): void;
+    removeObserver(observer: OnQuestionAnswerChange): void;
+    constructor(id: string);
+}
+export {};

package/lib/Entities/QuestionChallengeAnswer.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeQuestionChallengeAnswer = void 0;
+const _1 = require(".");
+function makeQuestionChallengeAnswer(id) {
+    return new QuestionChallengeAnswerImp(id);
+}
+exports.makeQuestionChallengeAnswer = makeQuestionChallengeAnswer;
+class QuestionChallengeAnswerImp {
+    constructor(id) {
+        this.observers = new _1.ObserverList();
+        this.memoizedText = new _1.MemoizedString("Answer", this.observers.notify);
+        this.memoizedFeedback = new _1.MemoizedString("", this.observers.notify);
+        this.memoizedIsCorrect = new _1.MemoizedBoolean(false, this.observers.notify);
+        this.memoizedShowFeedback = new _1.MemoizedBoolean(false, this.observers.notify);
+        this._id = id;
+    }
+    get id() {
+        return this._id;
+    }
+    get text() {
+        return this.memoizedText.val;
+    }
+    set text(val) {
+        this.memoizedText.val = val;
+    }
+    get feedbackText() {
+        return this.memoizedFeedback.val;
+    }
+    set feedbackText(val) {
+        this.memoizedFeedback.val = val;
+    }
+    get isCorrect() {
+        return this.memoizedIsCorrect.val;
+    }
+    set isCorrect(val) {
+        this.memoizedIsCorrect.val = val;
+    }
+    get showFeedback() {
+        return this.memoizedShowFeedback.val;
+    }
+    set showFeedback(val) {
+        this.memoizedShowFeedback.val = val;
+    }
+    addObserver(observer) {
+        this.observers.add(observer);
+    }
+    removeObserver(observer) {
+        this.observers.remove(observer);
+    }
+}

package/lib/Entities/SceneModel.d.ts

@@ -0,0 +1,85 @@
+import { Quaternion, Vector3 } from "../ValueObjects";
+import { ObservableEntity } from "./ObservableEntity";
+import { SceneModelMesh, SceneModelObjectDTOv1, SceneModelObjectDTOv0 } from "./SceneModelMesh";
+export declare enum SceneModelState {
+    INIT = "Initialized",
+    LOADING = "Loading",
+    READY = "Ready",
+    ERROR = "Error"
+}
+export declare abstract class SceneModel extends ObservableEntity {
+    abstract readonly id: string;
+    abstract name: string;
+    abstract state: SceneModelState;
+    abstract error: Error | undefined;
+    abstract bounds_min: Vector3;
+    abstract bounds_max: Vector3;
+    abstract defaultPosition: Vector3;
+    abstract defaultRotation: Quaternion;
+    abstract defaultScale: number;
+    abstract hasMesh(id: string): boolean;
+    abstract getMeshById(id: string): SceneModelMesh | undefined;
+    abstract getMeshByPath(path: string): SceneModelMesh | undefined;
+    abstract addMesh(object: SceneModelMesh): void;
+    abstract removeMesh(id: string): void;
+    abstract getAllMeshes(): SceneModelMesh[];
+    abstract applyData(data: SceneModelDTO): void;
+    abstract toData(): SceneModelDTO;
+}
+export declare function makeSceneModel(id: string): SceneModel;
+export declare type SceneModelDTO = SceneModelDTOV0 | SceneModelDTOv1;
+export interface SceneModelDTOV0 {
+    version: number;
+    objects: SceneModelObjectDTOv0[];
+    name: string;
+    description: string;
+    bounds_min: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    bounds_max: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    defaultPosition: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    defaultRotation: {
+        x: number;
+        y: number;
+        z: number;
+        w: number;
+    };
+    defaultScale: number;
+}
+export interface SceneModelDTOv1 {
+    version: number;
+    objects: SceneModelObjectDTOv1[];
+    name: string;
+    bounds_min: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    bounds_max: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    defaultPosition: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    defaultRotation: {
+        x: number;
+        y: number;
+        z: number;
+        w: number;
+    };
+    defaultScale: number;
+}

package/lib/Entities/SceneModel.js

@@ -0,0 +1,202 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeSceneModel = exports.SceneModel = exports.SceneModelState = void 0;
+const ValueObjects_1 = require("../ValueObjects");
+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;
+(function (SceneModelState) {
+    SceneModelState["INIT"] = "Initialized";
+    SceneModelState["LOADING"] = "Loading";
+    SceneModelState["READY"] = "Ready";
+    SceneModelState["ERROR"] = "Error";
+})(SceneModelState = exports.SceneModelState || (exports.SceneModelState = {}));
+class SceneModel extends ObservableEntity_1.ObservableEntity {
+}
+exports.SceneModel = SceneModel;
+function makeSceneModel(id) {
+    return new SceneModelImp(id);
+}
+exports.makeSceneModel = makeSceneModel;
+class SceneModelImp extends SceneModel {
+    constructor(id) {
+        super();
+        this._name = new MemoizedString_1.MemoizedString("", this.notify);
+        this._boundsMin = new MemoizedVector3_1.MemoizedVector3(ValueObjects_1.Vector3.Zero(), this.notify);
+        this._boundsMax = new MemoizedVector3_1.MemoizedVector3(ValueObjects_1.Vector3.Zero(), this.notify);
+        this._defaultPosition = new MemoizedVector3_1.MemoizedVector3(ValueObjects_1.Vector3.Zero(), this.notify);
+        this._defaultRotation = new MemoizedQuaternion_1.MemoizedQuaternion(ValueObjects_1.Quaternion.Identity(), this.notify);
+        this._defaultScale = new MemoizedNumber_1.MemoizedNumber(1, this.notify);
+        this._state = new MemoizedString_1.MemoizedString(SceneModelState.INIT, this.notify);
+        this.sceneModelObjectLookup = new Map();
+        this.hasMesh = (id) => {
+            return this.sceneModelObjectLookup.has(id);
+        };
+        this.getMeshById = (id) => {
+            return this.sceneModelObjectLookup.get(id);
+        };
+        this.getMeshByPath = (path) => {
+            let rVal;
+            this.sceneModelObjectLookup.forEach((sceneModelObject) => {
+                if (sceneModelObject.hasMeshPath(path)) {
+                    rVal = sceneModelObject;
+                }
+            });
+            return rVal;
+        };
+        this.addMesh = (object) => {
+            if (this.sceneModelObjectLookup.has(object.id)) {
+                const orig = this.sceneModelObjectLookup.get(object.id);
+                orig === null || orig === void 0 ? void 0 : orig.removeObserver(this.notify);
+            }
+            this.sceneModelObjectLookup.set(object.id, object);
+            object.addObserver(this.notify);
+            this.notify();
+        };
+        this.removeMesh = (id) => {
+            const orig = this.sceneModelObjectLookup.get(id);
+            if (orig) {
+                this.sceneModelObjectLookup.delete(id);
+                orig.removeObserver(this.notify);
+                this.notify();
+            }
+        };
+        this.getAllMeshes = () => {
+            return Array.from(this.sceneModelObjectLookup.values());
+        };
+        this.applyData = (data) => {
+            if (data.version === 0) {
+                this.applyDataV0(data);
+            }
+            else if (data.version === 1) {
+                this.applyDataV1(data);
+            }
+            else {
+                throw new Error(`applyData unsupported version number: ${data.version}`);
+            }
+        };
+        this.toData = () => {
+            const data = {
+                version: 1,
+                bounds_max: this.bounds_max.dto,
+                bounds_min: this.bounds_min.dto,
+                defaultPosition: this.defaultPosition.dto,
+                defaultRotation: this.defaultRotation.dto,
+                defaultScale: this.defaultScale,
+                name: this.name,
+                objects: this.getAllMeshes().map((obj) => obj.toData()),
+            };
+            return data;
+        };
+        this.id = id;
+    }
+    get name() {
+        return this._name.val;
+    }
+    set name(name) {
+        this._name.val = name;
+    }
+    get bounds_min() {
+        return this._boundsMin.val;
+    }
+    set bounds_min(bounds_min) {
+        this._boundsMin.val = bounds_min;
+    }
+    get bounds_max() {
+        return this._boundsMax.val;
+    }
+    set bounds_max(bounds_max) {
+        this._boundsMax.val = bounds_max;
+    }
+    get defaultPosition() {
+        return this._defaultPosition.val;
+    }
+    set defaultPosition(position) {
+        this._defaultPosition.val = position;
+    }
+    get defaultRotation() {
+        return this._defaultRotation.val;
+    }
+    set defaultRotation(rotation) {
+        this._defaultRotation.val = rotation;
+    }
+    get defaultScale() {
+        return this._defaultScale.val;
+    }
+    set defaultScale(scale) {
+        this._defaultScale.val = scale;
+    }
+    get state() {
+        return this._state.val;
+    }
+    set state(val) {
+        this._state.val = val;
+    }
+    get error() {
+        return this._error;
+    }
+    set error(val) {
+        this._error = val;
+        this._state.val = SceneModelState.ERROR;
+    }
+    applyDataV0(data) {
+        this._name.setValQuietly(data.name);
+        this._boundsMin.setValQuietly(ValueObjects_1.Vector3.FromDTO(data.bounds_min));
+        this._boundsMax.setValQuietly(ValueObjects_1.Vector3.FromDTO(data.bounds_max));
+        this._defaultPosition.setValQuietly(ValueObjects_1.Vector3.FromDTO(data.defaultPosition));
+        this._defaultScale.setValQuietly(data.defaultScale);
+        this._defaultRotation.setValQuietly(ValueObjects_1.Quaternion.FromDTO(data.defaultRotation));
+        const objectsToKeep = [];
+        data.objects.forEach((objectDTO) => {
+            const existingObj = this.sceneModelObjectLookup.get(objectDTO.id);
+            if (existingObj) {
+                existingObj.applyData(objectDTO);
+            }
+            else {
+                const newObj = SceneModelMesh_1.makeSceneModelMesh(objectDTO.id);
+                newObj.applyData(objectDTO);
+                this.addMesh(newObj);
+            }
+            objectsToKeep.push(objectDTO.id);
+        });
+        const allObjects = Array.from(this.sceneModelObjectLookup.keys());
+        allObjects.forEach((obj) => {
+            if (!objectsToKeep.includes(obj)) {
+                this.removeMesh(obj);
+            }
+        });
+        this.notify();
+    }
+    applyDataV1(data) {
+        this._name.setValQuietly(data.name);
+        this._boundsMin.setValQuietly(ValueObjects_1.Vector3.FromDTO(data.bounds_min));
+        this._boundsMax.setValQuietly(ValueObjects_1.Vector3.FromDTO(data.bounds_max));
+        this._defaultPosition.setValQuietly(ValueObjects_1.Vector3.FromDTO(data.defaultPosition));
+        this._defaultScale.setValQuietly(data.defaultScale);
+        this._defaultRotation.setValQuietly(ValueObjects_1.Quaternion.FromDTO(data.defaultRotation));
+        const objectsToKeep = [];
+        data.objects.forEach((objectDTO) => {
+            const existingObj = this.sceneModelObjectLookup.get(objectDTO.id);
+            if (existingObj) {
+                existingObj.applyData(objectDTO);
+            }
+            else {
+                const newObj = SceneModelMesh_1.makeSceneModelMesh(objectDTO.id);
+                newObj.applyData(objectDTO);
+                this.addMesh(newObj);
+            }
+            objectsToKeep.push(objectDTO.id);
+        });
+        const allObjects = Array.from(this.sceneModelObjectLookup.keys());
+        allObjects.forEach((obj) => {
+            if (!objectsToKeep.includes(obj)) {
+                this.removeMesh(obj);
+            }
+        });
+        this.notify();
+    }
+}

package/lib/Entities/SceneModelMesh.d.ts

@@ -0,0 +1,40 @@
+import { ObservableEntity } from "./ObservableEntity";
+export declare abstract class SceneModelMesh 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 makeSceneModelMesh(id: string): SceneModelMeshImp;
+declare class SceneModelMeshImp extends SceneModelMesh {
+    readonly id: string;
+    private _meshPaths;
+    get meshPaths(): string[];
+    set meshPaths(paths: string[]);
+    private memoizedLabel;
+    get label(): string;
+    set label(val: string);
+    addMeshPath: (path: string) => void;
+    hasMeshPath: (path: string) => boolean;
+    removeMeshPath: (path: string) => void;
+    toData: () => SceneModelObjectDTO;
+    applyData: (data: SceneModelObjectDTO) => void;
+    constructor(id: string);
+}
+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/SceneModelMesh.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeSceneModelMesh = exports.SceneModelMesh = void 0;
+const MemoizedString_1 = require("./Memoized/MemoizedString");
+const ObservableEntity_1 = require("./ObservableEntity");
+class SceneModelMesh extends ObservableEntity_1.ObservableEntity {
+}
+exports.SceneModelMesh = SceneModelMesh;
+function makeSceneModelMesh(id) {
+    return new SceneModelMeshImp(id);
+}
+exports.makeSceneModelMesh = makeSceneModelMesh;
+class SceneModelMeshImp extends SceneModelMesh {
+    constructor(id) {
+        super();
+        this._meshPaths = [];
+        this.memoizedLabel = new MemoizedString_1.MemoizedString("", this.notify);
+        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 = id;
+    }
+    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();
+    }
+    get label() {
+        return this.memoizedLabel.val;
+    }
+    set label(val) {
+        this.memoizedLabel.val = val;
+    }
+}