@colyseus/core 0.18.24 → 0.18.26

package/build/Room.d.ts

@@ -456,6 +456,39 @@ export declare class Room<T extends RoomOptions = RoomOptions> {
      * (Experimental: this feature is subject to change in the future - we're currently getting feedback to improve it)
      */
     onUncaughtException?(error: RoomException, methodName: RoomMethodName): void;
+    /**
+     * Called when a client sends a message type that has no `onMessage()` handler.
+     * Use it to report the message, for example to an error tracker.
+     *
+     * It only observes. After it returns, the server still handles the message the
+     * usual way:
+     * - `room.send()`/`room.sendBytes()`: the client is disconnected with
+     *   `CloseCode.WITH_ERROR` (4002). In `devMode`, the client receives an
+     *   `ErrorCode.INVALID_PAYLOAD` error instead and stays connected.
+     * - `room.request()`: the request rejects with a `no_handler` error.
+     *
+     * To accept every message type without disconnecting the client, register a
+     * fallback handler with `onMessage("*", ...)` instead. Messages it receives
+     * don't reach this method, except requests: the fallback can't answer those.
+     *
+     * Without this method, the server logs a warning for unhandled `send()`/`sendBytes()`
+     * messages. An error thrown here goes to `onUncaughtException` (as an
+     * `OnMessageException`) when defined, or is logged.
+     *
+     * @param client - The client that sent the message.
+     * @param type - The message type it sent.
+     * @param message - The decoded payload (a `Buffer` for `sendBytes()`).
+     *
+     * @example
+     * ```typescript
+     * onUnhandledMessage(client: Client, type: string | number, message: unknown) {
+     *   Sentry.captureMessage(`unhandled message "${type}"`, {
+     *     extra: { roomId: this.roomId, sessionId: client.sessionId, message },
+     *   });
+     * }
+     * ```
+     */
+    onUnhandledMessage?(client: ExtractRoomClient<T>, type: string | number, message: unknown): void | Promise<any>;
     /**
      * This method is called before onJoin() - this is where you should authenticate the client
      * @param client - The client that is authenticating.

package/build/Room.mjs

@@ -58,6 +58,8 @@ var Room = class _Room {
      */
     this.clock = new Clock();
     this.#_onLeaveConcurrent = 0;
+    // number of onLeave calls in progress
+    this.#_pendingCloses = /* @__PURE__ */ new WeakMap();
     this.#_maxClientsReached = false;
     this.#_maxClients = Infinity;
     this.#_autoDispose = true;
@@ -159,6 +161,7 @@ var Room = class _Room {
   #_roomId;
   #_roomName;
   #_onLeaveConcurrent;
+  #_pendingCloses;
   #_maxClientsReached;
   #_maxClients;
   #_autoDispose;
@@ -1197,6 +1200,7 @@ var Room = class _Room {
       return this._reconnections[reconnectionToken][1];
     }
     this._reserveSeat(sessionId, true, previousClient.auth, seconds, true);
+    this.#_pendingCloses.get(previousClient)?.();
     const reconnection = new Deferred();
     this._reconnections[reconnectionToken] = [sessionId, reconnection];
     if (seconds !== Infinity) {
@@ -1439,11 +1443,13 @@ var Room = class _Room {
     client.ref.removeAllListeners("message");
     client.ref.removeListener("close", client.ref["onleave"]);
     const ref = client.ref;
-    this._onLeave(client, closeCode).then(() => {
-      if (client.ref === ref) {
+    const close = () => {
+      if (this.#_pendingCloses.delete(client) && client.ref === ref) {
         client.leave(closeCode, reason);
       }
-    });
+    };
+    this.#_pendingCloses.set(client, close);
+    this._onLeave(client, closeCode).then(close);
   }
   async _onLeave(client, code) {
     const method = code === CloseCode.CONSENTED || client.state === ClientState.RECONNECTING ? this.onLeave : this.onDrop || this.onLeave;