@colyseus/sdk 0.17.7 → 0.17.8

package/dist/debug.js

@@ -3,7 +3,7 @@
 // This software is released under the MIT License.
 // https://opensource.org/license/MIT
 //
-// colyseus.js@0.17.7
+// colyseus.js@0.17.8
 (function (Client) {
   'use strict';
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@colyseus/sdk",
-  "version": "0.17.7",
+  "version": "0.17.8",
   "description": "Colyseus Multiplayer SDK for JavaScript/TypeScript",
   "author": "Endel Dreyer",
   "license": "MIT",
@@ -81,7 +81,7 @@
     "typescript": "^5.9.3",
     "vite": "^5.0.11",
     "vitest": "^2.1.1",
-    "@colyseus/core": "^0.17.7"
+    "@colyseus/core": "^0.17.9"
   },
   "peerDependencies": {
     "@colyseus/core": "0.17.x"

package/src/Auth.ts

@@ -13,12 +13,32 @@ export interface PopupSettings {
     height: number;
 }
 
-export interface AuthData {
-    user: any;
+/**
+ * Response from getUserData()
+ */
+export interface UserDataResponse<UserData = any> {
+    user: UserData;
+}
+
+/**
+ * Response from authentication methods (login, register, anonymous, OAuth)
+ */
+export interface AuthResponse<UserData = any> {
+    user: UserData;
     token: string;
 }
 
-export class Auth {
+/**
+ * Response from sendPasswordResetEmail()
+ */
+export type ForgotPasswordResponse = boolean | unknown;
+
+/**
+ * @deprecated Use AuthResponse instead
+ */
+export type AuthData<UserData = any> = AuthResponse<UserData>;
+
+export class Auth<UserData = any> {
     settings: AuthSettings = {
         path: "/auth",
         key: "colyseus-auth-token",
@@ -26,7 +46,9 @@ export class Auth {
 
     #_initialized = false;
     #_signInWindow: WindowProxy | null = null;
-    #_events = createNanoEvents();
+    #_events = createNanoEvents<{
+        change: (response: AuthResponse) => void;
+    }>();
 
     protected http: HTTP<any>;
 
@@ -43,10 +65,10 @@ export class Auth {
         return this.http.authToken;
     }
 
-    public onChange(callback: (response: AuthData) => void) {
+    public onChange<U = UserData>(callback: (response: AuthResponse<U | null>) => void) {
         const unbindChange = this.#_events.on("change", callback);
         if (!this.#_initialized) {
-            this.getUserData().then((userData: any) => {
+            this.getUserData().then((userData) => {
                 this.emitChange({ ...userData, token: this.token });
 
             }).catch((e) => {
@@ -58,7 +80,7 @@ export class Auth {
         return unbindChange;
     }
 
-    public async getUserData() {
+    public async getUserData<U = UserData>(): Promise<UserDataResponse<U>> {
         if (this.token) {
             return (await this.http.get(`${this.settings.path}/userdata`)).data;
         } else {
@@ -66,43 +88,53 @@ export class Auth {
         }
     }
 
-    public async registerWithEmailAndPassword(email: string, password: string, options?: any) {
+    public async registerWithEmailAndPassword<U = UserData>(
+        email: string,
+         password: string,
+        options?: any
+    ): Promise<AuthResponse<U>> {
         const data = (await this.http.post(`${this.settings.path}/register`, {
             body: { email, password, options, },
         })).data;
 
-        this.emitChange(data as any);
+        this.emitChange(data);
 
         return data;
     }
 
-    public async signInWithEmailAndPassword(email: string, password: string) {
+    public async signInWithEmailAndPassword<U = UserData>(
+        email: string,
+        password: string
+    ): Promise<AuthResponse<U>> {
         const data = (await this.http.post(`${this.settings.path}/login`, {
             body: { email, password, },
         })).data;
 
-        this.emitChange(data as any);
+        this.emitChange(data);
 
         return data;
     }
 
-    public async signInAnonymously(options?: any) {
+    public async signInAnonymously<U = UserData>(options?: any): Promise<AuthResponse<U>> {
         const data = (await this.http.post(`${this.settings.path}/anonymous`, {
             body: { options, }
         })).data;
 
-        this.emitChange(data as any);
+        this.emitChange(data);
 
         return data;
     }
 
-    public async sendPasswordResetEmail(email: string) {
+    public async sendPasswordResetEmail(email: string): Promise<ForgotPasswordResponse> {
         return (await this.http.post(`${this.settings.path}/forgot-password`, {
             body: { email, }
         })).data;
     }
 
-    public async signInWithProvider(providerName: string, settings: Partial<PopupSettings> = {}) {
+    public async signInWithProvider<U = UserData>(
+        providerName: string,
+        settings: Partial<PopupSettings> = {}
+    ): Promise<AuthResponse<U>> {
         return new Promise((resolve, reject) => {
             const w = settings.width || 480;
             const h = settings.height || 768;
@@ -153,12 +185,11 @@ export class Auth {
         });
     }
 
-    public async signOut() {
-        // @ts-ignore
+    public async signOut(): Promise<void> {
         this.emitChange({ user: null, token: null });
     }
 
-    private emitChange(authData: Partial<AuthData>) {
+    private emitChange(authData: AuthResponse<UserData | null>) {
         if (authData.token !== undefined) {
             this.token = authData.token;
 

package/src/Client.ts

@@ -50,7 +50,7 @@ export interface LatencyOptions {
     pingCount?: number;
 }
 
-export class ColyseusSDK<ServerType extends SDKTypes = any> {
+export class ColyseusSDK<ServerType extends SDKTypes = any, UserData = any> {
     static VERSION = "0.17";
 
     /**
@@ -61,7 +61,7 @@ export class ColyseusSDK<ServerType extends SDKTypes = any> {
     /**
      * The authentication module to authenticate into requests and rooms.
      */
-    public auth: Auth;
+    public auth: Auth<UserData>;
 
     /**
      * The settings used to connect to the server.
@@ -144,12 +144,12 @@ export class ColyseusSDK<ServerType extends SDKTypes = any> {
      * @param latencyOptions Latency measurement options (protocol, pingCount).
      * @returns The client with the lowest latency.
      */
-    static async selectByLatency<ServerType extends SDKTypes = any>(
+    static async selectByLatency<ServerType extends SDKTypes = any, UserData = any>(
         endpoints: Array<string | EndpointSettings>,
         options?: ClientOptions,
         latencyOptions: LatencyOptions = {}
     ) {
-        const clients = endpoints.map(endpoint => new ColyseusSDK<ServerType>(endpoint, options));
+        const clients = endpoints.map(endpoint => new ColyseusSDK<ServerType, UserData>(endpoint, options));
 
         const latencies = (await Promise.allSettled(clients.map((client, index) => client.getLatency(latencyOptions).then(latency => {
             const settings = clients[index].settings;

package/src/HTTP.ts

@@ -483,6 +483,11 @@ export class HTTP<R extends Router | Router["endpoints"]> {
                 : requestOptions?.headers
         );
 
+        // Add Authorization header if authToken is set
+        if (this.authToken && !headers.has("authorization")) {
+            headers.set("authorization", `Bearer ${this.authToken}`);
+        }
+
         // Stringify JSON-serializable objects for fetch() body
         if (isJSONSerializable(body) && typeof body === 'object' && body !== null) {
             if (!headers.has("content-type")) {

package/src/Room.ts

@@ -430,7 +430,7 @@ export class Room<
             this.onMessageHandlers.emit('*', type, message);
 
         } else if (!messageType.startsWith("__")) { // ignore internal messages
-            console.warn?.(`colyseus.js: onMessage() not registered for type '${type}'.`);
+            console.warn?.(`@colyseus/sdk: onMessage() not registered for type '${type}'.`);
         }
     }
 

package/src/core/nanoevents.ts

@@ -21,15 +21,23 @@
  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
-export const createNanoEvents = () => ({
-    emit(event: string, ...args: any[]) {
+export type EventsMap = Record<string, (...args: any[]) => void>;
+
+export interface Emitter<Events extends EventsMap> {
+    events: { [K in keyof Events]?: Array<Events[K]> };
+    emit<K extends keyof Events>(event: K, ...args: Parameters<Events[K]>): void;
+    on<K extends keyof Events>(event: K, cb: Events[K]): () => void;
+}
+
+export const createNanoEvents = <Events extends EventsMap = EventsMap>(): Emitter<Events> => ({
+    emit(event, ...args) {
         let callbacks = this.events[event] || []
         for (let i = 0, length = callbacks.length; i < length; i++) {
             callbacks[i](...args)
         }
     },
     events: {},
-    on(event: string, cb: (...args: any[]) => void) {
+    on(event, cb) {
         this.events[event]?.push(cb) || (this.events[event] = [cb])
         return () => {
             this.events[event] = this.events[event]?.filter(i => cb !== i)

package/src/index.ts

@@ -3,7 +3,7 @@ import './legacy';
 export { ColyseusSDK, Client, MatchMakeError, type JoinOptions, type EndpointSettings, type ClientOptions, type ISeatReservation as SeatReservation } from './Client.ts';
 export { Protocol, ErrorCode } from './Protocol.ts';
 export { Room, type RoomAvailable } from './Room.ts';
-export { Auth, type AuthSettings, type PopupSettings } from "./Auth.ts";
+export { Auth, type AuthSettings, type PopupSettings, type AuthResponse, type UserDataResponse, type ForgotPasswordResponse, type AuthData } from "./Auth.ts";
 export { ServerError, CloseCode } from './errors/Errors.ts';
 
 /*

package/src/transport/WebSocketTransport.ts

@@ -18,7 +18,7 @@ export class WebSocketTransport implements ITransport {
     }
 
     public sendUnreliable(data: Uint8Array): void {
-        console.warn("colyseus.js: The WebSocket transport does not support unreliable messages");
+        console.warn("@colyseus/sdk: The WebSocket transport does not support unreliable messages");
     }
 
     /**