@rtsdk/topia 0.0.11 → 0.0.13

package/dist/src/controllers/DroppedAsset.js

@@ -0,0 +1,399 @@
+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 __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 _DroppedAsset_updateDroppedAsset;
+// controllers
+import { Asset } from "controllers/Asset";
+// utils
+import { getErrorResponse } from "utils";
+/**
+ * Create an instance of Dropped Asset class with a given dropped asset id, url slug, and optional attributes and session credentials.
+ *
+ * ```ts
+ * await new DroppedAsset(topia, "1giFZb0sQ3X27L7uGyQX", "example", { attributes: { text: "" }, credentials: { assetId: "1giFZb0sQ3X27L7uGyQX" } } });
+ * ```
+ */
+export class DroppedAsset extends Asset {
+    constructor(topia, id, urlSlug, options = { attributes: { text: "" }, credentials: {} }) {
+        var _a;
+        super(topia, id, options);
+        // update dropped assets
+        _DroppedAsset_updateDroppedAsset.set(this, (payload, updateType) => __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield this.topia.axios.put(`/world/${this.urlSlug}/assets/${this.id}/${updateType}`, Object.assign({}, payload), this.requestOptions);
+            }
+            catch (error) {
+                throw getErrorResponse({ error });
+            }
+        }));
+        this.id = id;
+        this.text = (_a = options.attributes) === null || _a === void 0 ? void 0 : _a.text;
+        this.urlSlug = urlSlug;
+        Object.assign(this, options.attributes);
+    }
+    /**
+     * @summary
+     * Retrieves dropped asset details.
+     *
+     * @usage
+     * ```ts
+     * await droppedAsset.fetchDroppedAssetById();
+     * const { assetName } = droppedAsset;
+     * ```
+     */
+    fetchDroppedAssetById() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const response = yield this.topia.axios.get(`/world/${this.urlSlug}/assets/${this.id}`, this.requestOptions);
+                Object.assign(this, response.data);
+            }
+            catch (error) {
+                throw getErrorResponse({ error });
+            }
+        });
+    }
+    // delete dropped asset
+    deleteDroppedAsset() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield this.topia.axios.delete(`/world/${this.urlSlug}/assets/${this.id}`, this.requestOptions);
+            }
+            catch (error) {
+                throw getErrorResponse({ error });
+            }
+        });
+    }
+    /**
+     * @summary
+     * Retrieves the data object for a dropped asset.
+     *
+     * @usage
+     * ```ts
+     * await droppedAsset.fetchDroppedAssetDataObject();
+     * const { dataObject } = droppedAsset;
+     * ```
+     */
+    // get dropped asset
+    fetchDroppedAssetDataObject() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const response = yield this.topia.axios.get(`/world/${this.urlSlug}/assets/${this.id}/data-object`, this.requestOptions);
+                this.dataObject = response.data;
+            }
+            catch (error) {
+                throw getErrorResponse({ error });
+            }
+        });
+    }
+    /**
+     * @summary
+     * Setss the data object for a dropped asset.
+     *
+     * Optionally, a lock can be provided with this request to ensure only one update happens at a time between all updates that share the same lock id
+     *
+     * @usage
+     * ```ts
+     * await droppedAsset.setDroppedAssetDataObject({
+     *   "exampleKey": "exampleValue",
+     * });
+     * const { dataObject } = droppedAsset;
+     * ```
+     */
+    // get dropped asset
+    setDroppedAssetDataObject(dataObject, options = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const { lock = {} } = options;
+                yield this.topia.axios.put(`/world/${this.urlSlug}/assets/${this.id}/set-data-object`, { dataObject, lock }, this.requestOptions);
+                this.dataObject = dataObject;
+            }
+            catch (error) {
+                throw getErrorResponse({ error });
+            }
+        });
+    }
+    /**
+     * @summary
+     * Updates the data object for a dropped asset.
+     *
+     * Optionally, a lock can be provided with this request to ensure only one update happens at a time between all updates that share the same lock id
+     *
+     * @usage
+     * ```ts
+     * await droppedAsset.updateDroppedAssetDataObject({
+     *   "exampleKey": "exampleValue",
+     * });
+     * const { dataObject } = droppedAsset;
+     * ```
+     */
+    // get dropped asset
+    updateDroppedAssetDataObject(dataObject, options = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const { lock = {} } = options;
+                yield this.topia.axios.put(`/world/${this.urlSlug}/assets/${this.id}/update-data-object`, { dataObject, lock }, this.requestOptions);
+                this.dataObject = dataObject;
+            }
+            catch (error) {
+                throw getErrorResponse({ error });
+            }
+        });
+    }
+    /**
+     * @summary
+     * Updates broadcast options for a dropped asset.
+     *
+     * @usage
+     * ```ts
+     * await droppedAsset.updateBroadcast({
+     *   assetBroadcast: true,
+     *   assetBroadcastAll: true,
+     *   broadcasterEmail: "example@email.com"
+     * });
+     * ```
+     */
+    updateBroadcast({ assetBroadcast, assetBroadcastAll, broadcasterEmail, }) {
+        try {
+            return __classPrivateFieldGet(this, _DroppedAsset_updateDroppedAsset, "f").call(this, { assetBroadcast, assetBroadcastAll, broadcasterEmail }, "set-asset-broadcast");
+        }
+        catch (error) {
+            throw getErrorResponse({ error });
+        }
+    }
+    /**
+     * @summary
+     * Updates click options for a dropped asset.
+     *
+     * @usage
+     * ```ts
+     * await droppedAsset.updateClickType({
+     *   "clickType": "portal",
+     *   "clickableLink": "https://topia.io",
+     *   "clickableLinkTitle": "My awesome link!",
+     *   "position": {
+     *     "x": 0,
+     *     "y": 0
+     *   },
+     *   "portalName": "community"
+     * });
+     * ```
+     */
+    updateClickType({ clickType, clickableLink, clickableLinkTitle, portalName, position, }) {
+        try {
+            return __classPrivateFieldGet(this, _DroppedAsset_updateDroppedAsset, "f").call(this, { clickType, clickableLink, clickableLinkTitle, portalName, position }, "change-click-type");
+        }
+        catch (error) {
+            throw getErrorResponse({ error });
+        }
+    }
+    /**
+     * @summary
+     * Updates text and style of a dropped asset.
+     *
+     * @usage
+     * ```ts
+     * const style = {
+     *   "textColor": "#abc123",
+     *   "textFontFamily": "Arial",
+     *   "textSize": 40,
+     *   "textWeight": "normal",
+     *   "textWidth": 200
+     * };
+     * await droppedAsset.updateCustomTextAsset(style, "hello world");
+     * ```
+     */
+    updateCustomTextAsset(style, text) {
+        try {
+            return __classPrivateFieldGet(this, _DroppedAsset_updateDroppedAsset, "f").call(this, { style, text }, "set-custom-text");
+        }
+        catch (error) {
+            throw getErrorResponse({ error });
+        }
+    }
+    /**
+     * @summary
+     * Updates media options for a dropped asset.
+     *
+     * @usage
+     * ```ts
+     * await droppedAsset.updateMediaType({
+     *   "mediaType": "link",
+     *   "mediaLink": "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
+     *   "isVideo": true,
+     *   "syncUserMedia": true,
+     *   "audioVolume": -1,
+     *   "portalName": "community",
+     *   "audioRadius": 0,
+     *   "mediaName": "string"
+     * });
+     * ```
+     */
+    updateMediaType({ audioRadius, audioVolume, isVideo, mediaLink, mediaName, mediaType, portalName, syncUserMedia, }) {
+        try {
+            return __classPrivateFieldGet(this, _DroppedAsset_updateDroppedAsset, "f").call(this, { audioRadius, audioVolume, isVideo, mediaLink, mediaName, mediaType, portalName, syncUserMedia }, "change-media-type");
+        }
+        catch (error) {
+            throw getErrorResponse({ error });
+        }
+    }
+    /**
+     * @summary
+     * Updates mute zone options for a dropped asset.
+     *
+     * @usage
+     * ```ts
+     * await droppedAsset.updateMuteZone(true);
+     * ```
+     */
+    updateMuteZone(isMutezone) {
+        try {
+            return __classPrivateFieldGet(this, _DroppedAsset_updateDroppedAsset, "f").call(this, { isMutezone }, "set-mute-zone");
+        }
+        catch (error) {
+            throw getErrorResponse({ error });
+        }
+    }
+    /**
+     * @summary
+     * Moves a dropped asset to specified coordinates.
+     *
+     * @usage
+     * ```ts
+     * await droppedAsset.updatePosition(100,200);
+     * ```
+     */
+    updatePosition(x, y) {
+        try {
+            return __classPrivateFieldGet(this, _DroppedAsset_updateDroppedAsset, "f").call(this, { x, y }, "set-position");
+        }
+        catch (error) {
+            throw getErrorResponse({ error });
+        }
+    }
+    /**
+     * @summary
+     * Updates private zone options for a dropped asset.
+     *
+     * @usage
+     * ```ts
+     * await droppedAsset.updateMuteZone({
+     *   "isPrivateZone": false,
+     *   "isPrivateZoneChatDisabled": true,
+     *   "privateZoneUserCap": 10
+     * });
+     * ```
+     */
+    updatePrivateZone({ isPrivateZone, isPrivateZoneChatDisabled, privateZoneUserCap, }) {
+        try {
+            return __classPrivateFieldGet(this, _DroppedAsset_updateDroppedAsset, "f").call(this, { isPrivateZone, isPrivateZoneChatDisabled, privateZoneUserCap }, "set-private-zone");
+        }
+        catch (error) {
+            throw getErrorResponse({ error });
+        }
+    }
+    /**
+     * @summary
+     * Updates the size of a dropped asset.
+     *
+     * @usage
+     * ```ts
+     * await droppedAsset.assetScale(.5);
+     * ```
+     */
+    updateScale(assetScale) {
+        try {
+            return __classPrivateFieldGet(this, _DroppedAsset_updateDroppedAsset, "f").call(this, { assetScale }, "change-scale");
+        }
+        catch (error) {
+            throw getErrorResponse({ error });
+        }
+    }
+    /**
+     * @summary
+     * Change or remove media embedded in a dropped asset.
+     *
+     * @usage
+     * ```ts
+     * await droppedAsset.updateUploadedMediaSelected("LVWyxwNxI96eLjnXWwYO");
+     * ```
+     */
+    updateUploadedMediaSelected(mediaId) {
+        try {
+            return __classPrivateFieldGet(this, _DroppedAsset_updateDroppedAsset, "f").call(this, { mediaId }, "change-uploaded-media-selected");
+        }
+        catch (error) {
+            throw getErrorResponse({ error });
+        }
+    }
+    /**
+     * @summary
+     * Change or remove top and bottom layers of a dropped asset.
+     *
+     * @usage
+     * ```ts
+     * await droppedAsset.updateWebImageLayers("","https://www.shutterstock.com/image-vector/colorful-illustration-test-word-260nw-1438324490.jpg");
+     * ```
+     */
+    updateWebImageLayers(bottom, top) {
+        try {
+            return __classPrivateFieldGet(this, _DroppedAsset_updateDroppedAsset, "f").call(this, { bottom, top }, "set-webimage-layers");
+        }
+        catch (error) {
+            throw getErrorResponse({ error });
+        }
+    }
+    /**
+     * @summary
+     * Add a webhook to a dropped asset
+     *
+     * @usage
+     * ```ts
+     * await droppedAsset.addWebhook({
+     *   active: true,
+     *   assetId: "id",
+     *   dataObject: {},
+     *   description: "Webhook desc",
+     *   enteredBy: "you",
+     *   isUniqueOnly: false,
+     *   title: "title",
+     *   type: "type",
+     *   url: "https://url.com",
+     *   urlSlug: "world",
+     * });
+     * ```
+     */
+    addWebhook({ assetId, dataObject, description, isUniqueOnly, title, type, url, }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield this.topia.axios.post(`/world/${this.urlSlug}/webhooks`, {
+                    active: true,
+                    assetId,
+                    dataObject,
+                    description,
+                    enteredBy: "",
+                    isUniqueOnly,
+                    title,
+                    type,
+                    url,
+                    urlSlug: this.urlSlug,
+                }, this.requestOptions);
+            }
+            catch (error) {
+                throw getErrorResponse({ error });
+            }
+        });
+    }
+}
+_DroppedAsset_updateDroppedAsset = new WeakMap();
+export default DroppedAsset;

