@vived/app 4.31.0 → 4.33.0

package/lib/Components/Transparency/Controllers/clickToggleIsTransparent.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clickToggleIsTransparent = void 0;
+const UCs_1 = require("../UCs");
+function clickToggleIsTransparent(id, appObjects) {
+    const uc = UCs_1.MakeTransparentUC.get(id, appObjects);
+    if (uc) {
+        uc.toggleIsTransparent();
+    }
+    else {
+        appObjects.submitWarning("clickToggleIsTransparent", "Unable to find MakeTransparentUC");
+    }
+}
+exports.clickToggleIsTransparent = clickToggleIsTransparent;

package/lib/Components/Transparency/Controllers/index.d.ts

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

package/lib/Components/Transparency/Controllers/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("./clickToggleIsTransparent"), exports);

package/lib/Components/Transparency/Entities/Transparency.d.ts

@@ -0,0 +1,10 @@
+import { AppObject, AppObjectEntity, AppObjectRepo } from "../../../AppObject";
+export declare class Transparency extends AppObjectEntity {
+    static readonly type = "Transparency";
+    static addIfMissing(appObj: AppObject): Transparency;
+    static get(appObjID: string, appObjects: AppObjectRepo): Transparency | undefined;
+    private memoizedIsTransparent;
+    get isTransparent(): boolean;
+    set isTransparent(val: boolean);
+    constructor(appObject: AppObject);
+}

package/lib/Components/Transparency/Entities/Transparency.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Transparency = void 0;
+const AppObject_1 = require("../../../AppObject");
+const Entities_1 = require("../../../Entities");
+class Transparency extends AppObject_1.AppObjectEntity {
+    constructor(appObject) {
+        super(appObject, Transparency.type);
+        this.memoizedIsTransparent = new Entities_1.MemoizedBoolean(false, this.notifyOnChange);
+    }
+    static addIfMissing(appObj) {
+        const existing = appObj.getComponent(this.type);
+        if (existing) {
+            return existing;
+        }
+        else {
+            return new Transparency(appObj);
+        }
+    }
+    static get(appObjID, appObjects) {
+        const appObj = appObjects.get(appObjID);
+        if (appObj === undefined) {
+            return undefined;
+        }
+        return appObj.getComponent(Transparency.type);
+    }
+    get isTransparent() {
+        return this.memoizedIsTransparent.val;
+    }
+    set isTransparent(val) {
+        this.memoizedIsTransparent.val = val;
+    }
+}
+exports.Transparency = Transparency;
+Transparency.type = "Transparency";

package/lib/Components/Transparency/Entities/index.d.ts

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

package/lib/Components/Transparency/Entities/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("./Transparency"), exports);

package/lib/Components/Transparency/Factories/index.d.ts

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

package/lib/Components/Transparency/Factories/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("./setupTransparency"), exports);

package/lib/Components/Transparency/Factories/setupTransparency.d.ts

@@ -0,0 +1,2 @@
+import { AppObjectRepo } from "../../../AppObject";
+export declare function setupTransparency(appObjects: AppObjectRepo): void;

package/lib/Components/Transparency/Factories/setupTransparency.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupTransparency = void 0;
+const UCs_1 = require("../UCs");
+function setupTransparency(appObjects) {
+    const ao = appObjects.getOrCreate("Transparent");
+    // UCs
+    UCs_1.makeSerializeTransparentObjects(ao);
+}
+exports.setupTransparency = setupTransparency;

package/lib/Components/Transparency/Mocks/IsTransparentPMock.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="jest" />
+import { AppObject } from "../../../AppObject";
+import { IsTransparentPM } from "../PM";
+export declare class IsTransparentPMock extends IsTransparentPM {
+    vmsAreEqual: jest.Mock<any, any>;
+    constructor(appObject: AppObject);
+}

package/lib/Components/Transparency/Mocks/IsTransparentPMock.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IsTransparentPMock = void 0;
+const PM_1 = require("../PM");
+class IsTransparentPMock extends PM_1.IsTransparentPM {
+    constructor(appObject) {
+        super(appObject, PM_1.IsTransparentPM.type);
+        this.vmsAreEqual = jest.fn();
+    }
+}
+exports.IsTransparentPMock = IsTransparentPMock;

package/lib/Components/Transparency/Mocks/MakeTransparentUCMock.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="jest" />
+import { AppObject } from "../../../AppObject";
+import { MakeTransparentUC } from "../UCs/MakeTransparentUC";
+export declare class MakeTransparentUCMock extends MakeTransparentUC {
+    makeTransparent: jest.Mock<any, any>;
+    toggleIsTransparent: jest.Mock<any, any>;
+    constructor(appObject: AppObject);
+}

