@rtsdk/topia 0.1.0 → 0.1.1

package/dist/types/src/controllers/SDKController.d.ts

@@ -0,0 +1,48 @@
+import { Topia } from "controllers/Topia";
+import { SDKInterface } from "interfaces";
+import { InteractiveCredentials } from "types";
+import { AxiosError } from "axios";
+/**
+ * @summary
+ * Create an instance of SDKController class with credentials.
+ *
+ * @usage
+ * ```ts
+ * const credentials = {
+ *   assetId: "exampleAsset",
+ *   interactiveNonce: "exampleNonce"
+ *   interactivePublicKey: "examplePublicKey",
+ *   visitorId: 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 declare class SDKController implements SDKInterface {
+    credentials: InteractiveCredentials | undefined;
+    jwt?: string;
+    requestOptions: object;
+    topia: Topia;
+    constructor(topia: Topia, credentials?: InteractiveCredentials);
+    topiaPublicApi(): import("axios").AxiosInstance;
+    errorHandler({ error, message, }: {
+        error?: Error | AxiosError | unknown;
+        message?: string;
+    }): {
+        data: {};
+        message: string;
+        method: string;
+        stack: string;
+        stackTrace: Error;
+        status: number;
+        success: boolean;
+        url: string;
+    };
+}
+export default SDKController;

package/dist/types/src/controllers/Scene.d.ts

@@ -0,0 +1,19 @@
+import { SDKController } from "controllers/SDKController";
+import { Topia } from "controllers/Topia";
+import { SceneInterface, SceneOptionalInterface } from "interfaces";
+import { ResponseType } from "types";
+/**
+ * @summary
+ * Create an instance of Scene class with a given scene id and optional attributes and session credentials.
+ *
+ * @usage
+ * ```ts
+ * await new Scene(topia, "sceneId", { attributes: { name: "My Scene" } });
+ * ```
+ */
+export declare class Scene extends SDKController implements SceneInterface {
+    readonly id: string;
+    constructor(topia: Topia, id: string, options?: SceneOptionalInterface);
+    fetchSceneById(): Promise<void | ResponseType>;
+}
+export default Scene;

package/dist/types/src/controllers/Topia.d.ts

@@ -0,0 +1,33 @@
+import { AxiosInstance } from "axios";
+import { TopiaInterface } from "interfaces";
+import jwt from "jsonwebtoken";
+/**
+ * @summary
+ * Create a single instance of Topia axios used for all calls to the public API in all classes
+ *
+ * @usage
+ * ```ts
+ * const topia = await new Topia({
+ *   apiDomain: "api.topia.io",
+ *   apiKey: "exampleKey",
+ *   interactiveKey: "key",
+ *   interactiveSecret: "secret",
+ * });
+ * ```
+ */
+export declare class Topia implements TopiaInterface {
+    axios: AxiosInstance;
+    apiDomain?: string;
+    apiKey?: string;
+    apiProtocol?: string;
+    interactiveKey?: string;
+    interactiveSecret?: jwt.Secret;
+    constructor({ apiDomain, apiKey, apiProtocol, interactiveKey, interactiveSecret, }: {
+        apiDomain?: string;
+        apiKey?: string;
+        apiProtocol?: string;
+        interactiveKey?: string;
+        interactiveSecret?: jwt.Secret;
+    });
+}
+export default Topia;

package/dist/types/src/controllers/User.d.ts

