@colyseus/core 0.16.0-preview.8 → 0.16.0

package/build/Room.d.ts

@@ -1,15 +1,11 @@
-/// <reference types="node" />
-/// <reference types="node" />
-/// <reference types="node" />
-import http, { IncomingMessage } from 'http';
-import { Schema } from '@colyseus/schema';
-import Clock from '@gamestdio/timer';
+import Clock from '@colyseus/timer';
 import { EventEmitter } from 'events';
-import { Presence } from './presence/Presence';
-import { Serializer } from './serializer/Serializer';
-import { Deferred } from './utils/Utils';
-import { RoomListingData } from './matchmaker/driver';
-import { Client, ClientArray, ISendOptions } from './Transport';
+import { Presence } from './presence/Presence.js';
+import { Serializer } from './serializer/Serializer.js';
+import { Deferred } from './utils/Utils.js';
+import { RoomCache } from './matchmaker/driver/api.js';
+import { AuthContext, Client, ClientPrivate, ClientArray, ISendOptions } from './Transport';
+import { RoomException } from './errors/RoomExceptions.js';
 export declare const DEFAULT_SEAT_RESERVATION_TIME: number;
 export type SimulationCallback = (deltaTime: number) => void;
 export interface IBroadcastOptions extends ISendOptions {
@@ -20,6 +16,8 @@ export declare enum RoomInternalState {
     CREATED = 1,
     DISPOSING = 2
 }
+export type ExtractUserData<T> = T extends ClientArray<infer U> ? U : never;
+export type ExtractAuthData<T> = T extends ClientArray<infer _, infer U> ? U : never;
 /**
  * A Room class is meant to implement a game session, and/or serve as the communication channel
  * between a group of clients.
@@ -38,7 +36,7 @@ export declare abstract class Room<State extends object = any, Metadata = any, U
      */
     get locked(): boolean;
     get metadata(): Metadata;
-    listing: RoomListingData<Metadata>;
+    listing: RoomCache<Metadata>;
     /**
      * Timing events tied to the room instance.
      * Intervals and timeouts are cleared when the room is disposed.
@@ -50,6 +48,12 @@ export declare abstract class Room<State extends object = any, Metadata = any, U
      * the room will be unlocked as soon as a client disconnects from it.
      */
     maxClients: number;
+    /**
+     * Automatically dispose the room when last client disconnects.
+     *
+     * @default true
+     */
+    autoDispose: boolean;
     /**
      * Frequency to send the room state to connected clients, in milliseconds.
      *
@@ -76,7 +80,7 @@ export declare abstract class Room<State extends object = any, Metadata = any, U
     _events: EventEmitter<[never]>;
     protected seatReservationTime: number;
     protected reservedSeats: {
-        [sessionId: string]: [any, any];
+        [sessionId: string]: [any, any, boolean?, boolean?];
     };
     protected reservedSeatTimeouts: {
         [sessionId: string]: NodeJS.Timeout;
@@ -89,20 +93,15 @@ export declare abstract class Room<State extends object = any, Metadata = any, U
     private _serializer;
     private _afterNextPatchQueue;
     private _simulationInterval;
-    private _patchInterval;
     private _internalState;
-    private _locked;
     private _lockedExplicitly;
-    private _maxClientsReached;
     private _autoDisposeTimeout;
     constructor();
     /**
-     * Automatically dispose the room when last client disconnects.
-     *
-     * @default true
+     * This method is called by the MatchMaker before onCreate()
+     * @internal
      */
-    get autoDispose(): boolean;
-    set autoDispose(value: boolean);
+    protected __init(): void;
     /**
      * The name of the room you provided as first argument for `gameServer.define()`.
      *
@@ -135,11 +134,27 @@ export declare abstract class Room<State extends object = any, Metadata = any, U
     onLeave?(client: Client<UserData, AuthData>, consented?: boolean): void | Promise<any>;
     onDispose?(): void | Promise<any>;
     /**
-     * onAuth at the instance level will be deprecated in the future.
-     * Please use "static onAuth(token, req) instead
+     * Define a custom exception handler.
+     * If defined, all lifecycle hooks will be wrapped by try/catch, and the exception will be forwarded to this method.
+     *
+     * These methods will be wrapped by try/catch:
+     * - `onMessage`
+     * - `onAuth` / `onJoin` / `onLeave` / `onCreate` / `onDispose`
+     * - `clock.setTimeout` / `clock.setInterval`
+     * - `setSimulationInterval`
+     *
+     * (Experimental: this feature is subject to change in the future - we're currently getting feedback to improve it)
      */
-    onAuth(client: Client<UserData, AuthData>, options: any, request?: http.IncomingMessage): any | Promise<any>;
-    static onAuth(token: string, req: IncomingMessage): Promise<unknown>;
+    onUncaughtException?(error: RoomException<this>, methodName: 'onCreate' | 'onAuth' | 'onJoin' | 'onLeave' | 'onDispose' | 'onMessage' | 'setSimulationInterval' | 'setInterval' | 'setTimeout'): void;
+    onAuth(client: Client<UserData, AuthData>, options: any, context: AuthContext): any | Promise<any>;
+    static onAuth(token: string, options: any, context: AuthContext): Promise<unknown>;
+    /**
+     * This method is called during graceful shutdown of the server process
+     * You may override this method to dispose the room in your own way.
+     *
+     * Once process reaches room count of 0, the room process will be terminated.
+     */
+    onBeforeShutdown(): void;
     /**
      * devMode: When `devMode` is enabled, `onCacheRoom` method is called during
      * graceful shutdown.
@@ -184,7 +199,13 @@ export declare abstract class Room<State extends object = any, Metadata = any, U
      * @param delay - Interval delay on executing `onTickCallback` in milliseconds.
      */
     setSimulationInterval(onTickCallback?: SimulationCallback, delay?: number): void;
+    /**
+     * @deprecated Use `.patchRate=` instead.
+     */
     setPatchRate(milliseconds: number | null): void;
+    /**
+     * @deprecated Use `.state =` instead.
+     */
     setState(newState: State): void;
     setSerializer(serializer: Serializer<State>): void;
     setMetadata(meta: Partial<Metadata>): Promise<void>;
@@ -198,15 +219,17 @@ export declare abstract class Room<State extends object = any, Metadata = any, U
      */
     unlock(): Promise<void>;
     send(client: Client, type: string | number, message: any, options?: ISendOptions): void;
-    send(client: Client, message: Schema, options?: ISendOptions): void;
-    broadcast(type: string | number, message?: any, options?: IBroadcastOptions): any;
-    broadcast<T extends Schema>(message: T, options?: IBroadcastOptions): any;
+    broadcast(type: string | number, message?: any, options?: IBroadcastOptions): void;
+    /**
+     * Broadcast bytes (UInt8Arrays) to a particular room
+     */
+    broadcastBytes(type: string | number, message: Uint8Array, options: IBroadcastOptions): void;
     /**
      * Checks whether mutations have occurred in the state, and broadcast them to all connected clients.
      */
     broadcastPatch(): boolean;
     onMessage<T = any>(messageType: '*', callback: (client: Client<UserData, AuthData>, type: string | number, message: T) => void): any;
-    onMessage<T = any>(messageType: string | number, callback: (client: Client<UserData, AuthData>, message: T) => void): any;
+    onMessage<T = any>(messageType: string | number, callback: (client: Client<UserData, AuthData>, message: T) => void, validate?: (message: unknown) => T): any;
     /**
      * Disconnect all connected clients, and then dispose the room.
      *
@@ -214,7 +237,7 @@ export declare abstract class Room<State extends object = any, Metadata = any, U
      * @returns Promise<void>
      */
     disconnect(closeCode?: number): Promise<any>;
-    ['_onJoin'](client: Client, req?: http.IncomingMessage): Promise<void>;
+    ['_onJoin'](client: Client & ClientPrivate, authContext: AuthContext): Promise<void>;
     /**
      * Allow the specified client to reconnect into the room. Must be used inside `onLeave()` method.
      * If seconds is provided, the reconnection is going to be cancelled after the provided amount of seconds.
@@ -228,14 +251,15 @@ export declare abstract class Room<State extends object = any, Metadata = any, U
     allowReconnection(previousClient: Client, seconds: number | "manual"): Deferred<Client>;
     protected resetAutoDisposeTimeout(timeoutInSeconds?: number): void;
     private broadcastMessageType;
-    private sendFullState;
-    private _dequeueAfterPatchMessages;
-    private _reserveSeat;
-    private _disposeIfEmpty;
-    private _dispose;
-    private _onMessage;
-    private _forciblyCloseClient;
-    private _onLeave;
-    private _incrementClientCount;
-    private _decrementClientCount;
+    protected sendFullState(client: Client): void;
+    protected _dequeueAfterPatchMessages(): void;
+    protected _reserveSeat(sessionId: string, joinOptions?: any, authData?: any, seconds?: number, allowReconnection?: boolean, devModeReconnection?: boolean): Promise<boolean>;
+    protected _disposeIfEmpty(): boolean;
+    protected _dispose(): Promise<any>;
+    protected _onMessage(client: Client & ClientPrivate, buffer: Buffer): void;
+    protected _forciblyCloseClient(client: Client & ClientPrivate, closeCode: number): void;
+    protected _onLeave(client: Client, code?: number): Promise<any>;
+    protected _onAfterLeave(client: Client): Promise<void>;
+    protected _incrementClientCount(): Promise<void>;
+    protected _decrementClientCount(): Promise<boolean>;
 }