pw-js-api 0.2.1 → 0.2.2-dev.8bac497

package/esm/api/PWApiClient.d.ts

@@ -0,0 +1,182 @@
+import PWGameClient from "../game/PWGameClient.js";
+import type { APIFailure, AuthResultSuccess, CollectionResult, ColPlayer, ColQuery, ColWorld, JoinKeyResult, LobbyResult } from "../types/api.js";
+import type { GameClientSettings, WorldJoinData } from "../types/game.js";
+/**
+ * Note if you want to join a world, use new PWGameClient() then run .init()
+ */
+export default class PWApiClient {
+    /**
+     * The account token, this is private to prevent tampering.
+     */
+    private token?;
+    /**
+     * Account details with email and password, if applicable.
+     */
+    private account;
+    loggedIn: boolean;
+    /**
+     * This will create an instance of the class, as you're using the token, it will automatically be marked as loggedIn.
+     * @param token Must be a valid account token.
+     */
+    constructor(token: string);
+    /**
+     * This will create an instance of the class, as you're putting the account details, you must manually authenticate before invoking restricted calls including joinRoom.
+     * If populating email and password, you must manually authenticate yourself.
+     */
+    constructor(email: string, password: string);
+    /**
+     * Connects the API instance to the server.
+     * This will enable the client to join the room, or access to restricted collections.
+     */
+    authenticate(): Promise<AuthResultSuccess | APIFailure>;
+    /**
+     * Overrides local account details, the parameters are not needed if PW Api was already created with email/password in the first place.
+     * This is for those that used a token in the first place, the accounts won't be saved in the instance.
+     */
+    authenticate(email: string, password: string): Promise<AuthResultSuccess | APIFailure>;
+    /**
+     * Internal.
+     */
+    getJoinKey(roomType: string, roomId: string): Promise<JoinKeyResult>;
+    /**
+     * This route is available to take if you chose to create an API client to then join a world, in which case this returns the Game Client instance.
+     *
+     * Make sure the API client is already authenticated before calling this.
+     *
+     * The 3rd parameter is for if you wish to customise the reconnectability of the game client.
+     */
+    joinWorld(roomId: string, obj?: {
+        joinData?: WorldJoinData;
+        gameSettings?: Partial<GameClientSettings>;
+    }): Promise<PWGameClient<{}>>;
+    /**
+     * This will be an empty array if getRoomTypes has never been used successfully at least once.
+     */
+    static roomTypes: string[];
+    /**
+     * This will be an empty array if getRoomTypes has never been used successfully at least once.
+     */
+    get roomTypes(): string[];
+    /**
+     * Non-authenticated. This will refresh the room types each time, so make sure to check if roomTypes is available.
+     */
+    getRoomTypes(): Promise<string[]>;
+    /**
+     * Non-authenticated. This will refresh the room types each time, so make sure to check if roomTypes is available.
+     */
+    static getRoomTypes(): Promise<string[]>;
+    /**
+     * Non-authenticated. Returns the mappings from the game API.
+     *
+     * Note: This library also exports "BlockNames" which is an enum containing the block names along with their respective id.
+     */
+    getMappings(): Promise<Record<string, number>>;
+    /**
+     * Non-authenticated. Returns the mappings from the game API.
+     *
+     * Note: This library also exports "BlockNames" which is an enum containing the block names along with their respective id.
+     */
+    static getMappings(): Promise<Record<string, number>>;
+    /**
+     * Returns the collection result of the query - your own worlds.
+     * Default: page - 1, perPage - 10
+     */
+    getOwnedWorlds(page: number, perPage: number, query?: ColQuery<ColWorld>): Promise<CollectionResult<ColWorld>>;
+    getOwnedWorlds(query: ColQuery<ColWorld>): Promise<CollectionResult<ColWorld>>;
+    /**
+     * Returns the collection result of the query - players.
+     * Default: page - 1, perPage - 10
+     */
+    getPlayers(page: number, perPage: number, query?: ColQuery<ColPlayer>): Promise<CollectionResult<ColPlayer>>;
+    getPlayers(query: ColQuery<ColPlayer>): Promise<CollectionResult<ColPlayer>>;
+    /**
+     * Returns the collection result of the query - players.
+     * Default: page - 1, perPage - 10
+     */
+    static getPlayers(page: number, perPage: number, query?: ColQuery<ColPlayer>): Promise<CollectionResult<ColPlayer>>;
+    static getPlayers(query: ColQuery<ColPlayer>): Promise<CollectionResult<ColPlayer>>;
+    /**
+     * Returns the collection result of the query - public worlds.
+     * Default: page - 1, perPage - 10
+     */
+    getPublicWorlds(page: number, perPage: number, query?: ColQuery<ColWorld>): Promise<CollectionResult<ColWorld>>;
+    getPublicWorlds(query: ColQuery<ColWorld>): Promise<CollectionResult<ColWorld>>;
+    /**
+     * Returns the collection result of the query - public worlds.
+     * Default: page - 1, perPage - 10
+     */
+    static getPublicWorlds(page: number, perPage: number, query?: ColQuery<ColWorld>): Promise<CollectionResult<ColWorld>>;
+    static getPublicWorlds(query: ColQuery<ColWorld>): Promise<CollectionResult<ColWorld>>;
+    /**
+     * Returns the lobby result.
+     */
+    getVisibleWorlds(): Promise<LobbyResult>;
+    /**
+     * Returns the lobby result.
+     */
+    static getVisibleWorlds(): Promise<LobbyResult>;
+    /**
+     * Returns the world, if it exists and is public.
+     */
+    getPublicWorld(id: string): Promise<ColWorld | undefined>;
+    /**
+     * Returns the world, if it exists and is public.
+     */
+    static getPublicWorld(id: string): Promise<ColWorld | undefined>;
+    /**
+     * Gets the raw minimap bytes, the format may differ depending on the environment (Bun, NodeJS, Browser etc).
+     */
+    getMinimap(world: ColWorld | {
+        id: string;
+        minimap: string;
+    }, toURL?: false): Promise<Buffer>;
+    /**
+     * Gives the URL pointing to the minimap image.
+     */
+    getMinimap(world: ColWorld | {
+        id: string;
+        minimap: string;
+    }, toURL: true): string;
+    /**
+     * Gets the raw minimap bytes, the format may differ depending on the environment (Bun, NodeJS, Browser etc).
+     */
+    static getMinimap(world: ColWorld | {
+        id: string;
+        minimap: string;
+    }, toURL?: false): Promise<Buffer>;
+    /**
+     * Gives the URL pointing to the minimap image.
+     */
+    static getMinimap(world: ColWorld | {
+        id: string;
+        minimap: string;
+    }, toURL: true): string;
+    /**
+     * Note that username is cap sensitive, and may require you to use toUppercase
+     */
+    getPlayerByName(username: string): Promise<CollectionResult<ColPlayer>>;
+    /**
+     * Note that username is cap sensitive, and may require you to use toUppercase
+     */
+    static getPlayerByName(username: string): Promise<CollectionResult<ColPlayer>>;
+    /**
+     * IMPORTANT: This will return JSON for any responses that have the content-type of json, anything else will be sent back as Uint8array.
+     * If you're expecting raw bytes, make sure the endpoint is guaranteed to give you that otherwise there isn't a reason.
+     *
+     * This requires the manager to be authenticated, it will error if otherwise.
+     * @param url Requires to be a full URL with endpoint unfortunately. It will throw error if it doesn't match any of the 2 HTTP endpoint URLs.
+     * @param body If this is passed, the request will become a POST. (If you need to send a POST but has no data, just send an empty object).
+     * @param token The API token (not join key), this is if you wish to use authenticated API calls without having to instantise an api client yourself.
+     */
+    static request<T>(url: string, body?: Record<string, any> | string, token?: string): Promise<T>;
+    /**
+     * IMPORTANT: This will return JSON for any responses that have the content-type of json, anything else will be sent back as Uint8array.
+     * If you're expecting raw bytes, make sure the endpoint is guaranteed to give you that otherwise there isn't a reason.
+     *
+     * This requires the manager to be authenticated, it will error if otherwise.
+     * @param url Requires to be a full URL with endpoint unfortunately. It will throw error if it doesn't match any of the 2 HTTP endpoint URLs.
+     * @param body If this is passed, the request will become a POST. (If you need to send a POST but has no data, just send an empty object).
+     * @param isAuthenticated If true, this will send the token as the header.
+     */
+    protected request<T>(url: string, body?: Record<string, any> | string, isAuthenticated?: boolean): Promise<T>;
+}

