@rtsdk/topia 0.0.7 → 0.0.9

package/dist/controllers/DroppedAsset.js

@@ -0,0 +1,150 @@
+import { getErrorMessage, publicAPI } from "utils";
+import Asset from "./Asset";
+export class DroppedAsset extends Asset {
+    apiKey;
+    text;
+    urlSlug;
+    // TODO: should we explicitly declare each or simplify with Object.assign for all optional properties? (kinda breaks the ts rules but looks so much nicer!)
+    constructor(apiKey, args, text, urlSlug) {
+        super(args.addedOn, apiKey, args.assetName, args.creatorTags, args.id, args.isPublic, args.kitId, args.layer0, args.layer1, args.library, args.originalAssetId, args.originalKit, args.ownerId, args.ownerName, args.platformAsset, args.purchased, args.purchaseDate, args.purchasedFrom, args.specialType, args.transactionId, args.type, urlSlug);
+        this.apiKey = apiKey;
+        this.text = text;
+        this.urlSlug = urlSlug;
+        Object.assign(this, args);
+        this.updateCustomText;
+    }
+    // get dropped asset
+    fetchDroppedAssetById() {
+        return new Promise((resolve, reject) => {
+            publicAPI(this.apiKey)
+                .get(`/world/${this.urlSlug}/assets/${this.id}`)
+                .then((response) => {
+                Object.assign(this, response.data);
+                resolve("Success!");
+            })
+                .catch((error) => {
+                reject(new Error(getErrorMessage(error)));
+            });
+        });
+    }
+    // delete dropped asset
+    deleteDroppedAsset() {
+        return new Promise((resolve, reject) => {
+            publicAPI(this.apiKey)
+                .delete(`/world/${this.urlSlug}/assets/${this.id}`)
+                .then(() => {
+                resolve("Success!");
+            })
+                .catch((error) => {
+                reject(new Error(getErrorMessage(error)));
+            });
+        });
+    }
+    // update dropped assets
+    #updateDroppedAsset = (payload, updateType) => {
+        console.log("apiKey", this.apiKey);
+        return new Promise((resolve, reject) => {
+            publicAPI(this.apiKey)
+                .put(`/world/${this.urlSlug}/assets/${this.id}/${updateType}`, {
+                ...payload,
+            })
+                .then(() => {
+                resolve("Success!");
+            })
+                .catch((error) => {
+                reject(new Error(getErrorMessage(error)));
+            });
+        });
+    };
+    updateBroadcast({ assetBroadcast, assetBroadcastAll, broadcasterEmail }) {
+        return new Promise((resolve, reject) => {
+            return this.#updateDroppedAsset({ assetBroadcast, assetBroadcastAll, broadcasterEmail }, "set-asset-broadcast")
+                .then(resolve)
+                .catch((error) => {
+                reject(new Error(getErrorMessage(error)));
+            });
+        });
+    }
+    updateClickType({ clickType, clickableLink, clickableLinkTitle, portalName, position, }) {
+        return new Promise((resolve, reject) => {
+            return this.#updateDroppedAsset({ clickType, clickableLink, clickableLinkTitle, portalName, position }, "change-click-type")
+                .then(resolve)
+                .catch((error) => {
+                reject(new Error(getErrorMessage(error)));
+            });
+        });
+    }
+    updateCustomText(style, text) {
+        return new Promise((resolve, reject) => {
+            return this.#updateDroppedAsset({ style, text }, "set-custom-text")
+                .then(resolve)
+                .catch((error) => {
+                reject(new Error(getErrorMessage(error)));
+            });
+        });
+    }
+    updateMediaType({ audioRadius, audioVolume, isVideo, mediaLink, mediaName, mediaType, portalName, syncUserMedia, }) {
+        return new Promise((resolve, reject) => {
+            return this.#updateDroppedAsset({ audioRadius, audioVolume, isVideo, mediaLink, mediaName, mediaType, portalName, syncUserMedia }, "change-media-type")
+                .then(resolve)
+                .catch((error) => {
+                reject(new Error(getErrorMessage(error)));
+            });
+        });
+    }
+    updateMuteZone(isMutezone) {
+        return new Promise((resolve, reject) => {
+            return this.#updateDroppedAsset({ isMutezone }, "set-mute-zone")
+                .then(resolve)
+                .catch((error) => {
+                reject(new Error(getErrorMessage(error)));
+            });
+        });
+    }
+    updatePosition(x, y) {
+        return new Promise((resolve, reject) => {
+            return this.#updateDroppedAsset({ x, y }, "set-position")
+                .then(resolve)
+                .catch((error) => {
+                reject(new Error(getErrorMessage(error)));
+            });
+        });
+    }
+    updatePrivateZone({ isPrivateZone, isPrivateZoneChatDisabled, privateZoneUserCap, }) {
+        return new Promise((resolve, reject) => {
+            return this.#updateDroppedAsset({ isPrivateZone, isPrivateZoneChatDisabled, privateZoneUserCap }, "set-private-zone")
+                .then(resolve)
+                .catch((error) => {
+                reject(new Error(getErrorMessage(error)));
+            });
+        });
+    }
+    updateScale(assetScale) {
+        return new Promise((resolve, reject) => {
+            return this.#updateDroppedAsset({ assetScale }, "change-scale")
+                .then(resolve)
+                .catch((error) => {
+                reject(new Error(getErrorMessage(error)));
+            });
+        });
+    }
+    updateUploadedMediaSelected(mediaId) {
+        return new Promise((resolve, reject) => {
+            return this.#updateDroppedAsset({ mediaId }, "change-uploaded-media-selected")
+                .then(resolve)
+                .catch((error) => {
+                reject(new Error(getErrorMessage(error)));
+            });
+        });
+    }
+    updateWebImageLayers(bottom, top) {
+        return new Promise((resolve, reject) => {
+            return this.#updateDroppedAsset({ bottom, top }, "set-webimage-layers")
+                .then(resolve)
+                .catch((error) => {
+                reject(new Error(getErrorMessage(error)));
+            });
+        });
+    }
+}
+export default Asset;