package/lib/Components/Transparency/Mocks/MakeTransparentUCMock.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MakeTransparentUCMock = void 0;
+const MakeTransparentUC_1 = require("../UCs/MakeTransparentUC");
+class MakeTransparentUCMock extends MakeTransparentUC_1.MakeTransparentUC {
+    constructor(appObject) {
+        super(appObject, MakeTransparentUC_1.MakeTransparentUC.type);
+        this.makeTransparent = jest.fn();
+        this.toggleIsTransparent = jest.fn();
+    }
+}
+exports.MakeTransparentUCMock = MakeTransparentUCMock;

package/lib/Components/Transparency/Mocks/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./MakeTransparentUCMock";
+export * from "./IsTransparentPMock";

package/lib/Components/Transparency/Mocks/index.js

@@ -0,0 +1,14 @@
+"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("./MakeTransparentUCMock"), exports);
+__exportStar(require("./IsTransparentPMock"), exports);

package/lib/Components/Transparency/PM/IsTransparentPM.d.ts

@@ -0,0 +1,6 @@
+import { AppObject, AppObjectPM, AppObjectRepo } from "../../../AppObject";
+export declare abstract class IsTransparentPM extends AppObjectPM<boolean> {
+    static readonly type = "IsTransparentPM";
+    static get(appObjID: string, appObjects: AppObjectRepo): IsTransparentPM | undefined;
+}
+export declare function makeIsTransparentPM(appObject: AppObject): IsTransparentPM;

package/lib/Components/Transparency/PM/IsTransparentPM.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeIsTransparentPM = exports.IsTransparentPM = void 0;
+const AppObject_1 = require("../../../AppObject");
+const Entities_1 = require("../Entities");
+class IsTransparentPM extends AppObject_1.AppObjectPM {
+    static get(appObjID, appObjects) {
+        const appObj = appObjects.get(appObjID);
+        if (appObj === undefined) {
+            return undefined;
+        }
+        return appObj.getComponent(IsTransparentPM.type);
+    }
+}
+exports.IsTransparentPM = IsTransparentPM;
+IsTransparentPM.type = "IsTransparentPM";
+function makeIsTransparentPM(appObject) {
+    return new IsTransparentPMImp(appObject);
+}
+exports.makeIsTransparentPM = makeIsTransparentPM;
+class IsTransparentPMImp extends IsTransparentPM {
+    constructor(appObject) {
+        super(appObject, IsTransparentPM.type);
+        this.onIsHiddenChange = () => {
+            if (!this.transparency)
+                return;
+            this.doUpdateView(this.transparency.isTransparent);
+        };
+        this.dispose = () => {
+            var _a, _b;
+            super.dispose();
+            (_a = this.transparency) === null || _a === void 0 ? void 0 : _a.removeChangeObserver(this.onIsHiddenChange);
+            (_b = this.transparency) === null || _b === void 0 ? void 0 : _b.removeOnDisposeObserver(this.dispose);
+        };
+        if (!this.transparency) {
+            this.error("Unable to find Transparency Entity");
+            return;
+        }
+        else {
+            this.transparency.addChangeObserver(this.onIsHiddenChange);
+            this.transparency.addOnDisposeObserver(this.dispose);
+            this.onIsHiddenChange();
+        }
+    }
+    get transparency() {
+        return this.getCachedLocalComponent(Entities_1.Transparency.type);
+    }
+    vmsAreEqual(a, b) {
+        return a === b;
+    }
+}

package/lib/Components/Transparency/PM/index.d.ts

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

package/lib/Components/Transparency/PM/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("./IsTransparentPM"), exports);

package/lib/Components/Transparency/UCs/MakeTransparentUC.d.ts

@@ -0,0 +1,8 @@
+import { AppObject, AppObjectRepo, AppObjectUC } from "../../../AppObject";
+export declare abstract class MakeTransparentUC extends AppObjectUC {
+    static type: string;
+    abstract makeTransparent(): void;
+    abstract toggleIsTransparent(): void;
+    static get(id: string, appObjects: AppObjectRepo): MakeTransparentUC | undefined;
+}
+export declare function makeMakeTransparentUC(appObject: AppObject): MakeTransparentUC;