package/esm/api/PWApiClient.js

@@ -0,0 +1,247 @@
+import PWGameClient from "../game/PWGameClient.js";
+import { Endpoint } from "../util/Constants.js";
+import { queryToString } from "../util/Misc.js";
+/**
+ * Note if you want to join a world, use new PWGameClient() then run .init()
+ */
+class PWApiClient {
+    constructor(email, password) {
+        /**
+         * Account details with email and password, if applicable.
+         */
+        this.account = {
+            email: "",
+            password: ""
+        };
+        this.loggedIn = false;
+        if (password === undefined) {
+            this.token = email;
+            this.loggedIn = true;
+            return;
+        }
+        this.account.email = email;
+        this.account.password = password;
+        // this.token = token;
+    }
+    authenticate(email, password) {
+        if (email === undefined) {
+            if (this.account.email.length === 0 || this.account.password.length === 0)
+                throw Error("No email/password given.");
+            email = this.account.email;
+            password = this.account.password;
+        }
+        return this.request(`${Endpoint.Api}/api/collections/users/auth-with-password`, { identity: email, password }).then(res => {
+            if ("token" in res) {
+                this.token = res.token;
+                this.loggedIn = true;
+            }
+            return res;
+        }); //.then(console.log);
+    }
+    /**
+     * Internal.
+     */
+    getJoinKey(roomType, roomId) {
+        return this.request(`${Endpoint.Api}/api/joinkey/${roomType}/${roomId}`, undefined, true);
+    }
+    /**
+     * This route is available to take if you chose to create an API client to then join a world, in which case this returns the Game Client instance.
+     *
+     * Make sure the API client is already authenticated before calling this.
+     *
+     * The 3rd parameter is for if you wish to customise the reconnectability of the game client.
+     */
+    joinWorld(roomId, obj) {
+        const game = new PWGameClient(this, obj === null || obj === void 0 ? void 0 : obj.gameSettings);
+        return game.joinWorld(roomId, obj === null || obj === void 0 ? void 0 : obj.joinData);
+    }
+    // I feel like this is cursed.
+    /**
+     * This will be an empty array if getRoomTypes has never been used successfully at least once.
+     */
+    get roomTypes() {
+        return PWApiClient.roomTypes;
+    }
+    /**
+     * Non-authenticated. This will refresh the room types each time, so make sure to check if roomTypes is available.
+     */
+    getRoomTypes() {
+        return PWApiClient.getRoomTypes();
+    }
+    /**
+     * Non-authenticated. This will refresh the room types each time, so make sure to check if roomTypes is available.
+     */
+    static getRoomTypes() {
+        return this.request(`${Endpoint.GameHTTP}/listroomtypes`)
+            .then(res => {
+            PWApiClient.roomTypes = res;
+            return res;
+        });
+    }
+    /**
+     * Non-authenticated. Returns the mappings from the game API.
+     *
+     * Note: This library also exports "BlockNames" which is an enum containing the block names along with their respective id.
+     */
+    getMappings() {
+        return PWApiClient.getMappings();
+    }
+    /**
+     * Non-authenticated. Returns the mappings from the game API.
+     *
+     * Note: This library also exports "BlockNames" which is an enum containing the block names along with their respective id.
+     */
+    static getMappings() {
+        return this.request(`${Endpoint.GameHTTP}/mappings`);
+    }
+    getOwnedWorlds(page = 1, perPage = 10, query) {
+        if (typeof page === "object") {
+            query = page;
+            page = 1;
+        }
+        return this.request(`${Endpoint.Api}/api/collections/worlds/records?page=${page}&perPage=${perPage}${queryToString(query)}`, undefined, true);
+    }
+    getPlayers(page = 1, perPage = 10, query) {
+        if (typeof page === "object") {
+            query = page;
+            page = 1;
+        }
+        return PWApiClient.getPlayers(page, perPage, query);
+    }
+    static getPlayers(page = 1, perPage = 10, query) {
+        if (typeof page === "object") {
+            query = page;
+            page = 1;
+        }
+        return this.request(`${Endpoint.Api}/api/collections/public_profiles/records?page=${page}&perPage=${perPage}${queryToString(query)}`);
+    }
+    getPublicWorlds(page = 1, perPage = 10, query) {
+        if (typeof page === "object") {
+            query = page;
+            page = 1;
+        }
+        return PWApiClient.getPublicWorlds(page, perPage, query);
+    }
+    static getPublicWorlds(page = 1, perPage = 10, query) {
+        if (typeof page === "object") {
+            query = page;
+            page = 1;
+        }
+        return this.request(`${Endpoint.Api}/api/collections/public_worlds/records?page=${page}&perPage=${perPage}${queryToString(query)}`);
+    }
+    /**
+     * Returns the lobby result.
+     */
+    getVisibleWorlds() {
+        return PWApiClient.getVisibleWorlds();
+    }
+    /**
+     * Returns the lobby result.
+     */
+    static getVisibleWorlds() {
+        if (this.roomTypes.length === 0)
+            throw Error("roomTypes is empty - use getRoomTypes first!");
+        return this.request(`${Endpoint.GameHTTP}/room/list/${this.roomTypes[0]}`);
+    }
+    /**
+     * Returns the world, if it exists and is public.
+     */
+    getPublicWorld(id) {
+        return PWApiClient.getPublicWorld(id);
+    }
+    /**
+     * Returns the world, if it exists and is public.
+     */
+    static getPublicWorld(id) {
+        return this.getPublicWorlds(1, 1, { filter: { id } })
+            .then(res => res.items[0]);
+    }
+    getMinimap(world, toURL = false) {
+        if (toURL)
+            return `${Endpoint.Api}/api/files/rhrbt6wqhc4s0cp/${world.id}/${world.minimap}`;
+        return PWApiClient.getMinimap(world, toURL);
+    }
+    static getMinimap(world, toURL = false) {
+        if (toURL)
+            return `${Endpoint.Api}/api/files/rhrbt6wqhc4s0cp/${world.id}/${world.minimap}`;
+        return this.request(this.getMinimap(world, true))
+            .then(res => {
+            if ("message" in res)
+                throw Error("Minimap doesn't exist, the world may be unlisted.");
+            return res;
+        });
+    }
+    /**
+     * Note that username is cap sensitive, and may require you to use toUppercase
+     */
+    getPlayerByName(username) {
+        return PWApiClient.getPlayerByName(username);
+    }
+    /**
+     * Note that username is cap sensitive, and may require you to use toUppercase
+     */
+    static getPlayerByName(username) {
+        return this.getPlayers(1, 1, { filter: { username } });
+    }
+    // This doesn't seem to work so I commented it out, not removing it as there might be an oversight idk
+    // getMessageTypes() {
+    //     return this.request<string[]>(`${Endpoint.GameHTTP}/message_types`)
+    //         .then(res => res instanceof Uint8Array ? [] : res ?? []);
+    // }
+    /**
+     * IMPORTANT: This will return JSON for any responses that have the content-type of json, anything else will be sent back as Uint8array.
+     * If you're expecting raw bytes, make sure the endpoint is guaranteed to give you that otherwise there isn't a reason.
+     *
+     * This requires the manager to be authenticated, it will error if otherwise.
+     * @param url Requires to be a full URL with endpoint unfortunately. It will throw error if it doesn't match any of the 2 HTTP endpoint URLs.
+     * @param body If this is passed, the request will become a POST. (If you need to send a POST but has no data, just send an empty object).
+     * @param token The API token (not join key), this is if you wish to use authenticated API calls without having to instantise an api client yourself.
+     */
+    static request(url, body, token) {
+        if (!(url.startsWith(Endpoint.Api) || url.startsWith(Endpoint.GameHTTP)))
+            throw Error("URL given does not have the correct endpoint URL, this is for safety.");
+        const headers = {
+        // "user-agent": "PW-TS-API/0.0.1"
+        };
+        if (typeof token === "string")
+            headers["authorization"] = token;
+        if (typeof body === "object")
+            body = JSON.stringify(body);
+        let method = "GET";
+        if (typeof body !== "undefined") {
+            headers["content-type"] = "application/json";
+            method = "POST";
+        }
+        return fetch(url, {
+            headers, method,
+            body: body
+        }).then(res => {
+            var _a;
+            if (res.status === 403)
+                throw Error("Forbidden access - token invalid or unauthorised.");
+            // else if (res.status !== 200) throw Error("")
+            if ((_a = res.headers.get("content-type")) === null || _a === void 0 ? void 0 : _a.startsWith("application/json"))
+                return res.json();
+            else
+                return res.arrayBuffer();
+        });
+    }
+    /**
+     * IMPORTANT: This will return JSON for any responses that have the content-type of json, anything else will be sent back as Uint8array.
+     * If you're expecting raw bytes, make sure the endpoint is guaranteed to give you that otherwise there isn't a reason.
+     *
+     * This requires the manager to be authenticated, it will error if otherwise.
+     * @param url Requires to be a full URL with endpoint unfortunately. It will throw error if it doesn't match any of the 2 HTTP endpoint URLs.
+     * @param body If this is passed, the request will become a POST. (If you need to send a POST but has no data, just send an empty object).
+     * @param isAuthenticated If true, this will send the token as the header.
+     */
+    request(url, body, isAuthenticated = false) {
+        return PWApiClient.request(url, body, isAuthenticated ? this.token : undefined);
+    }
+}
+/**
+ * This will be an empty array if getRoomTypes has never been used successfully at least once.
+ */
+PWApiClient.roomTypes = [];
+export default PWApiClient;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"PWApiClient.js","sourceRoot":"","sources":["../../lib/api/PWApiClient.ts"],"names":[],"mappings":"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"}