package/dist/src/controllers/SDKController.js

@@ -0,0 +1,43 @@
+// utils
+import jwt from "jsonwebtoken";
+/**
+ * Create an instance of SDKController class with credentials.
+ *
+ * ```ts
+ * const credentials = {
+ *   assetId: "exampleAsset",
+ *   interactiveNonce: "exampleNonce"
+ *   interactivePublicKey: "examplePublicKey",
+ *   playerId: 1,
+ *   url: "https://topia.io",
+ * }
+ * const topia = await new Topia({
+ *   apiDomain: "api.topia.io",
+ *   apiKey: "exampleKey",
+ *   interactiveKey: "key",
+ *   interactiveSecret: "secret",
+ * }
+ * await new SDKController({ credentials, topia });
+ * ```
+ */
+export class SDKController {
+    constructor(topia, credentials = {}) {
+        this.credentials = credentials;
+        this.topia = topia;
+        const { assetId, interactiveNonce, visitorId } = credentials;
+        let payload = {};
+        if (visitorId && assetId && interactiveNonce) {
+            payload = {
+                interactiveNonce,
+                visitorId,
+                assetId,
+            };
+            this.jwt = jwt.sign(payload, topia.interactiveSecret);
+            this.requestOptions = { headers: { Interactivejwt: this.jwt } };
+        }
+        else {
+            this.requestOptions = {};
+        }
+    }
+}
+export default SDKController;

