@rtsdk/topia 0.0.10 → 0.0.12

package/dist/src/controllers/World.js

@@ -0,0 +1,319 @@
+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());
+    });
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _World_droppedAssetsMap, _World_visitorsMap;
+// controllers
+import { DroppedAsset } from "controllers/DroppedAsset";
+import { SDKController } from "controllers/SDKController";
+import { Visitor } from "controllers/Visitor";
+// utils
+import { getErrorResponse, removeUndefined, scatterVisitors } from "utils";
+/**
+ * Create an instance of World class with a given url slug and optional attributes and session credentials.
+ *
+ * ```ts
+ * await new World(topia, "exampleWorld", { attributes: { name: "Example World" } });
+ * ```
+ */
+export class World extends SDKController {
+    constructor(topia, urlSlug, options = { attributes: {}, credentials: {} }) {
+        super(topia, options.credentials);
+        _World_droppedAssetsMap.set(this, void 0);
+        _World_visitorsMap.set(this, void 0);
+        Object.assign(this, options.attributes);
+        __classPrivateFieldSet(this, _World_droppedAssetsMap, {}, "f");
+        __classPrivateFieldSet(this, _World_visitorsMap, {}, "f");
+        this.urlSlug = urlSlug;
+    }
+    get droppedAssets() {
+        return __classPrivateFieldGet(this, _World_droppedAssetsMap, "f");
+    }
+    get visitors() {
+        return __classPrivateFieldGet(this, _World_visitorsMap, "f");
+    }
+    /**
+     * @summary
+     * Retrieves details of a world.
+     *
+     * @usage
+     * ```ts
+     * await world.fetchDetails();
+     * const { name } = world;
+     * ```
+     */
+    // world details
+    fetchDetails() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const response = yield this.topia.axios.get(`/world/${this.urlSlug}/world-details`, this.requestOptions);
+                Object.assign(this, response.data);
+                console.log("🚀 ~ file: World.ts:64 ~ World ~ fetchDetails ~ response.data", response.data);
+            }
+            catch (error) {
+                console.log("🚀 ~ file: World.ts:65 ~ World ~ fetchDetails ~ error", error);
+                throw getErrorResponse({ error });
+            }
+        });
+    }
+    /**
+     * @summary
+     * Update details of a world.
+     *
+     * @usage
+     * ```ts
+     * await world.updateDetails({
+     *   controls: {
+     *     allowMuteAll: true,
+     *     disableHideVideo: true,
+     *     isMobileDisabled: false,
+     *     isShowingCurrentGuests: false,
+     *   },
+     *   description: 'Welcome to my world.',
+     *   forceAuthOnLogin: false,
+     *   height: 2000,
+     *   name: 'Example',
+     *   spawnPosition: { x: 100, y: 100 },
+     *   width: 2000
+     * });
+     * ```
+     */
+    updateDetails({ controls, description, forceAuthOnLogin, height, name, spawnPosition, width, }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const payload = {
+                controls,
+                description,
+                forceAuthOnLogin,
+                height,
+                name,
+                spawnPosition,
+                width,
+            };
+            try {
+                yield this.topia.axios.put(`/world/${this.urlSlug}/world-details`, payload, this.requestOptions);
+                const cleanPayload = removeUndefined(payload);
+                Object.assign(this, cleanPayload);
+            }
+            catch (error) {
+                throw getErrorResponse({ error });
+            }
+        });
+    }
+    // visitors
+    fetchVisitors() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const response = yield this.topia.axios.get(`/world/${this.urlSlug}/visitors`, this.requestOptions);
+                // create temp map and then update private property only once
+                const tempVisitorsMap = {};
+                for (const id in response.data) {
+                    tempVisitorsMap[id] = new Visitor(this.topia, response.data[id].playerId, this.urlSlug, {
+                        attributes: response.data[id],
+                    });
+                }
+                __classPrivateFieldSet(this, _World_visitorsMap, tempVisitorsMap, "f");
+            }
+            catch (error) {
+                throw getErrorResponse({ error });
+            }
+        });
+    }
+    /**
+     * @summary
+     * Retrieve all visitors currently in a world.
+     *
+     * @usage
+     * ```ts
+     * const visitors = await world.currentVisitors();
+     * ```
+     */
+    currentVisitors() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield this.fetchVisitors();
+                return this.visitors;
+            }
+            catch (error) {
+                return error;
+            }
+        });
+    }
+    /**
+     * @summary
+     * Move all visitors currently in a world to a single set of coordinates.
+     * Optionally refetch visitors, teleport or walk visitors to new location,
+     * and scatter visitors by any number so that they don't all move to the exact same location.
+     *
+     * @usage
+     * ```ts
+     * await world.moveAllVisitors({
+     *   shouldFetchVisitors: true,
+     *   shouldTeleportVisitors: true,
+     *   scatterVisitorsBy: 40,
+     *   x: 100,
+     *   y: 100,
+     * });
+     * ```
+     *
+     * @result
+     * Updates each Visitor instance and world.visitors map.
+     */
+    moveAllVisitors({ shouldFetchVisitors = true, shouldTeleportVisitors = true, scatterVisitorsBy = 0, x, y, }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (shouldFetchVisitors)
+                yield this.fetchVisitors();
+            const allPromises = [];
+            if (!this.visitors)
+                return;
+            const objectKeys = Object.keys(this.visitors);
+            objectKeys.forEach((key) => allPromises.push(__classPrivateFieldGet(this, _World_visitorsMap, "f")[key].moveVisitor({
+                shouldTeleportVisitor: shouldTeleportVisitors,
+                x: scatterVisitors(x, scatterVisitorsBy),
+                y: scatterVisitors(y, scatterVisitorsBy),
+            })));
+            const outcomes = yield Promise.allSettled(allPromises);
+            return outcomes;
+        });
+    }
+    /**
+     * @summary
+     * Teleport or walk a list of visitors currently in a world to various coordinates.
+     *
+     * @usage
+     * ```ts
+     * const visitorsToMove = [
+     *   {
+     *     visitorObj: world.visitors["1"],
+     *     shouldTeleportVisitor: true,
+     *     x: 100,
+     *     y: 100
+     *   }, {
+     *     visitorObj: world.visitors["2"],
+     *     shouldTeleportVisitor: false,
+     *     x: 100,
+     *     y: 100
+     *   }
+     * ];
+     * await world.moveVisitors(visitorsToMove);
+     * ```
+     *
+     * @result
+     * Updates each Visitor instance and world.visitors map.
+     */
+    moveVisitors(visitorsToMove) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const allPromises = [];
+            visitorsToMove.forEach((v) => {
+                allPromises.push(v.visitorObj.moveVisitor({ shouldTeleportVisitor: v.shouldTeleportVisitor, x: v.x, y: v.y }));
+            });
+            const outcomes = yield Promise.allSettled(allPromises);
+            return outcomes;
+        });
+    }
+    /**
+     * @summary
+     * Retrieve all assets dropped in a world.
+     *
+     * @usage
+     * ```ts
+     * await world.fetchDroppedAssets();
+     * const assets = world.droppedAssets;
+     * ```
+     */
+    // dropped assets
+    fetchDroppedAssets() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const response = yield this.topia.axios.get(`/world/${this.urlSlug}/assets`, this.requestOptions);
+                // create temp map and then update private property only once
+                const tempDroppedAssetsMap = {};
+                for (const index in response.data) {
+                    // tempDroppedAssetsMap[id] = createDroppedAsset(this.apiKey, response.data[id], this.urlSlug);
+                    tempDroppedAssetsMap[index] = new DroppedAsset(this.topia, response.data[index].id, this.urlSlug, {
+                        attributes: response.data[index],
+                    });
+                }
+                __classPrivateFieldSet(this, _World_droppedAssetsMap, tempDroppedAssetsMap, "f");
+            }
+            catch (error) {
+                throw getErrorResponse({ error });
+            }
+        });
+    }
+    /**
+     * @summary
+     * Update multiple custom text dropped assets with a single style while preserving text for specified dropped assets only.
+     *
+     * @usage
+     * ```ts
+     * const droppedAssetsToUpdate = [world.droppedAssets["6"], world.droppedAssets["12"]];
+     * const style = {
+     *   "textColor": "#abc123",
+     *   "textFontFamily": "Arial",
+     *   "textSize": 40,
+     *   "textWeight": "normal",
+     *   "textWidth": 200
+     * };
+     * await world.updateCustomText(droppedAssetsToUpdate, style);
+     * ```
+     *
+     * @result
+     * Updates each DroppedAsset instance and world.droppedAssets map.
+     */
+    updateCustomTextDroppedAssets(droppedAssetsToUpdate, style) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const allPromises = [];
+            droppedAssetsToUpdate.forEach((a) => {
+                allPromises.push(a.updateCustomTextAsset(style, a.text));
+            });
+            const outcomes = yield Promise.allSettled(allPromises);
+            return outcomes;
+        });
+    }
+    /**
+     * @summary
+     * Replace the current scene of a world.
+     *
+     * @usage
+     * ```ts
+     * const droppedAssetsToUpdate = [world.droppedAssets["6"], world.droppedAssets["12"]]
+     * const style = {
+     *   "textColor": "#abc123",
+     *   "textFontFamily": "Arial",
+     *   "textSize": 40,
+     *   "textWeight": "normal",
+     *   "textWidth": 200
+     * }
+     * await world.replaceScene(SCENE_ID);
+     * ```
+     */
+    // scenes
+    replaceScene(sceneId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield this.topia.axios.put(`/world/${this.urlSlug}/change-scene`, { sceneId }, this.requestOptions);
+            }
+            catch (error) {
+                throw getErrorResponse({ error });
+            }
+        });
+    }
+}
+_World_droppedAssetsMap = new WeakMap(), _World_visitorsMap = new WeakMap();
+export default World;

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