package/esm/game/PWGameClient.d.ts

@@ -0,0 +1,115 @@
+import type PWApiClient from "../api/PWApiClient.js";
+import { type PlayerChatPacket, type WorldBlockFilledPacket, type WorldBlockPlacedPacket } from "../gen/world_pb.js";
+import type { GameClientSettings, WorldJoinData, Hook } from "../types/game.js";
+import type { CustomBotEvents, MergedEvents, WorldEvents } from "../types/events.js";
+import Bucket from "../util/Bucket.js";
+import type { OmitRecursively, Optional, Promisable } from "../types/misc.js";
+type SafeCheck<K extends keyof MergedEvents, State extends Partial<{
+    [K in keyof MergedEvents]: any;
+}>> = State extends CustomBotEvents ? never : State[K];
+export default class PWGameClient<StateT extends Partial<{
+    [K in keyof WorldEvents]: never;
+}> = {}> {
+    settings: GameClientSettings;
+    api?: PWApiClient;
+    socket?: WebSocket;
+    private prevWorldId?;
+    protected totalBucket: Bucket;
+    protected chatBucket: Bucket;
+    protected connectAttempts: {
+        time: number;
+        count: number;
+    };
+    /**
+     * NOTE: After constructing, you must then run .init() to connect the API IF you're using email/password.
+     */
+    constructor(api: PWApiClient, settings?: Partial<GameClientSettings>);
+    constructor(settings?: Partial<GameClientSettings>);
+    get connected(): boolean;
+    /**
+     * This will connect to the world.
+     *
+     * (This returns itself for chaining)
+     */
+    joinWorld(roomId: string, joinData?: WorldJoinData): Promise<this>;
+    /**
+     * INTERNAL
+     */
+    private createSocket;
+    /**
+     * This is a more direct route if you already have a join key acquired via Pixelwalker's API.
+     *
+     * Useful for those wary of security.
+     */
+    static joinWorld(joinKey: string, obj?: {
+        joinData?: WorldJoinData;
+        gameSettings?: Partial<GameClientSettings>;
+    }): Promise<PWGameClient>;
+    /**
+     * For faster performance (even if it seems insignificant),
+     * direct functions are used instead of events which are also inconsistent with browsers/nodejs etc.
+     *
+     * NOTE: the "this" won't be the client itself. You will need to bind yourself if you want to keep this.
+     */
+    protected callbacks: Partial<{ [K in keyof MergedEvents]: Array<(data: MergedEvents[K], states?: SafeCheck<K, StateT>) => Promisable<void | "STOP">>; }>;
+    /**
+     * Poorly documented because I cba
+     */
+    private hooks;
+    /**
+     * This is different to addCallback as all hooks (regardless of the type) will execute first before the callbacks, each hook may modify something or do something in the background
+     * and may pass it to callbacks (via the second parameter in callbacks). If an error occurs while executing one of the hooks,
+     * the execution of hooks will halt for that packet and callbacks will run without the states.
+     *
+     * NOTE: This is permanent, if a hook is added, it can't be removed.
+     */
+    addHook<HookState extends Pick<Partial<{
+        [K in keyof WorldEvents]: any;
+    }>, keyof WorldEvents>>(hook: Hook<HookState>): PWGameClient<StateT & HookState>;
+    /**
+     * Adds a listener for the event type, it can even be a promise too.
+     *
+     * If the callback returns a specific string "STOP", it will prevent further listeners from being invoked.
+     */
+    addCallback<Event extends keyof CustomBotEvents>(type: Event, ...cbs: Array<(data: MergedEvents[Event]) => Promisable<void | "STOP">>): this;
+    addCallback<Event extends keyof WorldEvents>(type: Event, ...cbs: Array<(data: MergedEvents[Event], states?: SafeCheck<Event, StateT>) => Promisable<void | "STOP">>): this;
+    /**
+     * Adds a listener for the event type, it can even be a promise too.
+     *
+     * If the callback returns a specific string "STOP", it will prevent further listeners from being invoked.
+     */
+    prependCallback<Event extends keyof CustomBotEvents>(type: Event, ...cbs: Array<(data: MergedEvents[Event]) => Promisable<void | "STOP">>): this;
+    prependCallback<Event extends keyof WorldEvents>(type: Event, ...cbs: Array<(data: MergedEvents[Event], states?: SafeCheck<Event, StateT>) => Promisable<void | "STOP">>): this;
+    /**
+     * @param type The type of the event
+     * @param cb It can be the function itself (to remove that specific function). If undefined, it will remove ALL functions from that list, it will return undefined.
+     */
+    removeCallback<Event extends keyof MergedEvents>(type: Event, cb?: (data: MergedEvents[Event], states: SafeCheck<Event, StateT>) => Promisable<void | "STOP">): undefined | ((data: MergedEvents[Event], states: SafeCheck<Event, StateT>) => Promisable<void | "STOP">);
+    /**
+     * INTERNAL. Invokes all functions of a callback type, unless one of them prohibits in transit.
+     */
+    protected invoke<Event extends keyof CustomBotEvents>(type: Event, data: MergedEvents[Event]): Promise<{
+        count: number;
+        stopped: boolean;
+    }>;
+    protected invoke<Event extends keyof WorldEvents>(type: Event, data: MergedEvents[Event], states: SafeCheck<Event, StateT>): Promise<{
+        count: number;
+        stopped: boolean;
+    }>;
+    /**
+     * This assumes that the connection
+     *
+     * @param type Type of the packet.
+     * @param value Value of the packet to send along with, note that some properties are optional.
+     * @param direct If it should skip queue.
+     */
+    send<Event extends keyof WorldEvents>(type: Event, value?: OmitRecursively<Sendable<Event, WorldEvents>, "$typeName" | "$unknown">, direct?: boolean): void;
+    /**
+     * By default this will set the game client settings reconnectable to false.
+     *
+     * If reconnect is true, an additionl parameter can be passed which is the amount of time to wait before it attempts to reconnect (DEFAULT: none)
+     */
+    disconnect(reconnect?: number | boolean): boolean;
+}
+type Sendable<E extends keyof WorldEvents, WE extends WorldEvents> = E extends "worldBlockPlacedPacket" ? Optional<WorldBlockPlacedPacket, "extraFields"> : E extends "WorldBlockFilledPacket" ? Optional<WorldBlockFilledPacket, "extraFields"> : E extends "playerChatPacket" ? Omit<PlayerChatPacket, "playerId"> : WE[E];
+export {};