package/dist/src/controllers/Topia.js

@@ -0,0 +1,36 @@
+import axios from "axios";
+// utils
+import { getBrowserWarning } from "utils";
+/**
+ * Create a single instance of Topia axios used for all calls to the public API in all classes
+ *
+ * ```ts
+ * const topia = await new Topia({
+ *   apiDomain: "api.topia.io",
+ *   apiKey: "exampleKey",
+ *   interactiveKey: "key",
+ *   interactiveSecret: "secret",
+ * });
+ * ```
+ */
+export class Topia {
+    constructor({ apiKey, apiDomain, interactiveKey, interactiveSecret, }) {
+        getBrowserWarning();
+        this.apiKey = apiKey;
+        this.apiDomain = apiDomain || "api.topia.io";
+        this.interactiveSecret = interactiveSecret;
+        const headers = {
+            "Content-Type": "application/json",
+            "Accept-Encoding": "",
+        };
+        if (apiKey)
+            headers.Authorization = apiKey;
+        if (interactiveKey)
+            headers.Publickey = interactiveKey;
+        this.axios = axios.create({
+            baseURL: `https://${this.apiDomain}/api`,
+            headers,
+        });
+    }
+}
+export default Topia;

package/dist/src/controllers/User.js

@@ -0,0 +1,113 @@
+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 _User_worldsMap;
+// controllers
+import { SDKController } from "controllers/SDKController";
+import { World } from "controllers/World";
+// utils
+import { getErrorResponse } from "utils";
+/**
+ * Create an instance of User class with email and optional session credentials.
+ *
+ * ```ts
+ * await new User(topia, "example@email.io", { interactiveNonce: "exampleNonce", interactivePublicKey: "examplePublicKey", playerId: 1 });
+ * ```
+ */
+export class User extends SDKController {
+    constructor(topia, email, options = { credentials: {} }) {
+        super(topia, options.credentials);
+        _User_worldsMap.set(this, void 0);
+        __classPrivateFieldSet(this, _User_worldsMap, {}, "f");
+        this.email = email;
+    }
+    get worlds() {
+        return __classPrivateFieldGet(this, _User_worldsMap, "f");
+    }
+    /**
+     * @summary
+     * Returns all assets owned by User when an email address is provided.
+     */
+    fetchAssetsByEmail(ownerEmail) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const response = yield this.topia.axios.get(`/assets/my-assets?email=${ownerEmail}`, this.requestOptions);
+                return response.data;
+            }
+            catch (error) {
+                throw getErrorResponse({ error });
+            }
+        });
+    }
+    /**
+     * @summary
+     * Returns all scenes owned by User when an email address is provided.
+     */
+    fetchScenesByEmail() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (!this.email)
+                    throw getErrorResponse({ message: "There is no email associated with this user." });
+                const response = yield this.topia.axios.get(`/scenes/my-scenes?email=${this.email}`, this.requestOptions);
+                return response.data;
+            }
+            catch (error) {
+                throw getErrorResponse({ error });
+            }
+        });
+    }
+    /**
+     * @summary
+     * Retrieves all worlds owned by user with matching API Key,
+     * creates a new World object for each,
+     * and creates new map of Worlds accessible via user.worlds.
+     *
+     * @usage
+     * ```ts
+     * await user.fetchWorldsByKey();
+     * const userWorlds = user.worlds;
+     * ```
+     *
+     * @result
+     * ```ts
+     * { urlSlug: new World({ apiKey, worldArgs, urlSlug }) }
+     * ```
+     */
+    fetchWorldsByKey() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const response = yield this.topia.axios.get("/user/worlds", this.requestOptions);
+                const tempWorldsMap = {};
+                for (const i in response.data) {
+                    const worldDetails = response.data[i];
+                    tempWorldsMap[worldDetails.urlSlug] = new World(this.topia, worldDetails.urlSlug, {
+                        attributes: worldDetails,
+                    });
+                }
+                __classPrivateFieldSet(this, _User_worldsMap, tempWorldsMap, "f");
+            }
+            catch (error) {
+                throw getErrorResponse({ error });
+            }
+        });
+    }
+}
+_User_worldsMap = new WeakMap();
+export default User;