@@ -0,0 +1,36 @@
+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 MockAdapter from "axios-mock-adapter";
+import { AssetFactory } from "factories";
+import { Topia } from "controllers/Topia";
+const apiDomain = "api.topia.io";
+describe("Asset Class", () => {
+    let Asset, mock, testAsset, topia;
+    beforeEach(() => __awaiter(void 0, void 0, void 0, function* () {
+        topia = new Topia({
+            apiDomain: "api.topia.io",
+            apiKey: "exampleKey",
+            interactiveKey: "key",
+            interactiveSecret: "secret",
+        });
+        mock = new MockAdapter(topia.axios);
+        Asset = new AssetFactory(topia);
+        testAsset = Asset.create("test");
+    }));
+    afterEach(() => {
+        mock.restore();
+        jest.resetAllMocks();
+    });
+    it("should return an array of assets owned by specific email address", () => __awaiter(void 0, void 0, void 0, function* () {
+        mock.onGet(`https://${apiDomain}/api/assets/topia-assets`).reply(200);
+        yield testAsset.fetchPlatformAssets();
+        expect(mock.history.get.length).toBe(1);
+    }));
+});

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

@@ -0,0 +1,97 @@
+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 { droppedAssets } from "__mocks__";
+import { Topia } from "controllers";
+import { DroppedAssetClickType, DroppedAssetMediaType } from "types";
+import MockAdapter from "axios-mock-adapter";
+import { DroppedAssetFactory } from "factories";
+const apiDomain = "api.topia.io";
+const attributes = droppedAssets[0];
+const BASE_URL = `https://api.topia.io/api/world/exampleWorld/assets/${droppedAssets[0].id}`;
+const id = droppedAssets[0].id;
+describe("DroppedAsset Class", () => {
+    let DroppedAsset, mock, testDroppedAsset, topia;
+    beforeEach(() => __awaiter(void 0, void 0, void 0, function* () {
+        topia = new Topia({
+            apiDomain,
+            apiKey: "key",
+        });
+        mock = new MockAdapter(topia.axios);
+        DroppedAsset = new DroppedAssetFactory(topia);
+        testDroppedAsset = yield DroppedAsset.create(id, "exampleWorld");
+    }));
+    afterEach(() => {
+        mock.restore();
+        jest.resetAllMocks();
+    });
+    it("should fetch dropped asset by id", () => __awaiter(void 0, void 0, void 0, function* () {
+        mock.onGet(BASE_URL).reply(200, droppedAssets[0]);
+        yield testDroppedAsset.fetchDroppedAssetById();
+        expect(mock.history.get.length).toBe(1);
+        expect(testDroppedAsset.urlSlug).toBeDefined();
+    }));
+    it("should update dropped asset broadcast zone", () => __awaiter(void 0, void 0, void 0, function* () {
+        mock.onPut(`${BASE_URL}/set-asset-broadcast`).reply(200);
+        const broadcastArgs = Object.assign(Object.assign({}, attributes), { assetBroadcast: true, assetBroadcastAll: false, broadcasterEmail: "test@test.com" });
+        yield testDroppedAsset.updateBroadcast(broadcastArgs);
+        expect(mock.history.put.length).toBe(1);
+    }));
+    it("should update dropped asset click type", () => __awaiter(void 0, void 0, void 0, function* () {
+        mock.onPut(`${BASE_URL}/change-click-type`).reply(200);
+        const clickTypeArgs = Object.assign(Object.assign({}, attributes), { clickType: DroppedAssetClickType.LINK, clickableLink: "www.test.com", clickableLinkTitle: "Test", portalName: "Test", position: {
+                x: 0,
+                y: 0,
+            } });
+        yield testDroppedAsset.updateClickType(clickTypeArgs);
+        expect(mock.history.put.length).toBe(1);
+    }));
+    it("should update dropped asset custom text", () => __awaiter(void 0, void 0, void 0, function* () {
+        mock.onPut(`${BASE_URL}/set-custom-text`).reply(200);
+        yield testDroppedAsset.updateCustomTextAsset({ textColor: "#abc123" }, "hello world");
+        expect(mock.history.put.length).toBe(1);
+    }));
+    it("should update dropped asset media type", () => __awaiter(void 0, void 0, void 0, function* () {
+        mock.onPut(`${BASE_URL}/change-media-type`).reply(200);
+        const mediaTypeArgs = Object.assign(Object.assign({}, attributes), { audioRadius: 0, audioVolume: -1, isVideo: true, mediaLink: "https://www.youtube.com/watch?v=dQw4w9WgXcQ", mediaName: "string", mediaType: DroppedAssetMediaType.LINK, portalName: "community", syncUserMedia: true });
+        yield testDroppedAsset.updateMediaType(mediaTypeArgs);
+        expect(mock.history.put.length).toBe(1);
+    }));
+    it("should update dropped asset mute zone", () => __awaiter(void 0, void 0, void 0, function* () {
+        mock.onPut(`${BASE_URL}/set-mute-zone`).reply(200);
+        yield testDroppedAsset.updateMuteZone(true);
+        expect(mock.history.put.length).toBe(1);
+    }));
+    it("should update dropped asset position", () => __awaiter(void 0, void 0, void 0, function* () {
+        mock.onPut(`${BASE_URL}/set-position`).reply(200);
+        yield testDroppedAsset.updatePosition(100, 100);
+        expect(mock.history.put.length).toBe(1);
+    }));
+    it("should update dropped asset private zone", () => __awaiter(void 0, void 0, void 0, function* () {
+        mock.onPut(`${BASE_URL}/set-private-zone`).reply(200);
+        const privateZoneArgs = Object.assign(Object.assign({}, attributes), { isPrivateZone: true, isPrivateZoneChatDisabled: false, privateZoneUserCap: 10 });
+        yield testDroppedAsset.updatePrivateZone(privateZoneArgs);
+        expect(mock.history.put.length).toBe(1);
+    }));
+    it("should update dropped asset scale", () => __awaiter(void 0, void 0, void 0, function* () {
+        mock.onPut(`${BASE_URL}/change-scale`).reply(200);
+        yield testDroppedAsset.updateScale(75);
+        expect(mock.history.put.length).toBe(1);
+    }));
+    it("should update dropped asset uploaded media selected", () => __awaiter(void 0, void 0, void 0, function* () {
+        mock.onPut(`${BASE_URL}/change-uploaded-media-selected`).reply(200);
+        yield testDroppedAsset.updateUploadedMediaSelected("abc123");
+        expect(mock.history.put.length).toBe(1);
+    }));
+    it("should update dropped asset web image layers", () => __awaiter(void 0, void 0, void 0, function* () {
+        mock.onPut(`${BASE_URL}/set-webimage-layers`).reply(200);
+        yield testDroppedAsset.updateWebImageLayers("test", "test");
+        expect(mock.history.put.length).toBe(1);
+    }));
+});