package/dist/controllers/Scene.js

@@ -0,0 +1,22 @@
+import { getErrorMessage, publicAPI } from "utils";
+export class Scene {
+    apiKey;
+    email;
+    constructor(apiKey, email) {
+        this.apiKey = apiKey;
+        this.email = email;
+    }
+    fetchScenesByEmail() {
+        return new Promise((resolve, reject) => {
+            publicAPI(this.apiKey)
+                .get(`/scenes/my-scenes?email=${this.email}`)
+                .then((response) => {
+                resolve(response.data);
+            })
+                .catch((error) => {
+                reject(new Error(getErrorMessage(error)));
+            });
+        });
+    }
+}
+export default Scene;

package/dist/controllers/Visitor.js

@@ -0,0 +1,70 @@
+import { getErrorMessage, publicAPI } from "utils";
+export class Visitor {
+    apiKey;
+    color;
+    displayName;
+    gestureType;
+    hidden;
+    isAdmin;
+    isBackground;
+    isMobile;
+    isRecording;
+    isRecordingBot;
+    lastUpdate;
+    moveFrom;
+    movedOn;
+    moveTo;
+    muted;
+    performer;
+    performerNear;
+    playerId;
+    shareScreen;
+    sitting;
+    urlSlug;
+    username;
+    constructor(apiKey, color = "", displayName, gestureType = 0, hidden = false, isAdmin = false, isBackground = false, isMobile = false, isRecording = false, isRecordingBot = false, lastUpdate = undefined, moveFrom = {}, movedOn = undefined, moveTo = { x: 0, y: 0 }, muted = false, performer = false, performerNear = false, playerId = undefined, shareScreen = false, sitting = false, urlSlug, username = undefined) {
+        this.apiKey = apiKey;
+        this.color = color;
+        this.displayName = displayName;
+        this.gestureType = gestureType;
+        this.hidden = hidden;
+        this.isAdmin = isAdmin;
+        this.isBackground = isBackground;
+        this.isMobile = isMobile;
+        this.isRecording = isRecording;
+        this.isRecordingBot = isRecordingBot;
+        this.lastUpdate = lastUpdate;
+        this.moveFrom = moveFrom;
+        this.movedOn = movedOn;
+        this.moveTo = moveTo;
+        this.muted = muted;
+        this.performer = performer;
+        this.performerNear = performerNear;
+        this.playerId = playerId;
+        this.shareScreen = shareScreen;
+        this.sitting = sitting;
+        this.urlSlug = urlSlug;
+        this.username = username;
+        this.moveVisitor;
+    }
+    moveVisitor(shouldTeleportVisitor, x, y) {
+        return new Promise((resolve, reject) => {
+            publicAPI(this.apiKey)
+                .put(`/world/${this.urlSlug}/visitors/${this.playerId}/move`, {
+                moveTo: {
+                    x,
+                    y,
+                },
+                teleport: shouldTeleportVisitor,
+            })
+                .then(() => {
+                this.moveTo = { x, y };
+                resolve("Success!");
+            })
+                .catch((error) => {
+                reject(new Error(getErrorMessage(error)));
+            });
+        });
+    }
+}
+export default Visitor;