package/lib/Components/Transparency/UCs/MakeTransparentUC.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeMakeTransparentUC = exports.MakeTransparentUC = void 0;
+const AppObject_1 = require("../../../AppObject");
+const Dispatcher_1 = require("../../Dispatcher");
+const UndoRedo_1 = require("../../UndoRedo");
+const Entities_1 = require("../Entities");
+class MakeTransparentUC extends AppObject_1.AppObjectUC {
+    static get(id, appObjects) {
+        const appObj = appObjects.get(id);
+        if (appObj === undefined) {
+            return undefined;
+        }
+        return appObj.getComponent(MakeTransparentUC.type);
+    }
+}
+exports.MakeTransparentUC = MakeTransparentUC;
+MakeTransparentUC.type = "MakeTransparentUC";
+function makeMakeTransparentUC(appObject) {
+    return new MakeTransparentUCImp(appObject);
+}
+exports.makeMakeTransparentUC = makeMakeTransparentUC;
+class MakeTransparentUCImp extends MakeTransparentUC {
+    constructor(appObject) {
+        super(appObject, MakeTransparentUC.type);
+        this.makeTransparent = () => {
+            if (!this.transparency || this.transparency.isTransparent) {
+                return;
+            }
+            this.transparency.isTransparent = true;
+            if (this.dispatchStateChange)
+                this.dispatchStateChange();
+            this.submitUndo();
+        };
+        this.toggleIsTransparent = () => {
+            if (!this.transparency) {
+                return;
+            }
+            this.transparency.isTransparent = !this.transparency.isTransparent;
+            if (this.dispatchStateChange)
+                this.dispatchStateChange();
+            this.submitUndo();
+        };
+        this.submitUndo = () => {
+            const transparency = this.transparency;
+            const dispatcher = this.dispatchStateChange;
+            if (!transparency || !dispatcher || !this.undoRedo) {
+                return;
+            }
+            const undoState = !transparency.isTransparent;
+            const action = {
+                undoAction: () => {
+                    transparency.isTransparent = undoState;
+                    dispatcher();
+                },
+                redoAction: () => {
+                    transparency.isTransparent = !undoState;
+                    dispatcher();
+                },
+            };
+            this.undoRedo.submitAction(action);
+        };
+    }
+    get transparency() {
+        return this.getCachedLocalComponent(Entities_1.Transparency.type);
+    }
+    get dispatchStateChange() {
+        var _a;
+        return (_a = this.getCachedSingleton(Dispatcher_1.DispatchStateChangeUC.type)) === null || _a === void 0 ? void 0 : _a.doDispatch;
+    }
+    get undoRedo() {
+        return this.getCachedSingleton(UndoRedo_1.UndoRedoEntity.type);
+    }
+}

package/lib/Components/Transparency/UCs/SerializeTransparentObjects.d.ts

@@ -0,0 +1,22 @@
+import { AppObject, AppObjectUC } from "../../../AppObject";
+import { SerializedSystem } from "../../StateMachine";
+export declare abstract class SerializeTransparentObjects extends AppObjectUC implements SerializedSystem {
+    static readonly type = "SerializeTransparentObjects";
+    name: string;
+    abstract seriliziationVersion: number;
+    abstract getSystemState(): object;
+    abstract applySystemState(state: object, version: number, transitionDuration: number): void;
+    abstract applyDefaultState(transitionDuration: number): void;
+}
+export declare function makeSerializeTransparentObjects(appObject: AppObject): SerializeTransparentObjects;
+export declare class SerializeTransparentObjectsImp extends SerializeTransparentObjects {
+    seriliziationVersion: number;
+    getSystemState(): object;
+    applySystemState(state: object, version: number, durationS: number): Promise<void> | void;
+    private applyStateV1;
+    applyDefaultState(): void;
+    constructor(appObj: AppObject);
+}
+export interface SerializedTransparentObjectsV1 {
+    transparentObjects: string[];
+}