package/dist/src/controllers/Visitor.js

@@ -0,0 +1,62 @@
+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());
+    });
+};
+// controllers
+import { SDKController } from "controllers/SDKController";
+// utils
+import { getErrorResponse } from "utils";
+/**
+ * Create an instance of Visitor class with a given id and optional attributes and session credentials.
+ *
+ * ```ts
+ * await new Visitor(topia, id, urlSlug, { attributes: { moveTo: { x: 0, y: 0 } } });
+ * ```
+ */
+export class Visitor extends SDKController {
+    constructor(topia, id, urlSlug, options = { attributes: {}, credentials: {} }) {
+        super(topia, options.credentials);
+        Object.assign(this, options.attributes);
+        this.id = id;
+        this.urlSlug = urlSlug;
+        this.moveVisitor;
+    }
+    /**
+     * @summary
+     * Teleport or walk a visitor currently in a world to a single set of coordinates.
+     *
+     * @usage
+     * ```ts
+     * await visitor.moveVisitor({
+     *   shouldTeleportVisitor: true,
+     *   x: 100,
+     *   y: 100,
+     * });
+     * ```
+     *
+     * @result
+     * Updates each Visitor instance and world.visitors map.
+     */
+    moveVisitor({ shouldTeleportVisitor, x, y }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield this.topia.axios.put(`/world/${this.urlSlug}/visitors/${this.id}/move`, {
+                    moveTo: {
+                        x,
+                        y,
+                    },
+                    teleport: shouldTeleportVisitor,
+                }, this.requestOptions);
+            }
+            catch (error) {
+                throw getErrorResponse({ error });
+            }
+        });
+    }
+}
+export default Visitor;