package/dist/controllers/World.js

@@ -1,71 +1,137 @@
-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());
-    });
-};
-import axios from "axios";
-const API_URL = "https://api.topia.io/api";
-class World {
+import { createVisitor, getErrorMessage, publicAPI, scatterVisitors } from "utils";
+import { DroppedAsset } from "controllers/DroppedAsset";
+import { Visitor } from "controllers/Visitor";
+export class World {
+    #droppedAssetsMap;
+    #visitorsMap;
+    apiKey;
+    background;
+    controls;
+    created;
+    description;
+    enforceWhitelistOnLogin;
+    forceAuthOnLogin;
+    height;
+    heroImage;
+    mapExists;
+    name;
+    redirectTo;
+    spawnPosition;
+    tileBackgroundEverywhere;
+    urlSlug;
+    useTopiaPassword;
+    width;
+    get droppedAssets() {
+        return this.#droppedAssetsMap;
+    }
+    get visitors() {
+        return this.#visitorsMap;
+    }
     constructor(apiKey, urlSlug) {
         this.apiKey = apiKey;
         this.urlSlug = urlSlug;
     }
+    // world details
     fetchDetails() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return new Promise((resolve, reject) => {
-                axios
-                    .get(`${API_URL}/world/${this.urlSlug}/world-details`, {
-                    headers: { Authorization: this.apiKey },
-                })
-                    .then((response) => {
-                    console.log("🚀 ~ file: World.ts ~ line 21 ~ World ~ .then ~ response", response);
-                    resolve(response.data);
-                })
-                    .catch(reject);
+        return new Promise((resolve, reject) => {
+            publicAPI(this.apiKey)
+                .get(`/world/${this.urlSlug}/world-details`)
+                .then((response) => {
+                Object.assign(this, response.data);
+                resolve("Success!");
+            })
+                .catch((error) => {
+                reject(new Error(getErrorMessage(error)));
+            });
+        });
+    }
+    updateDetails() {
+        return new Promise((resolve, reject) => {
+            publicAPI(this.apiKey)
+                .get(`/world/${this.urlSlug}/world-details`)
+                .then(() => {
+                resolve("Success!");
+            })
+                .catch((error) => {
+                reject(new Error(getErrorMessage(error)));
             });
         });
     }
+    // visitors
     fetchVisitors() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return new Promise((resolve, reject) => {
-                axios
-                    .get(`${API_URL}/world/${this.urlSlug}/visitors`, {
-                    headers: { Authorization: this.apiKey },
-                })
-                    .then((response) => {
-                    console.log("🚀 ~ file: World.ts ~ line 35 ~ World ~ .then ~ response", response);
-                    resolve(response.data);
-                })
-                    .catch(reject);
+        return new Promise((resolve, reject) => {
+            publicAPI(this.apiKey)
+                .get(`/world/${this.urlSlug}/visitors`)
+                .then((response) => {
+                // create temp map and then update private property only once
+                const tempVisitorsMap = {};
+                for (const playerId in response.data) {
+                    tempVisitorsMap[playerId] = createVisitor(Visitor, this.apiKey, response.data[playerId], this.urlSlug);
+                }
+                this.#visitorsMap = tempVisitorsMap;
+                resolve("Success!");
+            })
+                .catch((error) => {
+                reject(new Error(getErrorMessage(error)));
             });
         });
     }
-    moveVisitor(visitor) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return new Promise((resolve, reject) => {
-                const requestOptions = {
-                    headers: { Authorization: this.apiKey },
-                    body: {
-                        moveTo: {
-                            x: visitor.coordinates.x,
-                            y: visitor.coordinates.y,
-                        },
-                        teleport: true,
-                    },
-                };
-                axios
-                    .put(`${API_URL}/world/${this.urlSlug}/visitors/${visitor.visitorId}/move`, requestOptions)
-                    .then((response) => {
-                    console.log("🚀 ~ file: World.ts ~ line 49 ~ World ~ .then ~ response", response);
-                    resolve(response.data);
-                })
-                    .catch(reject);
+    async currentVisitors() {
+        try {
+            await this.fetchVisitors();
+            return this.visitors;
+        }
+        catch (error) {
+            return error;
+        }
+    }
+    async moveAllVisitors({ shouldFetchVisitors = true, shouldTeleportVisitors = true, scatterVisitorsBy = 0, x, y, }) {
+        if (shouldFetchVisitors)
+            await this.fetchVisitors();
+        const allPromises = [];
+        if (!this.visitors)
+            return;
+        const objectKeys = Object.keys(this.visitors);
+        objectKeys.forEach((key) => allPromises.push(this.#visitorsMap[key].moveVisitor(shouldTeleportVisitors, scatterVisitors(x, scatterVisitorsBy), scatterVisitors(y, scatterVisitorsBy))));
+        const outcomes = await Promise.allSettled(allPromises);
+        return outcomes;
+    }
+    async moveVisitors(visitorsToMove) {
+        const allPromises = [];
+        visitorsToMove.forEach((v) => {
+            allPromises.push(v.visitorObj.moveVisitor(v.shouldTeleportVisitor, v.x, v.y));
+        });
+        const outcomes = await Promise.allSettled(allPromises);
+        return outcomes;
+    }
+    // dropped assets
+    fetchDroppedAssets() {
+        return new Promise((resolve, reject) => {
+            publicAPI(this.apiKey)
+                .get(`/world/${this.urlSlug}/assets`)
+                .then((response) => {
+                // create temp map and then update private property only once
+                const tempDroppedAssetsMap = {};
+                for (const id in response.data) {
+                    // tempDroppedAssetsMap[id] = createDroppedAsset(this.apiKey, response.data[id], this.urlSlug);
+                    tempDroppedAssetsMap[id] = new DroppedAsset(this.apiKey, response.data[id], "", this.urlSlug);
+                }
+                this.#droppedAssetsMap = tempDroppedAssetsMap;
+                resolve("Success!");
+            })
+                .catch((error) => {
+                reject(new Error(getErrorMessage(error)));
             });
         });
     }
+    async updateCustomTextDroppedAssets(droppedAssetsToUpdate, style) {
+        // adds ability to update any styles for specified dropped assets only while preserving text
+        const allPromises = [];
+        droppedAssetsToUpdate.forEach((a) => {
+            allPromises.push(a.updateCustomText(style, a.text));
+        });
+        const outcomes = await Promise.allSettled(allPromises);
+        return outcomes;
+    }
 }
-export { World };
+export default World;

package/dist/controllers/__tests__/asset.test.js

@@ -0,0 +1,14 @@
+import { assets } from "../../__mocks__";
+import { Asset } from "..";
+afterEach(() => {
+    jest.resetAllMocks();
+});
+describe("Asset Class", () => {
+    it("should return an array of assets owned by specific email address", async () => {
+        const testAsset = new Asset("", "key");
+        testAsset.fetchAssetsByEmail = jest.fn().mockReturnValue(assets);
+        const mockAssets = await testAsset.fetchAssetsByEmail("lina@topia.io");
+        expect(testAsset.fetchAssetsByEmail).toHaveBeenCalled();
+        expect(mockAssets).toBeDefined();
+    });
+});

package/dist/controllers/__tests__/droppedAsset.test.js

@@ -0,0 +1,109 @@
+import { droppedAssets } from "__mocks__";
+import { DroppedAsset } from "..";
+import { DroppedAssetClickType, DroppedAssetMediaType } from "../../types/DroppedAssetTypes";
+import axios from "axios";
+import MockAdapter from "axios-mock-adapter";
+const BASE_URL = `https://api.topia.io/api/world/magic/assets/${droppedAssets[0].id}`;
+describe("DroppedAsset Class", () => {
+    let mock;
+    beforeAll(() => {
+        mock = new MockAdapter(axios);
+    });
+    afterEach(() => {
+        mock.reset();
+        jest.resetAllMocks();
+    });
+    it("should fetch dropped asset by id", async () => {
+        const testDroppedAsset = new DroppedAsset("key", { id: droppedAssets[0].id }, "", "magic");
+        testDroppedAsset.fetchDroppedAssetById = jest.fn().mockReturnValue(droppedAssets[0]);
+        const mockDroppedAssets = await testDroppedAsset.fetchDroppedAssetById();
+        expect(testDroppedAsset.fetchDroppedAssetById).toHaveBeenCalled();
+        expect(mockDroppedAssets).toBeDefined();
+    });
+    it("should update dropped asset broadcast zone", async () => {
+        mock.onPut(`${BASE_URL}/set-asset-broadcast`).reply(200, "Success!");
+        const testDroppedAsset = new DroppedAsset("key", { id: droppedAssets[0].id }, "", "magic");
+        const args = {
+            assetBroadcast: true,
+            assetBroadcastAll: false,
+            broadcasterEmail: "test@test.com",
+        };
+        await testDroppedAsset.updateBroadcast(args);
+        expect(mock.history.put.length).toBe(1);
+    });
+    it("should update dropped asset click type", async () => {
+        mock.onPut(`${BASE_URL}/change-click-type`).reply(200, "Success!");
+        const testDroppedAsset = new DroppedAsset("key", { id: droppedAssets[0].id }, "", "magic");
+        const args = {
+            clickType: DroppedAssetClickType.LINK,
+            clickableLink: "www.test.com",
+            clickableLinkTitle: "Test",
+            portalName: "Test",
+            position: {
+                x: 0,
+                y: 0,
+            },
+        };
+        await testDroppedAsset.updateClickType(args);
+        expect(mock.history.put.length).toBe(1);
+    });
+    it("should update dropped asset custom text", async () => {
+        mock.onPut(`${BASE_URL}/set-custom-text`).reply(200, "Success!");
+        const testDroppedAsset = new DroppedAsset("key", { id: droppedAssets[0].id }, "", "magic");
+        await testDroppedAsset.updateCustomText({ textColor: "#abc123" }, "hello world");
+        expect(mock.history.put.length).toBe(1);
+    });
+    it("should update dropped asset media type", async () => {
+        mock.onPut(`${BASE_URL}/change-media-type`).reply(200, "Success!");
+        const args = {
+            audioRadius: 0,
+            audioVolume: -1,
+            isVideo: true,
+            mediaLink: "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
+            mediaName: "string",
+            mediaType: DroppedAssetMediaType.LINK,
+            portalName: "community",
+            syncUserMedia: true,
+        };
+        const testDroppedAsset = new DroppedAsset("key", { id: droppedAssets[0].id }, "", "magic");
+        await testDroppedAsset.updateMediaType(args);
+        expect(mock.history.put.length).toBe(1);
+    });
+    it("should update dropped asset mute zone", async () => {
+        mock.onPut(`${BASE_URL}/set-mute-zone`).reply(200, "Success!");
+        const testDroppedAsset = new DroppedAsset("key", { id: droppedAssets[0].id }, "", "magic");
+        await testDroppedAsset.updateMuteZone(true);
+        expect(mock.history.put.length).toBe(1);
+    });
+    it("should update dropped asset position", async () => {
+        mock.onPut(`${BASE_URL}/set-position`).reply(200, "Success!");
+        const testDroppedAsset = new DroppedAsset("key", { id: droppedAssets[0].id }, "", "magic");
+        await testDroppedAsset.updatePosition(100, 100);
+        expect(mock.history.put.length).toBe(1);
+    });
+    it("should update dropped asset private zone", async () => {
+        mock.onPut(`${BASE_URL}/set-private-zone`).reply(200, "Success!");
+        const args = { isPrivateZone: true, isPrivateZoneChatDisabled: false, privateZoneUserCap: 10 };
+        const testDroppedAsset = new DroppedAsset("key", { id: droppedAssets[0].id }, "", "magic");
+        await testDroppedAsset.updatePrivateZone(args);
+        expect(mock.history.put.length).toBe(1);
+    });
+    it("should update dropped asset scale", async () => {
+        mock.onPut(`${BASE_URL}/change-scale`).reply(200, "Success!");
+        const testDroppedAsset = new DroppedAsset("key", { id: droppedAssets[0].id }, "", "magic");
+        await testDroppedAsset.updateScale(75);
+        expect(mock.history.put.length).toBe(1);
+    });
+    it("should update dropped asset uploaded media selected", async () => {
+        mock.onPut(`${BASE_URL}/change-uploaded-media-selected`).reply(200, "Success!");
+        const testDroppedAsset = new DroppedAsset("key", { id: droppedAssets[0].id }, "", "magic");
+        await testDroppedAsset.updateUploadedMediaSelected("abc123");
+        expect(mock.history.put.length).toBe(1);
+    });
+    it("should update dropped asset web image layers", async () => {
+        mock.onPut(`${BASE_URL}/set-webimage-layers`).reply(200, "Success!");
+        const testDroppedAsset = new DroppedAsset("key", { id: droppedAssets[0].id }, "", "magic");
+        await testDroppedAsset.updateWebImageLayers("test", "test");
+        expect(mock.history.put.length).toBe(1);
+    });
+});

package/dist/controllers/__tests__/scene.test.js

@@ -0,0 +1,14 @@
+import { scenes } from "../../__mocks__";
+import { Scene } from "..";
+afterEach(() => {
+    jest.resetAllMocks();
+});
+describe("Scene Class", () => {
+    it("should return an array of scenes owned by specific email address", async () => {
+        const testScene = await new Scene("key", "lina@topia.io");
+        testScene.fetchScenesByEmail = jest.fn().mockReturnValue(scenes);
+        const mockScenes = await testScene.fetchScenesByEmail();
+        expect(testScene.fetchScenesByEmail).toHaveBeenCalled();
+        expect(mockScenes).toBeDefined();
+    });
+});

package/dist/controllers/__tests__/visitor.test.js

@@ -0,0 +1,12 @@
+import { Visitor } from "controllers";
+import { createVisitor } from "../../utils/createVisitor";
+import { visitor } from "../../__mocks__/visitors";
+afterEach(() => {
+    jest.resetAllMocks();
+});
+describe("Visitor Class", () => {
+    it("should create an instance of Visitor", async () => {
+        const testVisitor = createVisitor(Visitor, "apiKey", visitor, "magic");
+        expect(testVisitor.displayName).toEqual("test");
+    });
+});

package/dist/controllers/__tests__/world.test.js

@@ -0,0 +1,50 @@
+import { visitors, worlds } from "../../__mocks__";
+import { Visitor, World } from "../../controllers";
+import axios from "axios";
+import MockAdapter from "axios-mock-adapter";
+import { createVisitor } from "utils";
+const BASE_URL = "https://api.topia.io/api/world/magic";
+describe("World Class", () => {
+    let mock;
+    beforeAll(() => {
+        mock = new MockAdapter(axios);
+    });
+    afterEach(() => {
+        mock.reset();
+        jest.resetAllMocks();
+    });
+    it("should return details of a world", async () => {
+        const testWorld = await new World("key", "magic");
+        expect(testWorld.urlSlug).toEqual("magic");
+        testWorld.fetchDetails = jest.fn().mockReturnValue(worlds[1]);
+        const mockDetails = await testWorld.fetchDetails();
+        expect(testWorld.fetchDetails).toHaveBeenCalled();
+        expect(mockDetails).toBeDefined();
+    });
+    it("should move all visitors within a world to a single set of coordinates", async () => {
+        mock.onGet(`${BASE_URL}/visitors`).reply(200, visitors);
+        mock.onPut(`${BASE_URL}/visitors/1/move`).reply(200, "Success!");
+        const testWorld = await new World("key", "magic");
+        const args = { shouldFetchVisitors: true, shouldTeleportVisitors: true, scatterVisitorsBy: 100, x: 20, y: 40 };
+        await testWorld.moveAllVisitors(args);
+        expect(mock.history.put.length).toBe(Object.keys(visitors).length);
+    });
+    it("should return success if world doesn't have visitors", async () => {
+        const testWorld = await new World("key", "magic");
+        const args = { shouldFetchVisitors: false, scatterVisitorsBy: 100, x: 20, y: 40 };
+        await testWorld.moveAllVisitors(args);
+        expect(mock.history.put.length).toBe(0);
+    });
+    it("should move a list of visitors to uniquely specified coordinates", async () => {
+        mock.onPut(`${BASE_URL}/visitors/1/move`).reply(200, "Success!");
+        const testWorld = await new World("key", "magic");
+        const v1 = createVisitor(Visitor, "key", visitors["1"], "magic");
+        const v2 = createVisitor(Visitor, "key", visitors["2"], "magic");
+        const testVisitors = [
+            { visitorObj: v1, shouldTeleportVisitor: true, x: 0, y: 0 },
+            { visitorObj: v2, shouldTeleportVisitor: false, x: 100, y: 100 },
+        ];
+        await testWorld.moveVisitors(testVisitors);
+        expect(mock.history.put.length).toBe(2);
+    });
+});

package/dist/controllers/index.js

@@ -0,0 +1,5 @@
+export { Asset } from "./Asset";
+export { DroppedAsset } from "./DroppedAsset";
+export { Scene } from "./Scene";
+export { Visitor } from "./Visitor";
+export { World } from "./World";