package/dist/src/controllers/__tests__/user.test.js

@@ -0,0 +1,49 @@
+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 MockAdapter from "axios-mock-adapter";
+import { droppedAssets, scenes, worlds } from "__mocks__";
+import { Topia } from "controllers";
+import { UserFactory } from "factories";
+const apiDomain = "api.topia.io";
+const email = "test@email.com";
+describe("User Class", () => {
+    let mock, testUser, topia, User;
+    beforeEach(() => {
+        topia = new Topia({
+            apiDomain,
+            apiKey: "key",
+        });
+        mock = new MockAdapter(topia.axios);
+        User = new UserFactory(topia);
+        testUser = User.create(email);
+    });
+    afterEach(() => {
+        mock.restore();
+        jest.resetAllMocks();
+    });
+    it("should update user.worlds", () => __awaiter(void 0, void 0, void 0, function* () {
+        mock.onGet(`https://${apiDomain}/api/user/worlds`).reply(200, worlds);
+        yield testUser.fetchWorldsByKey();
+        expect(mock.history.get.length).toBe(1);
+        expect(Object.keys(testUser.worlds).length).toBe(Object.keys(worlds).length);
+    }));
+    it("should return an array of scenes owned by specific email address", () => __awaiter(void 0, void 0, void 0, function* () {
+        testUser.fetchScenesByEmail = jest.fn().mockReturnValue(scenes);
+        const mockScenes = yield testUser.fetchScenesByEmail();
+        expect(testUser.fetchScenesByEmail).toHaveBeenCalled();
+        expect(mockScenes).toBeDefined();
+    }));
+    it("should return an array of assets owned by specific email address", () => __awaiter(void 0, void 0, void 0, function* () {
+        testUser.fetchAssetsByEmail = jest.fn().mockReturnValue(droppedAssets);
+        const mockAssets = yield testUser.fetchAssetsByEmail("lina@topia.io");
+        expect(testUser.fetchAssetsByEmail).toHaveBeenCalled();
+        expect(mockAssets).toBeDefined();
+    }));
+});

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