@@ -0,0 +1,58 @@
+import { Asset } from "controllers/Asset";
+import { Scene } from "controllers/Scene";
+import { SDKController } from "controllers/SDKController";
+import { Topia } from "controllers/Topia";
+import { World } from "controllers/World";
+import { UserOptionalInterface } from "interfaces";
+import { ResponseType } from "types";
+/**
+ * @summary
+ * Create an instance of User class with optional session credentials.
+ *
+ * @usage
+ * ```ts
+ * await new User(topia, { interactiveNonce: "exampleNonce", interactivePublicKey: "examplePublicKey", visitorId: 1 });
+ * ```
+ */
+export declare class User extends SDKController {
+    #private;
+    constructor(topia: Topia, options?: UserOptionalInterface);
+    get assets(): {
+        [key: string]: Asset;
+    };
+    get scenes(): {
+        [key: string]: Scene;
+    };
+    get worlds(): {
+        [key: string]: World;
+    };
+    /**
+     * @summary
+     * Returns all assets owned by User when an email address is provided.
+     */
+    fetchAssets(): Promise<void | ResponseType>;
+    /**
+     * @summary
+     * Returns all scenes owned by User
+     */
+    fetchScenes(): Promise<void | ResponseType>;
+    /**
+     * @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(): Promise<void | ResponseType>;
+}
+export default User;

package/dist/types/src/controllers/Visitor.d.ts

@@ -0,0 +1,50 @@
+import { Topia } from "controllers/Topia";
+import { User } from "controllers/User";
+import { MoveVisitorInterface, VisitorInterface, VisitorOptionalInterface } from "interfaces";
+import { ResponseType } from "types";
+/**
+ * @summary
+ * Create an instance of Visitor class with a given id and optional attributes and session credentials.
+ *
+ * @usage
+ * ```ts
+ * await new Visitor(topia, id, urlSlug, { attributes: { moveTo: { x: 0, y: 0 } } });
+ * ```
+ */
+export declare class Visitor extends User implements VisitorInterface {
+    readonly id: number;
+    urlSlug: string;
+    user?: User;
+    constructor(topia: Topia, id: number, urlSlug: string, options?: VisitorOptionalInterface);
+    /**
+     * @summary
+     * Get a single visitor from a world
+     *
+     * @usage
+     * ```ts
+     * await visitor.fetchVisitor();
+     * ```
+     *
+     * @result
+     * Returns details for a visitor in a world by id and urlSlug
+     */
+    fetchVisitor(): Promise<void | ResponseType>;
+    /**
+     * @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 }: MoveVisitorInterface): Promise<void | ResponseType>;
+}
+export default Visitor;

package/dist/types/src/controllers/World.d.ts

@@ -0,0 +1,143 @@
+import { DroppedAsset } from "controllers/DroppedAsset";
+import { SDKController } from "controllers/SDKController";
+import { Topia } from "controllers/Topia";
+import { WorldInterface, WorldOptionalInterface } from "interfaces";
+import { ResponseType } from "types";
+/**
+ * @summary
+ * Create an instance of World class with a given url slug and optional attributes and session credentials.
+ *
+ * @usage
+ * ```ts
+ * await new World(topia, "exampleWorld", { attributes: { name: "Example World" } });
+ * ```
+ */
+export declare class World extends SDKController implements WorldInterface {
+    #private;
+    urlSlug: string;
+    constructor(topia: Topia, urlSlug: string, options?: WorldOptionalInterface);
+    get droppedAssets(): {
+        [key: string]: DroppedAsset;
+    };
+    /**
+     * @summary
+     * Retrieves details of a world.
+     *
+     * @usage
+     * ```ts
+     * await world.fetchDetails();
+     * const { name } = world;
+     * ```
+     */
+    fetchDetails(): Promise<void | ResponseType>;
+    /**
+     * @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, }: WorldInterface): Promise<void | ResponseType>;
+    /**
+     * @summary
+     * Retrieve all assets dropped in a world.
+     *
+     * @usage
+     * ```ts
+     * await world.fetchDroppedAssets();
+     * const assets = world.droppedAssets;
+     * ```
+     */
+    fetchDroppedAssets(): Promise<void | ResponseType>;
+    /**
+     * @summary
+     * Retrieve all assets dropped in a world matching uniqueName.
+     *
+     * @usage
+     * ```ts
+     * await world.fetchDroppedAssets();
+     * const assets = world.droppedAssets;
+     * ```
+     */
+    fetchDroppedAssetsWithUniqueName({ uniqueName, isPartial, isReversed, }: {
+        uniqueName: string;
+        isPartial?: boolean;
+        isReversed?: boolean;
+    }): Promise<DroppedAsset[]>;
+    /**
+     * @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: Array<DroppedAsset>, style: object): Promise<object>;
+    /**
+     * @summary
+     * Drop a scene in a world.
+     *
+     * @usage
+     * ```ts
+     * await world.dropScene({
+     *   "sceneId": "string",
+     *   "position": {
+     *     "x": 0,
+     *     "y": 0
+     *   },
+     *   "assetSuffix": "string"
+     * });
+     * ```
+     */
+    dropScene({ assetSuffix, position, sceneId, }: {
+        assetSuffix: string;
+        position: object;
+        sceneId: string;
+    }): Promise<void | ResponseType>;
+    /**
+     * @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);
+     * ```
+     */
+    replaceScene(sceneId: string): Promise<void | ResponseType>;
+}
+export default World;

package/dist/types/src/controllers/WorldActivity.d.ts

@@ -0,0 +1,83 @@
+import { SDKController } from "controllers/SDKController";
+import { Topia } from "controllers/Topia";
+import { Visitor } from "controllers/Visitor";
+import { MoveAllVisitorsInterface, WorldActivityOptionalInterface } from "interfaces";
+import { ResponseType, VisitorsToMoveArrayType } from "types";
+/**
+ * @summary
+ * Create an instance of WorldActivity class with a given url slug and optional attributes and session credentials.
+ *
+ * This class is responsible for all activity of a specified world including editing dropped assets, moving current visitors, etc.
+ *
+ * @usage
+ * ```ts
+ * await new WorldActivity(topia, "exampleWorld", { attributes: { name: "Example World" } });
+ * ```
+ */
+export declare class WorldActivity extends SDKController {
+    #private;
+    urlSlug: string;
+    constructor(topia: Topia, urlSlug: string, options?: WorldActivityOptionalInterface);
+    get visitors(): {
+        [key: string]: Visitor;
+    };
+    private fetchVisitors;
+    /**
+     * @summary
+     * Retrieve all visitors currently in a world.
+     *
+     * @usage
+     * ```ts
+     * const visitors = await world.currentVisitors();
+     * ```
+     */
+    currentVisitors(): Promise<unknown>;
+    /**
+     * @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, shouldTeleportVisitors, scatterVisitorsBy, x, y, }: MoveAllVisitorsInterface): Promise<(void | ResponseType)[] | undefined>;
+    /**
+     * @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: VisitorsToMoveArrayType): Promise<(void | ResponseType)[]>;
+}
+export default WorldActivity;

package/dist/{src/interfaces/AssetInterfaces.js → types/src/controllers/__tests__/asset.test.d.ts}

@@ -1 +1 @@
-export {};
+export {};

package/dist/{src/interfaces/DroppedAssetInterfaces.js → types/src/controllers/__tests__/droppedAsset.test.d.ts}

@@ -1 +1 @@
-export {};
+export {};

package/dist/{src/interfaces/SDKInterfaces.js → types/src/controllers/__tests__/scene.test.d.ts}

@@ -1 +1 @@
-export {};
+export {};

package/dist/{src/interfaces/SceneInterfaces.js → types/src/controllers/__tests__/user.test.d.ts}

@@ -1 +1 @@
-export {};
+export {};

package/dist/types/src/controllers/__tests__/visitor.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/src/controllers/__tests__/world.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/src/controllers/__tests__/worldActivity.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/{src/controllers/index.js → types/src/controllers/index.d.ts}

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

package/dist/types/src/factories/AssetFactory.d.ts

@@ -0,0 +1,8 @@
+import { Asset, Topia } from "controllers";
+import { AssetOptionalInterface } from "interfaces";
+export declare class AssetFactory {
+    topia: Topia;
+    constructor(topia: Topia);
+    create(id: string, options?: AssetOptionalInterface): Asset;
+}
+export default AssetFactory;

package/dist/types/src/factories/DroppedAssetFactory.d.ts

@@ -0,0 +1,16 @@
+import { DroppedAsset, Topia, Asset, SDKController } from "controllers";
+import { DroppedAssetOptionalInterface } from "interfaces";
+export declare class DroppedAssetFactory extends SDKController {
+    constructor(topia: Topia);
+    create(id: string, urlSlug: string, options?: DroppedAssetOptionalInterface): DroppedAsset;
+    get(id: string, urlSlug: string, options?: DroppedAssetOptionalInterface): Promise<DroppedAsset>;
+    drop(asset: Asset, { position: { x, y }, uniqueName, urlSlug, }: {
+        position: {
+            x: number;
+            y: number;
+        };
+        uniqueName?: string;
+        urlSlug: string;
+    }): Promise<DroppedAsset>;
+}
+export default DroppedAssetFactory;

package/dist/types/src/factories/SceneFactory.d.ts

@@ -0,0 +1,9 @@
+import { Scene, Topia } from "controllers";
+import { SceneOptionalInterface } from "interfaces";
+export declare class SceneFactory {
+    topia: Topia;
+    constructor(topia: Topia);
+    create(id: string, options?: SceneOptionalInterface): Scene;
+    get(id: string, options?: SceneOptionalInterface): Promise<Scene>;
+}
+export default SceneFactory;

package/dist/types/src/factories/UserFactory.d.ts

@@ -0,0 +1,8 @@
+import { Topia, User } from "controllers";
+import { UserOptionalInterface } from "interfaces";
+export declare class UserFactory {
+    topia: Topia;
+    constructor(topia: Topia);
+    create(options?: UserOptionalInterface): User;
+}
+export default UserFactory;

package/dist/types/src/factories/VisitorFactory.d.ts

@@ -0,0 +1,9 @@
+import { Topia, Visitor } from "controllers";
+import { VisitorOptionalInterface } from "interfaces";
+export declare class VisitorFactory {
+    topia: Topia;
+    constructor(topia: Topia);
+    create(id: number, urlSlug: string, options?: VisitorOptionalInterface): Visitor;
+    get(id: number, urlSlug: string, options?: VisitorOptionalInterface): Promise<Visitor>;
+}
+export default VisitorFactory;

package/dist/types/src/factories/WorldActivityFactory.d.ts

@@ -0,0 +1,8 @@
+import { Topia, WorldActivity } from "controllers";
+import { WorldOptionalInterface } from "interfaces";
+export declare class WorldActivityFactory {
+    topia: Topia;
+    constructor(topia: Topia);
+    create(urlSlug: string, options?: WorldOptionalInterface): WorldActivity;
+}
+export default WorldActivityFactory;

package/dist/types/src/factories/WorldFactory.d.ts

@@ -0,0 +1,8 @@
+import { Topia, World } from "controllers";
+import { WorldOptionalInterface } from "interfaces";
+export declare class WorldFactory {
+    topia: Topia;
+    constructor(topia: Topia);
+    create(urlSlug: string, options?: WorldOptionalInterface): World;
+}
+export default WorldFactory;

package/dist/{src/factories/index.js → types/src/factories/index.d.ts}

@@ -1,7 +1,7 @@
-export { AssetFactory } from "./AssetFactory";
-export { DroppedAssetFactory } from "./DroppedAssetFactory";
-export { SceneFactory } from "./SceneFactory";
-export { UserFactory } from "./UserFactory";
-export { VisitorFactory } from "./VisitorFactory";
-export { WorldActivityFactory } from "./WorldActivityFactory";
-export { WorldFactory } from "./WorldFactory";
+export { AssetFactory } from "./AssetFactory";
+export { DroppedAssetFactory } from "./DroppedAssetFactory";
+export { SceneFactory } from "./SceneFactory";
+export { UserFactory } from "./UserFactory";
+export { VisitorFactory } from "./VisitorFactory";
+export { WorldActivityFactory } from "./WorldActivityFactory";
+export { WorldFactory } from "./WorldFactory";

package/dist/types/src/index.d.ts

@@ -0,0 +1,4 @@
+export { Topia } from "controllers";
+export { AssetFactory, DroppedAssetFactory, SceneFactory, UserFactory, VisitorFactory, WorldActivityFactory, WorldFactory, } from "factories";
+export type { AssetOptions, DroppedAssetClickType, DroppedAssetMediaType, DroppedAssetOptions, InteractiveCredentials, ResponseType, UserOptions, VisitorOptions, VisitorType, VisitorsToMoveType, VisitorsToMoveArrayType, WorldOptions, } from "types";
+export * from "interfaces";

package/dist/types/src/interfaces/AssetInterfaces.d.ts

@@ -0,0 +1,26 @@
+import { InteractiveCredentials } from "types";
+import { SDKInterface } from "interfaces/SDKInterfaces";
+export interface AssetInterface extends SDKInterface {
+    fetchPlatformAssets(): Promise<object>;
+    addedOn?: string;
+    assetName?: string;
+    creatorTags?: object;
+    readonly id?: string;
+    isPublic?: boolean;
+    library?: string;
+    originalAssetId?: string;
+    originalKit?: string;
+    ownerId?: string;
+    ownerName?: string;
+    platformAsset?: boolean;
+    purchased?: boolean;
+    purchaseDate?: string;
+    purchasedFrom?: string;
+    specialType?: string | null;
+    transactionId?: string;
+    type?: string;
+}
+export type AssetOptionalInterface = {
+    attributes?: AssetInterface | object;
+    credentials?: InteractiveCredentials | object;
+};