package/lib/Components/Transparency/UCs/SerializeTransparentObjects.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SerializeTransparentObjectsImp = exports.makeSerializeTransparentObjects = exports.SerializeTransparentObjects = void 0;
+const AppObject_1 = require("../../../AppObject");
+const StateMachine_1 = require("../../StateMachine");
+const Entities_1 = require("../Entities");
+class SerializeTransparentObjects extends AppObject_1.AppObjectUC {
+    constructor() {
+        super(...arguments);
+        this.name = "hideable-objects";
+    }
+}
+exports.SerializeTransparentObjects = SerializeTransparentObjects;
+SerializeTransparentObjects.type = "SerializeTransparentObjects";
+function makeSerializeTransparentObjects(appObject) {
+    return new SerializeTransparentObjectsImp(appObject);
+}
+exports.makeSerializeTransparentObjects = makeSerializeTransparentObjects;
+class SerializeTransparentObjectsImp extends SerializeTransparentObjects {
+    constructor(appObj) {
+        super(appObj, SerializeTransparentObjects.type);
+        this.seriliziationVersion = 1;
+        const stateMachine = this.appObjects.getSingleton(StateMachine_1.StateMachineEntity.type);
+        if (stateMachine) {
+            stateMachine.registerSerializedSystem(this);
+        }
+        else {
+            this.warn("Unable to find StateMachineEntity");
+        }
+    }
+    getSystemState() {
+        const transparentObjects = [];
+        const allTransparents = this.appObjects.getAllComponents(Entities_1.Transparency.type);
+        allTransparents.forEach((transparent) => {
+            if (transparent.isTransparent)
+                transparentObjects.push(transparent.appObject.id);
+        });
+        const state = {
+            transparentObjects,
+        };
+        return state;
+    }
+    applySystemState(state, version, durationS) {
+        if (version === 1) {
+            return this.applyStateV1(state, durationS);
+        }
+        else {
+            this.applyDefaultState();
+        }
+    }
+    applyStateV1(state, durationS) {
+        const { transparentObjects } = state;
+        let transparentObjectsIds = [];
+        if (transparentObjects !== undefined && transparentObjects.length > 0) {
+            transparentObjectsIds = [...transparentObjects];
+        }
+        else {
+            this.applyDefaultState();
+            return;
+        }
+        const allTransparents = this.appObjects.getAllComponents(Entities_1.Transparency.type);
+        allTransparents.forEach((transparent) => {
+            const appObjectId = transparent.appObject.id;
+            if (transparentObjectsIds.includes(appObjectId)) {
+                transparent.isTransparent = true;
+                const index = transparentObjectsIds.indexOf(appObjectId);
+                if (index !== -1) {
+                    transparentObjectsIds.splice(index, 1);
+                }
+            }
+        });
+        transparentObjectsIds.forEach((remainingObjectId) => {
+            const appObject = this.appObjects.get(remainingObjectId);
+            if (appObject) {
+                const hideable = Entities_1.Transparency.addIfMissing(appObject);
+                hideable.isTransparent = true;
+            }
+        });
+    }
+    applyDefaultState() {
+        const allTransparents = this.appObjects.getAllComponents(Entities_1.Transparency.type);
+        allTransparents.forEach((transparent) => {
+            transparent.isTransparent = false;
+        });
+    }
+}
+exports.SerializeTransparentObjectsImp = SerializeTransparentObjectsImp;

package/lib/Components/Transparency/UCs/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./MakeTransparentUC";
+export * from "./SerializeTransparentObjects";

package/lib/Components/Transparency/UCs/index.js

@@ -0,0 +1,14 @@
+"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("./MakeTransparentUC"), exports);
+__exportStar(require("./SerializeTransparentObjects"), exports);

package/lib/Components/Transparency/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./Adapters";
+export * from "./Controllers";
+export * from "./Entities";
+export * from "./Factories";
+export * from "./Mocks";
+export * from "./PM";
+export * from "./UCs";

package/lib/Components/Transparency/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("./Adapters"), exports);
+__exportStar(require("./Controllers"), exports);
+__exportStar(require("./Entities"), exports);
+__exportStar(require("./Factories"), exports);
+__exportStar(require("./Mocks"), exports);
+__exportStar(require("./PM"), exports);
+__exportStar(require("./UCs"), exports);

package/lib/Components/UndoRedo/index.d.ts

@@ -1,4 +1,6 @@
+export * from "./Controllers";
 export * from "./Entities";
+export * from "./Factories";
 export * from "./Mocks";
 export * from "./PM";
-export * from "./Controllers";
+export * from "./UCs";

package/lib/Components/UndoRedo/index.js

@@ -10,7 +10,9 @@ 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("./Controllers"), exports);
 __exportStar(require("./Entities"), exports);
+__exportStar(require("./Factories"), exports);
 __exportStar(require("./Mocks"), exports);
 __exportStar(require("./PM"), exports);
-__exportStar(require("./Controllers"), exports);
+__exportStar(require("./UCs"), exports);

package/lib/Components/index.d.ts

@@ -12,6 +12,7 @@ export * from "./FramedScreen";
 export * from "./GLBModel";
 export * from "./Hideable";
 export * from "./HoverLabel";
+export * from "./InspectorTab";
 export * from "./KeyboardInput";
 export * from "./Label";
 export * from "./LabelDrop";

package/lib/Components/index.js

@@ -24,6 +24,7 @@ __exportStar(require("./FramedScreen"), exports);
 __exportStar(require("./GLBModel"), exports);
 __exportStar(require("./Hideable"), exports);
 __exportStar(require("./HoverLabel"), exports);
+__exportStar(require("./InspectorTab"), exports);
 __exportStar(require("./KeyboardInput"), exports);
 __exportStar(require("./Label"), exports);
 __exportStar(require("./LabelDrop"), exports);

package/package.json

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