@@ -0,0 +1,40 @@
+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 MockAdapter from "axios-mock-adapter";
+import { visitors } from "../../__mocks__";
+import { Topia } from "controllers";
+import { VisitorFactory } from "factories";
+const apiDomain = "api.topia.io";
+const id = visitors["1"].playerId;
+describe("Visitor Class", () => {
+    let mock, testVisitor, topia, Visitor;
+    beforeEach(() => {
+        topia = new Topia({
+            apiDomain,
+            apiKey: "key",
+        });
+        mock = new MockAdapter(topia.axios);
+        Visitor = new VisitorFactory(topia);
+        testVisitor = Visitor.create(id, "exampleWorld");
+    });
+    afterEach(() => {
+        mock.restore();
+        jest.resetAllMocks();
+    });
+    it("should move a list of visitors to uniquely specified coordinates", () => __awaiter(void 0, void 0, void 0, function* () {
+        mock.onPut(`https://${apiDomain}/api/world/exampleWorld/visitors/${id}/move`).reply(200);
+        yield testVisitor.moveVisitor({
+            shouldTeleportVisitor: true,
+            x: 100,
+            y: 100,
+        });
+        expect(mock.history.put.length).toBe(1);
+    }));
+});

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

@@ -0,0 +1,80 @@
+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 MockAdapter from "axios-mock-adapter";
+import { visitors, worlds } from "../../__mocks__";
+import { Visitor, Topia } from "controllers";
+import { WorldFactory } from "factories";
+const BASE_URL = "https://api.topia.io/api/world/exampleWorld";
+const urlSlug = worlds[1].urlSlug;
+describe("World Class", () => {
+    let mock, testWorld, topia, World;
+    beforeEach(() => {
+        topia = new Topia({
+            apiDomain: "api.topia.io",
+            apiKey: "key",
+        });
+        mock = new MockAdapter(topia.axios);
+        World = new WorldFactory(topia);
+        testWorld = World.create(urlSlug);
+    });
+    afterEach(() => {
+        mock.restore();
+        jest.resetAllMocks();
+    });
+    it("should return details of a world", () => __awaiter(void 0, void 0, void 0, function* () {
+        expect(testWorld.urlSlug).toEqual("exampleWorld");
+        testWorld.fetchDetails = jest.fn().mockReturnValue(worlds[1]);
+        const mockDetails = yield testWorld.fetchDetails();
+        expect(testWorld.fetchDetails).toHaveBeenCalled();
+        expect(mockDetails).toBeDefined();
+    }));
+    // it("should update details of a world", async () => {
+    //   mock.onPut(`${BASE_URL}/world-details`).reply(200);
+    //   const worldArgs = {
+    //     controls: {
+    //       allowMuteAll: false,
+    //     },
+    //     description: "testing update details",
+    //     name: "exampleWorld",
+    //   };
+    //   await testWorld.updateDetails(worldArgs);
+    //   expect(mock.history.put.length).toBe(1);
+    //   expect(testWorld.urlSlug).toEqual("exampleWorld");
+    // });
+    it("should move all visitors within a world to a single set of coordinates", () => __awaiter(void 0, void 0, void 0, function* () {
+        mock.onGet(`${BASE_URL}/visitors`).reply(200, visitors);
+        mock.onPut(`${BASE_URL}/visitors/1/move`).reply(200);
+        const attributes = {
+            shouldFetchVisitors: true,
+            shouldTeleportVisitors: true,
+            scatterVisitorsBy: 100,
+            x: 20,
+            y: 40,
+        };
+        yield testWorld.moveAllVisitors(attributes);
+        expect(mock.history.put.length).toBe(Object.keys(visitors).length);
+    }));
+    it("should return success if world doesn't have visitors", () => __awaiter(void 0, void 0, void 0, function* () {
+        const attributes = { shouldFetchVisitors: false, scatterVisitorsBy: 100, x: 20, y: 40 };
+        yield testWorld.moveAllVisitors(attributes);
+        expect(mock.history.put.length).toBe(0);
+    }));
+    it("should move a list of visitors to uniquely specified coordinates", () => __awaiter(void 0, void 0, void 0, function* () {
+        mock.onPut(`${BASE_URL}/visitors/1/move`).reply(200);
+        const v1 = new Visitor(topia, visitors["1"].playerId, urlSlug, { attributes: visitors["1"] });
+        const v2 = new Visitor(topia, visitors["2"].playerId, urlSlug, { attributes: visitors["2"] });
+        const testVisitors = [
+            { visitorObj: v1, shouldTeleportVisitor: true, x: 0, y: 0 },
+            { visitorObj: v2, shouldTeleportVisitor: false, x: 100, y: 100 },
+        ];
+        yield testWorld.moveVisitors(testVisitors);
+        expect(mock.history.put.length).toBe(2);
+    }));
+});

