@eleven-am/pondsocket 0.1.218 → 0.1.219

package/{engines → dist/engines}/lobbyEngine.js

@@ -22,6 +22,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 var _LobbyEngine_instances, _LobbyEngine_backend, _LobbyEngine_channels, _LobbyEngine_getChannel, _LobbyEngine_createChannel;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LobbyEngine = void 0;
+const pondsocket_common_1 = require("@eleven-am/pondsocket-common");
 const channelEngine_1 = require("./channelEngine");
 const middleware_1 = require("../abstracts/middleware");
 const eventContext_1 = require("../contexts/eventContext");
@@ -50,6 +51,9 @@ class LobbyEngine {
      * Attaches a handler for a specific event pattern
      */
     onEvent(event, handler) {
+        if (typeof event === 'string') {
+            (0, pondsocket_common_1.compilePondRoute)(event);
+        }
         this.middleware.use((requestEvent, channel, next) => {
             const params = (0, matcher_1.parseAddress)(event, requestEvent.event);
             if (!params) {
@@ -63,6 +67,9 @@ class LobbyEngine {
      * Attaches a handler for outgoing events
      */
     handleOutgoingEvent(event, handler) {
+        if (typeof event === 'string') {
+            (0, pondsocket_common_1.compilePondRoute)(event);
+        }
         this.outgoing.use((context, chEvent, next) => __awaiter(this, void 0, void 0, function* () {
             const params = (0, matcher_1.parseAddress)(event, chEvent.event);
             if (!params || context.isBlocked()) {
@@ -70,12 +77,7 @@ class LobbyEngine {
             }
             const typedContext = context;
             typedContext.updateParams(params);
-            const payload = yield handler(typedContext, next);
-            if (payload === undefined || payload === null) {
-                return;
-            }
-            typedContext.transform(payload);
-            return next();
+            yield handler(typedContext);
         }));
     }
     /**
@@ -89,8 +91,10 @@ class LobbyEngine {
         return __awaiter(this, void 0, void 0, function* () {
             const params = (0, matcher_1.parseAddress)('*', event.event);
             const context = new outgoingContext_1.OutgoingContext(event, params, engine, userId);
-            yield this.outgoing.runAsync(context, event, () => {
-                // no-op
+            yield this.outgoing.runAsync(context, event, (error) => {
+                if (error) {
+                    context.block();
+                }
             });
             if (context.isBlocked()) {
                 return;

package/{index.d.ts → dist/index.d.ts}

@@ -8,6 +8,7 @@ export { BaseContext } from './contexts/baseContext';
 export { JoinContext } from './contexts/joinContext';
 export { EventContext } from './contexts/eventContext';
 export { OutgoingContext } from './contexts/outgoingContext';
+export type { OutgoingHandlerContext, OutgoingPayload } from './contexts/outgoingContext';
 export { HttpError } from './errors/httpError';
 export type { ConnectionHandler, AuthorizationHandler, EventHandler, OutgoingEventHandler, LeaveCallback, LeaveEvent, NextFunction, } from './abstracts/types';
 export * from './types';

package/dist/matcher/matcher.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseAddress = parseAddress;
+const pondsocket_common_1 = require("@eleven-am/pondsocket-common");
+function parseAddress(route, address) {
+    if (route instanceof RegExp) {
+        const match = address.match(route);
+        if (!match) {
+            return null;
+        }
+        return {
+            params: {},
+            query: {},
+        };
+    }
+    return (0, pondsocket_common_1.parsePondRoute)(route, address);
+}

package/{server → dist/server}/server.d.ts

@@ -1,21 +1,25 @@
 import { IncomingMessage, Server as HTTPServer } from 'http';
-import { PondPath } from '@eleven-am/pondsocket-common';
+import { PondEndpointDefinition, PondPath } from '@eleven-am/pondsocket-common';
 import { ConnectionHandler } from '../abstracts/types';
 import { PondSocketOptions } from '../types';
 import { Endpoint } from '../wrappers/endpoint';
 export declare class PondSocket {
     #private;
-    constructor({ server, socketServer, exclusiveServer, distributedBackend, maxMessageSize, heartbeatInterval, }?: PondSocketOptions);
+    constructor({ server, socketServer, closeHttpServerOnShutdown, exclusiveServer, distributedBackend, maxMessageSize, heartbeatInterval, }?: PondSocketOptions);
     /**
      * Start listening for connections
      */
-    listen(...args: any[]): HTTPServer<typeof IncomingMessage, typeof import("node:http").ServerResponse>;
+    listen(...args: any[]): HTTPServer<typeof IncomingMessage, typeof import("http").ServerResponse>;
     /**
      * Close the server
      */
-    close(callback?: (err?: Error) => void, timeout?: number): HTTPServer<typeof IncomingMessage, typeof import("node:http").ServerResponse>;
+    close(callback?: (err?: Error) => void, timeout?: number): HTTPServer<typeof IncomingMessage, typeof import("http").ServerResponse>;
+    closeAsync(timeout?: number): Promise<void>;
+    ready(): Promise<void>;
+    isHealthy(): boolean;
     /**
      * Create a new endpoint
      */
+    createEndpoint<Path extends string>(definition: PondEndpointDefinition<Path>, handler: ConnectionHandler<Path>): Endpoint;
     createEndpoint<Path extends string>(path: PondPath<Path>, handler: ConnectionHandler<Path>): Endpoint;
 }

package/{server → dist/server}/server.js

@@ -1,4 +1,13 @@
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
     if (kind === "m") throw new TypeError("Private method is not writable");
     if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
@@ -10,7 +19,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _PondSocket_instances, _PondSocket_server, _PondSocket_exclusiveServer, _PondSocket_socketServer, _PondSocket_backend, _PondSocket_middleware, _PondSocket_maxMessageSize, _PondSocket_heartbeatMs, _PondSocket_heartbeatTimer, _PondSocket_backendReady, _PondSocket_handleUpgrade, _PondSocket_manageHeartbeat, _PondSocket_init, _PondSocket_getCookies;
+var _PondSocket_instances, _PondSocket_server, _PondSocket_exclusiveServer, _PondSocket_socketServer, _PondSocket_backend, _PondSocket_middleware, _PondSocket_maxMessageSize, _PondSocket_heartbeatMs, _PondSocket_closeHttpServerOnShutdown, _PondSocket_upgradeHandler, _PondSocket_heartbeatTimer, _PondSocket_backendReady, _PondSocket_backendError, _PondSocket_serverError, _PondSocket_shutdownPromise, _PondSocket_shutdown, _PondSocket_handleUpgrade, _PondSocket_manageHeartbeat, _PondSocket_init, _PondSocket_getCookies;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PondSocket = void 0;
 const http_1 = require("http");
@@ -22,7 +31,7 @@ const endpointEngine_1 = require("../engines/endpointEngine");
 const matcher_1 = require("../matcher/matcher");
 const endpoint_1 = require("../wrappers/endpoint");
 class PondSocket {
-    constructor({ server, socketServer, exclusiveServer = true, distributedBackend, maxMessageSize = 1024 * 1024, heartbeatInterval = 30000, } = {}) {
+    constructor({ server, socketServer, closeHttpServerOnShutdown = true, exclusiveServer = true, distributedBackend, maxMessageSize = 1024 * 1024, heartbeatInterval = 30000, } = {}) {
         _PondSocket_instances.add(this);
         _PondSocket_server.set(this, void 0);
         _PondSocket_exclusiveServer.set(this, void 0);
@@ -31,15 +40,22 @@ class PondSocket {
         _PondSocket_middleware.set(this, void 0);
         _PondSocket_maxMessageSize.set(this, void 0);
         _PondSocket_heartbeatMs.set(this, void 0);
+        _PondSocket_closeHttpServerOnShutdown.set(this, void 0);
+        _PondSocket_upgradeHandler.set(this, void 0);
         _PondSocket_heartbeatTimer.set(this, null);
         _PondSocket_backendReady.set(this, null);
+        _PondSocket_backendError.set(this, null);
+        _PondSocket_serverError.set(this, null);
+        _PondSocket_shutdownPromise.set(this, null);
         __classPrivateFieldSet(this, _PondSocket_middleware, new middleware_1.Middleware(), "f");
         __classPrivateFieldSet(this, _PondSocket_exclusiveServer, exclusiveServer, "f");
         __classPrivateFieldSet(this, _PondSocket_server, server !== null && server !== void 0 ? server : new http_1.Server(), "f");
         __classPrivateFieldSet(this, _PondSocket_backend, distributedBackend !== null && distributedBackend !== void 0 ? distributedBackend : null, "f");
         __classPrivateFieldSet(this, _PondSocket_maxMessageSize, maxMessageSize, "f");
         __classPrivateFieldSet(this, _PondSocket_heartbeatMs, heartbeatInterval, "f");
+        __classPrivateFieldSet(this, _PondSocket_closeHttpServerOnShutdown, closeHttpServerOnShutdown, "f");
         __classPrivateFieldSet(this, _PondSocket_socketServer, socketServer !== null && socketServer !== void 0 ? socketServer : new ws_1.WebSocketServer({ noServer: true }), "f");
+        __classPrivateFieldSet(this, _PondSocket_upgradeHandler, __classPrivateFieldGet(this, _PondSocket_instances, "m", _PondSocket_handleUpgrade).bind(this), "f");
         __classPrivateFieldGet(this, _PondSocket_instances, "m", _PondSocket_init).call(this);
     }
     /**
@@ -52,34 +68,35 @@ class PondSocket {
      * Close the server
      */
     close(callback, timeout = 5000) {
-        var _a, _b;
-        if (__classPrivateFieldGet(this, _PondSocket_heartbeatTimer, "f")) {
-            clearInterval(__classPrivateFieldGet(this, _PondSocket_heartbeatTimer, "f"));
-            __classPrivateFieldSet(this, _PondSocket_heartbeatTimer, null, "f");
+        this.closeAsync(timeout)
+            .then(() => callback === null || callback === void 0 ? void 0 : callback())
+            .catch((error) => callback === null || callback === void 0 ? void 0 : callback(error instanceof Error ? error : new Error(String(error))));
+        return __classPrivateFieldGet(this, _PondSocket_server, "f");
+    }
+    closeAsync(timeout = 5000) {
+        if (__classPrivateFieldGet(this, _PondSocket_shutdownPromise, "f")) {
+            return __classPrivateFieldGet(this, _PondSocket_shutdownPromise, "f");
         }
-        __classPrivateFieldGet(this, _PondSocket_socketServer, "f").clients.forEach((socket) => {
-            if (socket.readyState === ws_1.WebSocket.OPEN) {
-                socket.close(1001, 'Server shutting down');
+        __classPrivateFieldSet(this, _PondSocket_shutdownPromise, __classPrivateFieldGet(this, _PondSocket_instances, "m", _PondSocket_shutdown).call(this, timeout), "f");
+        return __classPrivateFieldGet(this, _PondSocket_shutdownPromise, "f");
+    }
+    ready() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            yield ((_a = __classPrivateFieldGet(this, _PondSocket_backendReady, "f")) !== null && _a !== void 0 ? _a : Promise.resolve());
+            if (__classPrivateFieldGet(this, _PondSocket_backendError, "f")) {
+                throw __classPrivateFieldGet(this, _PondSocket_backendError, "f");
             }
         });
-        const forceClose = setTimeout(() => {
-            __classPrivateFieldGet(this, _PondSocket_socketServer, "f").clients.forEach((socket) => {
-                if (socket.readyState !== ws_1.WebSocket.CLOSED) {
-                    socket.terminate();
-                }
-            });
-            __classPrivateFieldGet(this, _PondSocket_socketServer, "f").close();
-        }, timeout);
-        __classPrivateFieldGet(this, _PondSocket_socketServer, "f").close(() => {
-            clearTimeout(forceClose);
-        });
-        __classPrivateFieldSet(this, _PondSocket_backendReady, (_b = (_a = __classPrivateFieldGet(this, _PondSocket_backendReady, "f")) === null || _a === void 0 ? void 0 : _a.catch(() => { }).then(() => { var _a; return (_a = __classPrivateFieldGet(this, _PondSocket_backend, "f")) === null || _a === void 0 ? void 0 : _a.cleanup(); }).catch(() => { })) !== null && _b !== void 0 ? _b : null, "f");
-        return __classPrivateFieldGet(this, _PondSocket_server, "f").close(callback);
     }
-    /**
-     * Create a new endpoint
-     */
-    createEndpoint(path, handler) {
+    isHealthy() {
+        return __classPrivateFieldGet(this, _PondSocket_backendError, "f") === null && __classPrivateFieldGet(this, _PondSocket_serverError, "f") === null && __classPrivateFieldGet(this, _PondSocket_shutdownPromise, "f") === null;
+    }
+    createEndpoint(pathOrDefinition, handler) {
+        const path = (0, pondsocket_common_1.isPondEndpointDefinition)(pathOrDefinition) ? pathOrDefinition.path : pathOrDefinition;
+        if (typeof path === 'string') {
+            (0, pondsocket_common_1.compilePondRoute)(path);
+        }
         const endpoint = new endpointEngine_1.EndpointEngine(String(path), __classPrivateFieldGet(this, _PondSocket_backend, "f"), __classPrivateFieldGet(this, _PondSocket_maxMessageSize, "f"));
         __classPrivateFieldGet(this, _PondSocket_middleware, "f").use((req, params, next) => {
             const event = (0, matcher_1.parseAddress)(path, req.address);
@@ -93,13 +110,67 @@ class PondSocket {
                 webSocketServer: __classPrivateFieldGet(this, _PondSocket_socketServer, "f"),
             };
             const context = new connectionContext_1.ConnectionContext(request, newParams);
-            return Promise.resolve(handler(context, next)).then(() => undefined);
+            let delegated = false;
+            const delegate = (error) => {
+                delegated = true;
+                return next(error);
+            };
+            return Promise.resolve(handler(context, delegate)).then(() => {
+                if (!delegated && !context.hasResponded) {
+                    context.decline('Connection handler completed without accepting or declining the request', 500);
+                }
+            });
         });
         return new endpoint_1.Endpoint(endpoint);
     }
 }
 exports.PondSocket = PondSocket;
-_PondSocket_server = new WeakMap(), _PondSocket_exclusiveServer = new WeakMap(), _PondSocket_socketServer = new WeakMap(), _PondSocket_backend = new WeakMap(), _PondSocket_middleware = new WeakMap(), _PondSocket_maxMessageSize = new WeakMap(), _PondSocket_heartbeatMs = new WeakMap(), _PondSocket_heartbeatTimer = new WeakMap(), _PondSocket_backendReady = new WeakMap(), _PondSocket_instances = new WeakSet(), _PondSocket_handleUpgrade = function _PondSocket_handleUpgrade(req, socket, head) {
+_PondSocket_server = new WeakMap(), _PondSocket_exclusiveServer = new WeakMap(), _PondSocket_socketServer = new WeakMap(), _PondSocket_backend = new WeakMap(), _PondSocket_middleware = new WeakMap(), _PondSocket_maxMessageSize = new WeakMap(), _PondSocket_heartbeatMs = new WeakMap(), _PondSocket_closeHttpServerOnShutdown = new WeakMap(), _PondSocket_upgradeHandler = new WeakMap(), _PondSocket_heartbeatTimer = new WeakMap(), _PondSocket_backendReady = new WeakMap(), _PondSocket_backendError = new WeakMap(), _PondSocket_serverError = new WeakMap(), _PondSocket_shutdownPromise = new WeakMap(), _PondSocket_instances = new WeakSet(), _PondSocket_shutdown = function _PondSocket_shutdown(timeout) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        if (__classPrivateFieldGet(this, _PondSocket_heartbeatTimer, "f")) {
+            clearInterval(__classPrivateFieldGet(this, _PondSocket_heartbeatTimer, "f"));
+            __classPrivateFieldSet(this, _PondSocket_heartbeatTimer, null, "f");
+        }
+        __classPrivateFieldGet(this, _PondSocket_server, "f").off('upgrade', __classPrivateFieldGet(this, _PondSocket_upgradeHandler, "f"));
+        __classPrivateFieldGet(this, _PondSocket_socketServer, "f").clients.forEach((socket) => {
+            if (socket.readyState === ws_1.WebSocket.OPEN) {
+                socket.close(1001, 'Server shutting down');
+            }
+        });
+        const closeSockets = new Promise((resolve) => {
+            var _a;
+            const forceClose = setTimeout(() => {
+                __classPrivateFieldGet(this, _PondSocket_socketServer, "f").clients.forEach((socket) => {
+                    if (socket.readyState !== ws_1.WebSocket.CLOSED) {
+                        socket.terminate();
+                    }
+                });
+                resolve();
+            }, timeout);
+            (_a = forceClose.unref) === null || _a === void 0 ? void 0 : _a.call(forceClose);
+            try {
+                __classPrivateFieldGet(this, _PondSocket_socketServer, "f").close(() => {
+                    clearTimeout(forceClose);
+                    resolve();
+                });
+            }
+            catch (_b) {
+                clearTimeout(forceClose);
+                resolve();
+            }
+        });
+        const cleanupBackend = ((_a = __classPrivateFieldGet(this, _PondSocket_backendReady, "f")) !== null && _a !== void 0 ? _a : Promise.resolve())
+            .catch(() => { })
+            .then(() => { var _a; return (_a = __classPrivateFieldGet(this, _PondSocket_backend, "f")) === null || _a === void 0 ? void 0 : _a.cleanup(); });
+        const closeHttpServer = __classPrivateFieldGet(this, _PondSocket_closeHttpServerOnShutdown, "f") && __classPrivateFieldGet(this, _PondSocket_server, "f").listening
+            ? new Promise((resolve, reject) => {
+                __classPrivateFieldGet(this, _PondSocket_server, "f").close((error) => error ? reject(error) : resolve());
+            })
+            : Promise.resolve();
+        yield Promise.all([closeSockets, cleanupBackend, closeHttpServer]);
+    });
+}, _PondSocket_handleUpgrade = function _PondSocket_handleUpgrade(req, socket, head) {
     const clientId = (0, pondsocket_common_1.uuid)();
     const request = {
         id: clientId,
@@ -125,12 +196,13 @@ _PondSocket_server = new WeakMap(), _PondSocket_exclusiveServer = new WeakMap(),
         }
     });
 }, _PondSocket_manageHeartbeat = function _PondSocket_manageHeartbeat() {
+    var _a;
     __classPrivateFieldGet(this, _PondSocket_socketServer, "f").on('connection', (socket) => {
         socket.on('pong', () => {
             socket.isAlive = true;
         });
     });
-    return setInterval(() => {
+    const timer = setInterval(() => {
         __classPrivateFieldGet(this, _PondSocket_socketServer, "f").clients.forEach((socket) => {
             if (socket.isAlive === false) {
                 return socket.terminate();
@@ -139,18 +211,20 @@ _PondSocket_server = new WeakMap(), _PondSocket_exclusiveServer = new WeakMap(),
             socket.ping();
         });
     }, __classPrivateFieldGet(this, _PondSocket_heartbeatMs, "f"));
+    (_a = timer.unref) === null || _a === void 0 ? void 0 : _a.call(timer);
+    return timer;
 }, _PondSocket_init = function _PondSocket_init() {
     var _a, _b;
     __classPrivateFieldSet(this, _PondSocket_heartbeatTimer, __classPrivateFieldGet(this, _PondSocket_instances, "m", _PondSocket_manageHeartbeat).call(this), "f");
     __classPrivateFieldSet(this, _PondSocket_backendReady, (_b = (_a = __classPrivateFieldGet(this, _PondSocket_backend, "f")) === null || _a === void 0 ? void 0 : _a.initialize().catch((error) => {
-        __classPrivateFieldGet(this, _PondSocket_server, "f").emit('error', error);
+        __classPrivateFieldSet(this, _PondSocket_backendError, error instanceof Error ? error : new Error(String(error)), "f");
     })) !== null && _b !== void 0 ? _b : null, "f");
     __classPrivateFieldGet(this, _PondSocket_server, "f").on('error', (error) => {
+        __classPrivateFieldSet(this, _PondSocket_serverError, error, "f");
         if (__classPrivateFieldGet(this, _PondSocket_heartbeatTimer, "f")) {
             clearInterval(__classPrivateFieldGet(this, _PondSocket_heartbeatTimer, "f"));
             __classPrivateFieldSet(this, _PondSocket_heartbeatTimer, null, "f");
         }
-        throw new Error(error.message);
     });
     __classPrivateFieldGet(this, _PondSocket_server, "f").on('close', () => {
         if (__classPrivateFieldGet(this, _PondSocket_heartbeatTimer, "f")) {
@@ -158,7 +232,7 @@ _PondSocket_server = new WeakMap(), _PondSocket_exclusiveServer = new WeakMap(),
             __classPrivateFieldSet(this, _PondSocket_heartbeatTimer, null, "f");
         }
     });
-    __classPrivateFieldGet(this, _PondSocket_server, "f").on('upgrade', __classPrivateFieldGet(this, _PondSocket_instances, "m", _PondSocket_handleUpgrade).bind(this));
+    __classPrivateFieldGet(this, _PondSocket_server, "f").on('upgrade', __classPrivateFieldGet(this, _PondSocket_upgradeHandler, "f"));
 }, _PondSocket_getCookies = function _PondSocket_getCookies(headers) {
     const cookieHeader = headers.cookie;
     if (!cookieHeader) {
@@ -173,7 +247,12 @@ _PondSocket_server = new WeakMap(), _PondSocket_exclusiveServer = new WeakMap(),
         }
         const name = trimmed.slice(0, eqIndex);
         const value = trimmed.slice(eqIndex + 1);
-        cookies[name] = decodeURIComponent(value);
+        try {
+            cookies[name] = decodeURIComponent(value);
+        }
+        catch (_a) {
+            cookies[name] = value;
+        }
         return cookies;
     }, {});
 };

package/{types.d.ts → dist/types.d.ts}

@@ -14,6 +14,7 @@ export interface RedisDistributedBackendOptions {
     onError?: (error: Error) => void;
 }
 export interface PondSocketOptions {
+    closeHttpServerOnShutdown?: boolean;
     server?: HTTPServer;
     socketServer?: WebSocketServer;
     exclusiveServer?: boolean;

package/{wrappers → dist/wrappers}/channel.d.ts

@@ -1,4 +1,4 @@
-import { AnyPondSchema, AssignsOf, EventsOf, EventPayload, PresenceOf, UserData, UserAssigns, UserPresences } from '@eleven-am/pondsocket-common';
+import { AnyPondSchema, AssignsOf, EventsOf, EventPayload, PresenceOf, RouteParamsArguments, UserData, UserAssigns, UserPresences } from '@eleven-am/pondsocket-common';
 import { ChannelEngine } from '../engines/channelEngine';
 export declare class Channel<Schema extends AnyPondSchema = AnyPondSchema> {
     #private;
@@ -6,7 +6,7 @@ export declare class Channel<Schema extends AnyPondSchema = AnyPondSchema> {
     /**
      * Gets a user's data
      */
-    getUserData(userId: string): UserData<PresenceOf<Schema>, AssignsOf<Schema>> | null;
+    getUserData(userId: string): UserData<PresenceOf<Schema>, AssignsOf<Schema>>;
     /**
      * Gets all presence data
      */
@@ -18,15 +18,15 @@ export declare class Channel<Schema extends AnyPondSchema = AnyPondSchema> {
     /**
      * Broadcasts a message to all users
      */
-    broadcast<Event extends Extract<keyof EventsOf<Schema>, string>>(event: Event, payload: EventPayload<EventsOf<Schema>, Event>): this;
+    broadcast<Event extends Extract<keyof EventsOf<Schema>, string>>(event: Event, payload: EventPayload<EventsOf<Schema>, Event>, ...args: RouteParamsArguments<Event>): this;
     /**
      * Broadcasts a message from a specific user to all others
      */
-    broadcastFrom<Event extends Extract<keyof EventsOf<Schema>, string>>(userId: string, event: Event, payload: EventPayload<EventsOf<Schema>, Event>): this;
+    broadcastFrom<Event extends Extract<keyof EventsOf<Schema>, string>>(userId: string, event: Event, payload: EventPayload<EventsOf<Schema>, Event>, ...args: RouteParamsArguments<Event>): this;
     /**
      * Broadcasts a message to specific users
      */
-    broadcastTo<Event extends Extract<keyof EventsOf<Schema>, string>>(userIds: string | string[], event: Event, payload: EventPayload<EventsOf<Schema>, Event>): this;
+    broadcastTo<Event extends Extract<keyof EventsOf<Schema>, string>>(userIds: string | string[], event: Event, payload: EventPayload<EventsOf<Schema>, Event>, ...args: RouteParamsArguments<Event>): this;
     /**
      * Kicks a user from the channel
      */

package/{wrappers → dist/wrappers}/channel.js

@@ -40,23 +40,26 @@ class Channel {
     /**
      * Broadcasts a message to all users
      */
-    broadcast(event, payload) {
-        __classPrivateFieldGet(this, _Channel_engine, "f").sendMessage(pondsocket_common_1.SystemSender.CHANNEL, pondsocket_common_1.ChannelReceiver.ALL_USERS, pondsocket_common_1.ServerActions.BROADCAST, event, payload);
+    broadcast(event, payload, ...args) {
+        var _a;
+        __classPrivateFieldGet(this, _Channel_engine, "f").sendMessage(pondsocket_common_1.SystemSender.CHANNEL, pondsocket_common_1.ChannelReceiver.ALL_USERS, pondsocket_common_1.ServerActions.BROADCAST, (0, pondsocket_common_1.buildPondRoute)(event, (_a = args[0]) !== null && _a !== void 0 ? _a : {}), payload);
         return this;
     }
     /**
      * Broadcasts a message from a specific user to all others
      */
-    broadcastFrom(userId, event, payload) {
-        __classPrivateFieldGet(this, _Channel_engine, "f").sendMessage(userId, pondsocket_common_1.ChannelReceiver.ALL_EXCEPT_SENDER, pondsocket_common_1.ServerActions.BROADCAST, event, payload);
+    broadcastFrom(userId, event, payload, ...args) {
+        var _a;
+        __classPrivateFieldGet(this, _Channel_engine, "f").sendMessage(userId, pondsocket_common_1.ChannelReceiver.ALL_EXCEPT_SENDER, pondsocket_common_1.ServerActions.BROADCAST, (0, pondsocket_common_1.buildPondRoute)(event, (_a = args[0]) !== null && _a !== void 0 ? _a : {}), payload);
         return this;
     }
     /**
      * Broadcasts a message to specific users
      */
-    broadcastTo(userIds, event, payload) {
+    broadcastTo(userIds, event, payload, ...args) {
+        var _a;
         const users = Array.isArray(userIds) ? userIds : [userIds];
-        __classPrivateFieldGet(this, _Channel_engine, "f").sendMessage(pondsocket_common_1.SystemSender.CHANNEL, users, pondsocket_common_1.ServerActions.BROADCAST, event, payload);
+        __classPrivateFieldGet(this, _Channel_engine, "f").sendMessage(pondsocket_common_1.SystemSender.CHANNEL, users, pondsocket_common_1.ServerActions.BROADCAST, (0, pondsocket_common_1.buildPondRoute)(event, (_a = args[0]) !== null && _a !== void 0 ? _a : {}), payload);
         return this;
     }
     /**

package/{wrappers → dist/wrappers}/endpoint.d.ts

@@ -1,10 +1,12 @@
-import { AnyPondSchema, PondPath } from '@eleven-am/pondsocket-common';
+import { AnyPondChannelDefinition, AnyPondSchema, PathOf, PondPath, SchemaOf } from '@eleven-am/pondsocket-common';
+import { PondChannel } from './pondChannel';
 import { AuthorizationHandler } from '../abstracts/types';
 import { EndpointEngine } from '../engines/endpointEngine';
 export declare class Endpoint {
     #private;
     constructor(engine: EndpointEngine);
-    createChannel<Path extends string, Schema extends AnyPondSchema = AnyPondSchema>(path: PondPath<Path>, handler: AuthorizationHandler<Path, Schema>): import("./pondChannel").PondChannel<Schema>;
+    createChannel<Definition extends AnyPondChannelDefinition>(definition: Definition, handler: AuthorizationHandler<PathOf<Definition>, SchemaOf<Definition>>): PondChannel<SchemaOf<Definition>>;
+    createChannel<Path extends string, Schema extends AnyPondSchema = AnyPondSchema>(path: PondPath<Path>, handler: AuthorizationHandler<Path, Schema>): PondChannel<Schema>;
     closeConnection(clientIds: string | string[]): void;
     getClients(): import("ws").WebSocket[];
 }

package/{wrappers → dist/wrappers}/pondChannel.d.ts

@@ -1,4 +1,4 @@
-import { AnyPondSchema, EventPayload, EventsOf, PondPath } from '@eleven-am/pondsocket-common';
+import { AnyPondSchema, EventPayload, EventsOf, PondPath, RouteParamsArguments } from '@eleven-am/pondsocket-common';
 import { Channel } from './channel';
 import { EventHandler, LeaveCallback, OutgoingEventHandler } from '../abstracts/types';
 import { LobbyEngine } from '../engines/lobbyEngine';
@@ -9,7 +9,7 @@ export declare class PondChannel<Schema extends AnyPondSchema = AnyPondSchema> {
     onLeave(callback: LeaveCallback): PondChannel<Schema>;
     handleOutgoingEvent<Event extends Extract<keyof EventsOf<Schema>, string>>(event: PondPath<Event>, handler: OutgoingEventHandler<Event, Schema, Event>): this;
     getChannel(channelName: string): Channel<Schema> | null;
-    broadcast<Event extends Extract<keyof EventsOf<Schema>, string>>(channelName: string, event: Event, payload: EventPayload<EventsOf<Schema>, Event>): PondChannel<Schema>;
-    broadcastFrom<Event extends Extract<keyof EventsOf<Schema>, string>>(channelName: string, userId: string, event: Event, payload: EventPayload<EventsOf<Schema>, Event>): PondChannel<Schema>;
-    broadcastTo<Event extends Extract<keyof EventsOf<Schema>, string>>(channelName: string, userIds: string | string[], event: Event, payload: EventPayload<EventsOf<Schema>, Event>): PondChannel<Schema>;
+    broadcast<Event extends Extract<keyof EventsOf<Schema>, string>>(channelName: string, event: Event, payload: EventPayload<EventsOf<Schema>, Event>, ...args: RouteParamsArguments<Event>): PondChannel<Schema>;
+    broadcastFrom<Event extends Extract<keyof EventsOf<Schema>, string>>(channelName: string, userId: string, event: Event, payload: EventPayload<EventsOf<Schema>, Event>, ...args: RouteParamsArguments<Event>): PondChannel<Schema>;
+    broadcastTo<Event extends Extract<keyof EventsOf<Schema>, string>>(channelName: string, userIds: string | string[], event: Event, payload: EventPayload<EventsOf<Schema>, Event>, ...args: RouteParamsArguments<Event>): PondChannel<Schema>;
 }

package/{wrappers → dist/wrappers}/pondChannel.js

@@ -40,16 +40,16 @@ class PondChannel {
             return null;
         }
     }
-    broadcast(channelName, event, payload) {
-        __classPrivateFieldGet(this, _PondChannel_instances, "m", _PondChannel_getChannel).call(this, channelName).broadcast(event, payload);
+    broadcast(channelName, event, payload, ...args) {
+        __classPrivateFieldGet(this, _PondChannel_instances, "m", _PondChannel_getChannel).call(this, channelName).broadcast(event, payload, ...args);
         return this;
     }
-    broadcastFrom(channelName, userId, event, payload) {
-        __classPrivateFieldGet(this, _PondChannel_instances, "m", _PondChannel_getChannel).call(this, channelName).broadcastFrom(userId, event, payload);
+    broadcastFrom(channelName, userId, event, payload, ...args) {
+        __classPrivateFieldGet(this, _PondChannel_instances, "m", _PondChannel_getChannel).call(this, channelName).broadcastFrom(userId, event, payload, ...args);
         return this;
     }
-    broadcastTo(channelName, userIds, event, payload) {
-        __classPrivateFieldGet(this, _PondChannel_instances, "m", _PondChannel_getChannel).call(this, channelName).broadcastTo(userIds, event, payload);
+    broadcastTo(channelName, userIds, event, payload, ...args) {
+        __classPrivateFieldGet(this, _PondChannel_instances, "m", _PondChannel_getChannel).call(this, channelName).broadcastTo(userIds, event, payload, ...args);
         return this;
     }
 }