package/dist/src/controllers/index.js

@@ -0,0 +1,7 @@
+export { Asset } from "./Asset";
+export { DroppedAsset } from "./DroppedAsset";
+export { SDKController } from "./SDKController";
+export { User } from "./User";
+export { Visitor } from "./Visitor";
+export { World } from "./World";
+export { Topia } from "./Topia";

package/dist/src/factories/AssetFactory.js

@@ -0,0 +1,11 @@
+import { Asset } from "controllers";
+export class AssetFactory {
+    constructor(topia) {
+        this.topia = topia;
+        this.create;
+    }
+    create(id, options) {
+        return new Asset(this.topia, id, options);
+    }
+}
+export default AssetFactory;

package/dist/src/factories/DroppedAssetFactory.js

@@ -0,0 +1,26 @@
+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 { DroppedAsset } from "controllers";
+export class DroppedAssetFactory {
+    constructor(topia) {
+        this.topia = topia;
+    }
+    create(id, urlSlug, options) {
+        return new DroppedAsset(this.topia, id, urlSlug, options);
+    }
+    get(id, urlSlug, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const droppedAsset = new DroppedAsset(this.topia, id, urlSlug, options);
+            yield droppedAsset.fetchDroppedAssetById();
+            return droppedAsset;
+        });
+    }
+}
+export default DroppedAssetFactory;