@wabot-dev/framework 0.0.14 → 0.0.17

package/dist/src/node_modules/socket.io/dist/namespace.js

@@ -1,597 +0,0 @@
-import { __exports as namespace } from '../../../_virtual/namespace.js';
-import { __require as requireSocket } from './socket.js';
-import { __require as requireTypedEvents } from './typed-events.js';
-import { __require as requireSrc } from '../node_modules/debug/src/index.js';
-import { __require as requireBroadcastOperator } from './broadcast-operator.js';
-
-var hasRequiredNamespace;
-
-function requireNamespace () {
-	if (hasRequiredNamespace) return namespace;
-	hasRequiredNamespace = 1;
-	(function (exports) {
-		var __importDefault = (namespace && namespace.__importDefault) || function (mod) {
-		    return (mod && mod.__esModule) ? mod : { "default": mod };
-		};
-		Object.defineProperty(exports, "__esModule", { value: true });
-		exports.Namespace = exports.RESERVED_EVENTS = void 0;
-		const socket_1 = requireSocket();
-		const typed_events_1 = requireTypedEvents();
-		const debug_1 = __importDefault(requireSrc());
-		const broadcast_operator_1 = requireBroadcastOperator();
-		const debug = (0, debug_1.default)("socket.io:namespace");
-		exports.RESERVED_EVENTS = new Set(["connect", "connection", "new_namespace"]);
-		/**
-		 * A Namespace is a communication channel that allows you to split the logic of your application over a single shared
-		 * connection.
-		 *
-		 * Each namespace has its own:
-		 *
-		 * - event handlers
-		 *
-		 * ```
-		 * io.of("/orders").on("connection", (socket) => {
-		 *   socket.on("order:list", () => {});
-		 *   socket.on("order:create", () => {});
-		 * });
-		 *
-		 * io.of("/users").on("connection", (socket) => {
-		 *   socket.on("user:list", () => {});
-		 * });
-		 * ```
-		 *
-		 * - rooms
-		 *
-		 * ```
-		 * const orderNamespace = io.of("/orders");
-		 *
-		 * orderNamespace.on("connection", (socket) => {
-		 *   socket.join("room1");
-		 *   orderNamespace.to("room1").emit("hello");
-		 * });
-		 *
-		 * const userNamespace = io.of("/users");
-		 *
-		 * userNamespace.on("connection", (socket) => {
-		 *   socket.join("room1"); // distinct from the room in the "orders" namespace
-		 *   userNamespace.to("room1").emit("holà");
-		 * });
-		 * ```
-		 *
-		 * - middlewares
-		 *
-		 * ```
-		 * const orderNamespace = io.of("/orders");
-		 *
-		 * orderNamespace.use((socket, next) => {
-		 *   // ensure the socket has access to the "orders" namespace
-		 * });
-		 *
-		 * const userNamespace = io.of("/users");
-		 *
-		 * userNamespace.use((socket, next) => {
-		 *   // ensure the socket has access to the "users" namespace
-		 * });
-		 * ```
-		 */
-		class Namespace extends typed_events_1.StrictEventEmitter {
-		    /**
-		     * Namespace constructor.
-		     *
-		     * @param server instance
-		     * @param name
-		     */
-		    constructor(server, name) {
-		        super();
-		        /**
-		         * A map of currently connected sockets.
-		         */
-		        this.sockets = new Map();
-		        /**
-		         * A map of currently connecting sockets.
-		         */
-		        this._preConnectSockets = new Map();
-		        this._fns = [];
-		        /** @private */
-		        this._ids = 0;
-		        this.server = server;
-		        this.name = name;
-		        this._initAdapter();
-		    }
-		    /**
-		     * Initializes the `Adapter` for this nsp.
-		     * Run upon changing adapter by `Server#adapter`
-		     * in addition to the constructor.
-		     *
-		     * @private
-		     */
-		    _initAdapter() {
-		        // @ts-ignore
-		        this.adapter = new (this.server.adapter())(this);
-		    }
-		    /**
-		     * Registers a middleware, which is a function that gets executed for every incoming {@link Socket}.
-		     *
-		     * @example
-		     * const myNamespace = io.of("/my-namespace");
-		     *
-		     * myNamespace.use((socket, next) => {
-		     *   // ...
-		     *   next();
-		     * });
-		     *
-		     * @param fn - the middleware function
-		     */
-		    use(fn) {
-		        this._fns.push(fn);
-		        return this;
-		    }
-		    /**
-		     * Executes the middleware for an incoming client.
-		     *
-		     * @param socket - the socket that will get added
-		     * @param fn - last fn call in the middleware
-		     * @private
-		     */
-		    run(socket, fn) {
-		        if (!this._fns.length)
-		            return fn();
-		        const fns = this._fns.slice(0);
-		        function run(i) {
-		            fns[i](socket, (err) => {
-		                // upon error, short-circuit
-		                if (err)
-		                    return fn(err);
-		                // if no middleware left, summon callback
-		                if (!fns[i + 1])
-		                    return fn();
-		                // go on to next
-		                run(i + 1);
-		            });
-		        }
-		        run(0);
-		    }
-		    /**
-		     * Targets a room when emitting.
-		     *
-		     * @example
-		     * const myNamespace = io.of("/my-namespace");
-		     *
-		     * // the “foo” event will be broadcast to all connected clients in the “room-101” room
-		     * myNamespace.to("room-101").emit("foo", "bar");
-		     *
-		     * // with an array of rooms (a client will be notified at most once)
-		     * myNamespace.to(["room-101", "room-102"]).emit("foo", "bar");
-		     *
-		     * // with multiple chained calls
-		     * myNamespace.to("room-101").to("room-102").emit("foo", "bar");
-		     *
-		     * @param room - a room, or an array of rooms
-		     * @return a new {@link BroadcastOperator} instance for chaining
-		     */
-		    to(room) {
-		        return new broadcast_operator_1.BroadcastOperator(this.adapter).to(room);
-		    }
-		    /**
-		     * Targets a room when emitting. Similar to `to()`, but might feel clearer in some cases:
-		     *
-		     * @example
-		     * const myNamespace = io.of("/my-namespace");
-		     *
-		     * // disconnect all clients in the "room-101" room
-		     * myNamespace.in("room-101").disconnectSockets();
-		     *
-		     * @param room - a room, or an array of rooms
-		     * @return a new {@link BroadcastOperator} instance for chaining
-		     */
-		    in(room) {
-		        return new broadcast_operator_1.BroadcastOperator(this.adapter).in(room);
-		    }
-		    /**
-		     * Excludes a room when emitting.
-		     *
-		     * @example
-		     * const myNamespace = io.of("/my-namespace");
-		     *
-		     * // the "foo" event will be broadcast to all connected clients, except the ones that are in the "room-101" room
-		     * myNamespace.except("room-101").emit("foo", "bar");
-		     *
-		     * // with an array of rooms
-		     * myNamespace.except(["room-101", "room-102"]).emit("foo", "bar");
-		     *
-		     * // with multiple chained calls
-		     * myNamespace.except("room-101").except("room-102").emit("foo", "bar");
-		     *
-		     * @param room - a room, or an array of rooms
-		     * @return a new {@link BroadcastOperator} instance for chaining
-		     */
-		    except(room) {
-		        return new broadcast_operator_1.BroadcastOperator(this.adapter).except(room);
-		    }
-		    /**
-		     * Adds a new client.
-		     *
-		     * @return {Socket}
-		     * @private
-		     */
-		    async _add(client, auth, fn) {
-		        var _a;
-		        debug("adding socket to nsp %s", this.name);
-		        const socket = await this._createSocket(client, auth);
-		        this._preConnectSockets.set(socket.id, socket);
-		        if (
-		        // @ts-ignore
-		        ((_a = this.server.opts.connectionStateRecovery) === null || _a === void 0 ? void 0 : _a.skipMiddlewares) &&
-		            socket.recovered &&
-		            client.conn.readyState === "open") {
-		            return this._doConnect(socket, fn);
-		        }
-		        this.run(socket, (err) => {
-		            process.nextTick(() => {
-		                if ("open" !== client.conn.readyState) {
-		                    debug("next called after client was closed - ignoring socket");
-		                    socket._cleanup();
-		                    return;
-		                }
-		                if (err) {
-		                    debug("middleware error, sending CONNECT_ERROR packet to the client");
-		                    socket._cleanup();
-		                    if (client.conn.protocol === 3) {
-		                        return socket._error(err.data || err.message);
-		                    }
-		                    else {
-		                        return socket._error({
-		                            message: err.message,
-		                            data: err.data,
-		                        });
-		                    }
-		                }
-		                this._doConnect(socket, fn);
-		            });
-		        });
-		    }
-		    async _createSocket(client, auth) {
-		        const sessionId = auth.pid;
-		        const offset = auth.offset;
-		        if (
-		        // @ts-ignore
-		        this.server.opts.connectionStateRecovery &&
-		            typeof sessionId === "string" &&
-		            typeof offset === "string") {
-		            let session;
-		            try {
-		                session = await this.adapter.restoreSession(sessionId, offset);
-		            }
-		            catch (e) {
-		                debug("error while restoring session: %s", e);
-		            }
-		            if (session) {
-		                debug("connection state recovered for sid %s", session.sid);
-		                return new socket_1.Socket(this, client, auth, session);
-		            }
-		        }
-		        return new socket_1.Socket(this, client, auth);
-		    }
-		    _doConnect(socket, fn) {
-		        this._preConnectSockets.delete(socket.id);
-		        this.sockets.set(socket.id, socket);
-		        // it's paramount that the internal `onconnect` logic
-		        // fires before user-set events to prevent state order
-		        // violations (such as a disconnection before the connection
-		        // logic is complete)
-		        socket._onconnect();
-		        if (fn)
-		            fn(socket);
-		        // fire user-set events
-		        this.emitReserved("connect", socket);
-		        this.emitReserved("connection", socket);
-		    }
-		    /**
-		     * Removes a client. Called by each `Socket`.
-		     *
-		     * @private
-		     */
-		    _remove(socket) {
-		        this.sockets.delete(socket.id) || this._preConnectSockets.delete(socket.id);
-		    }
-		    /**
-		     * Emits to all connected clients.
-		     *
-		     * @example
-		     * const myNamespace = io.of("/my-namespace");
-		     *
-		     * myNamespace.emit("hello", "world");
-		     *
-		     * // all serializable datastructures are supported (no need to call JSON.stringify)
-		     * myNamespace.emit("hello", 1, "2", { 3: ["4"], 5: Uint8Array.from([6]) });
-		     *
-		     * // with an acknowledgement from the clients
-		     * myNamespace.timeout(1000).emit("some-event", (err, responses) => {
-		     *   if (err) {
-		     *     // some clients did not acknowledge the event in the given delay
-		     *   } else {
-		     *     console.log(responses); // one response per client
-		     *   }
-		     * });
-		     *
-		     * @return Always true
-		     */
-		    emit(ev, ...args) {
-		        return new broadcast_operator_1.BroadcastOperator(this.adapter).emit(ev, ...args);
-		    }
-		    /**
-		     * Sends a `message` event to all clients.
-		     *
-		     * This method mimics the WebSocket.send() method.
-		     *
-		     * @see https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/send
-		     *
-		     * @example
-		     * const myNamespace = io.of("/my-namespace");
-		     *
-		     * myNamespace.send("hello");
-		     *
-		     * // this is equivalent to
-		     * myNamespace.emit("message", "hello");
-		     *
-		     * @return self
-		     */
-		    send(...args) {
-		        // This type-cast is needed because EmitEvents likely doesn't have `message` as a key.
-		        // if you specify the EmitEvents, the type of args will be never.
-		        this.emit("message", ...args);
-		        return this;
-		    }
-		    /**
-		     * Sends a `message` event to all clients. Sends a `message` event. Alias of {@link send}.
-		     *
-		     * @return self
-		     */
-		    write(...args) {
-		        // This type-cast is needed because EmitEvents likely doesn't have `message` as a key.
-		        // if you specify the EmitEvents, the type of args will be never.
-		        this.emit("message", ...args);
-		        return this;
-		    }
-		    /**
-		     * Sends a message to the other Socket.IO servers of the cluster.
-		     *
-		     * @example
-		     * const myNamespace = io.of("/my-namespace");
-		     *
-		     * myNamespace.serverSideEmit("hello", "world");
-		     *
-		     * myNamespace.on("hello", (arg1) => {
-		     *   console.log(arg1); // prints "world"
-		     * });
-		     *
-		     * // acknowledgements (without binary content) are supported too:
-		     * myNamespace.serverSideEmit("ping", (err, responses) => {
-		     *  if (err) {
-		     *     // some servers did not acknowledge the event in the given delay
-		     *   } else {
-		     *     console.log(responses); // one response per server (except the current one)
-		     *   }
-		     * });
-		     *
-		     * myNamespace.on("ping", (cb) => {
-		     *   cb("pong");
-		     * });
-		     *
-		     * @param ev - the event name
-		     * @param args - an array of arguments, which may include an acknowledgement callback at the end
-		     */
-		    serverSideEmit(ev, ...args) {
-		        if (exports.RESERVED_EVENTS.has(ev)) {
-		            throw new Error(`"${String(ev)}" is a reserved event name`);
-		        }
-		        args.unshift(ev);
-		        this.adapter.serverSideEmit(args);
-		        return true;
-		    }
-		    /**
-		     * Sends a message and expect an acknowledgement from the other Socket.IO servers of the cluster.
-		     *
-		     * @example
-		     * const myNamespace = io.of("/my-namespace");
-		     *
-		     * try {
-		     *   const responses = await myNamespace.serverSideEmitWithAck("ping");
-		     *   console.log(responses); // one response per server (except the current one)
-		     * } catch (e) {
-		     *   // some servers did not acknowledge the event in the given delay
-		     * }
-		     *
-		     * @param ev - the event name
-		     * @param args - an array of arguments
-		     *
-		     * @return a Promise that will be fulfilled when all servers have acknowledged the event
-		     */
-		    serverSideEmitWithAck(ev, ...args) {
-		        return new Promise((resolve, reject) => {
-		            args.push((err, responses) => {
-		                if (err) {
-		                    err.responses = responses;
-		                    return reject(err);
-		                }
-		                else {
-		                    return resolve(responses);
-		                }
-		            });
-		            this.serverSideEmit(ev, ...args);
-		        });
-		    }
-		    /**
-		     * Called when a packet is received from another Socket.IO server
-		     *
-		     * @param args - an array of arguments, which may include an acknowledgement callback at the end
-		     *
-		     * @private
-		     */
-		    _onServerSideEmit(args) {
-		        super.emitUntyped.apply(this, args);
-		    }
-		    /**
-		     * Gets a list of clients.
-		     *
-		     * @deprecated this method will be removed in the next major release, please use {@link Namespace#serverSideEmit} or
-		     * {@link Namespace#fetchSockets} instead.
-		     */
-		    allSockets() {
-		        return new broadcast_operator_1.BroadcastOperator(this.adapter).allSockets();
-		    }
-		    /**
-		     * Sets the compress flag.
-		     *
-		     * @example
-		     * const myNamespace = io.of("/my-namespace");
-		     *
-		     * myNamespace.compress(false).emit("hello");
-		     *
-		     * @param compress - if `true`, compresses the sending data
-		     * @return self
-		     */
-		    compress(compress) {
-		        return new broadcast_operator_1.BroadcastOperator(this.adapter).compress(compress);
-		    }
-		    /**
-		     * Sets a modifier for a subsequent event emission that the event data may be lost if the client is not ready to
-		     * receive messages (because of network slowness or other issues, or because they’re connected through long polling
-		     * and is in the middle of a request-response cycle).
-		     *
-		     * @example
-		     * const myNamespace = io.of("/my-namespace");
-		     *
-		     * myNamespace.volatile.emit("hello"); // the clients may or may not receive it
-		     *
-		     * @return self
-		     */
-		    get volatile() {
-		        return new broadcast_operator_1.BroadcastOperator(this.adapter).volatile;
-		    }
-		    /**
-		     * Sets a modifier for a subsequent event emission that the event data will only be broadcast to the current node.
-		     *
-		     * @example
-		     * const myNamespace = io.of("/my-namespace");
-		     *
-		     * // the “foo” event will be broadcast to all connected clients on this node
-		     * myNamespace.local.emit("foo", "bar");
-		     *
-		     * @return a new {@link BroadcastOperator} instance for chaining
-		     */
-		    get local() {
-		        return new broadcast_operator_1.BroadcastOperator(this.adapter).local;
-		    }
-		    /**
-		     * Adds a timeout in milliseconds for the next operation.
-		     *
-		     * @example
-		     * const myNamespace = io.of("/my-namespace");
-		     *
-		     * myNamespace.timeout(1000).emit("some-event", (err, responses) => {
-		     *   if (err) {
-		     *     // some clients did not acknowledge the event in the given delay
-		     *   } else {
-		     *     console.log(responses); // one response per client
-		     *   }
-		     * });
-		     *
-		     * @param timeout
-		     */
-		    timeout(timeout) {
-		        return new broadcast_operator_1.BroadcastOperator(this.adapter).timeout(timeout);
-		    }
-		    /**
-		     * Returns the matching socket instances.
-		     *
-		     * Note: this method also works within a cluster of multiple Socket.IO servers, with a compatible {@link Adapter}.
-		     *
-		     * @example
-		     * const myNamespace = io.of("/my-namespace");
-		     *
-		     * // return all Socket instances
-		     * const sockets = await myNamespace.fetchSockets();
-		     *
-		     * // return all Socket instances in the "room1" room
-		     * const sockets = await myNamespace.in("room1").fetchSockets();
-		     *
-		     * for (const socket of sockets) {
-		     *   console.log(socket.id);
-		     *   console.log(socket.handshake);
-		     *   console.log(socket.rooms);
-		     *   console.log(socket.data);
-		     *
-		     *   socket.emit("hello");
-		     *   socket.join("room1");
-		     *   socket.leave("room2");
-		     *   socket.disconnect();
-		     * }
-		     */
-		    fetchSockets() {
-		        return new broadcast_operator_1.BroadcastOperator(this.adapter).fetchSockets();
-		    }
-		    /**
-		     * Makes the matching socket instances join the specified rooms.
-		     *
-		     * Note: this method also works within a cluster of multiple Socket.IO servers, with a compatible {@link Adapter}.
-		     *
-		     * @example
-		     * const myNamespace = io.of("/my-namespace");
-		     *
-		     * // make all socket instances join the "room1" room
-		     * myNamespace.socketsJoin("room1");
-		     *
-		     * // make all socket instances in the "room1" room join the "room2" and "room3" rooms
-		     * myNamespace.in("room1").socketsJoin(["room2", "room3"]);
-		     *
-		     * @param room - a room, or an array of rooms
-		     */
-		    socketsJoin(room) {
-		        return new broadcast_operator_1.BroadcastOperator(this.adapter).socketsJoin(room);
-		    }
-		    /**
-		     * Makes the matching socket instances leave the specified rooms.
-		     *
-		     * Note: this method also works within a cluster of multiple Socket.IO servers, with a compatible {@link Adapter}.
-		     *
-		     * @example
-		     * const myNamespace = io.of("/my-namespace");
-		     *
-		     * // make all socket instances leave the "room1" room
-		     * myNamespace.socketsLeave("room1");
-		     *
-		     * // make all socket instances in the "room1" room leave the "room2" and "room3" rooms
-		     * myNamespace.in("room1").socketsLeave(["room2", "room3"]);
-		     *
-		     * @param room - a room, or an array of rooms
-		     */
-		    socketsLeave(room) {
-		        return new broadcast_operator_1.BroadcastOperator(this.adapter).socketsLeave(room);
-		    }
-		    /**
-		     * Makes the matching socket instances disconnect.
-		     *
-		     * Note: this method also works within a cluster of multiple Socket.IO servers, with a compatible {@link Adapter}.
-		     *
-		     * @example
-		     * const myNamespace = io.of("/my-namespace");
-		     *
-		     * // make all socket instances disconnect (the connections might be kept alive for other namespaces)
-		     * myNamespace.disconnectSockets();
-		     *
-		     * // make all socket instances in the "room1" room disconnect and close the underlying connections
-		     * myNamespace.in("room1").disconnectSockets(true);
-		     *
-		     * @param close - whether to close the underlying connection
-		     */
-		    disconnectSockets(close = false) {
-		        return new broadcast_operator_1.BroadcastOperator(this.adapter).disconnectSockets(close);
-		    }
-		}
-		exports.Namespace = Namespace; 
-	} (namespace));
-	return namespace;
-}
-
-export { requireNamespace as __require };

package/dist/src/node_modules/socket.io/dist/parent-namespace.js

@@ -1,101 +0,0 @@
-import { __exports as parentNamespace } from '../../../_virtual/parent-namespace.js';
-import { __require as requireNamespace } from './namespace.js';
-import { __require as requireDist } from '../../socket.io-adapter/dist/index.js';
-import { __require as requireSrc } from '../node_modules/debug/src/index.js';
-
-var hasRequiredParentNamespace;
-
-function requireParentNamespace () {
-	if (hasRequiredParentNamespace) return parentNamespace;
-	hasRequiredParentNamespace = 1;
-	var __importDefault = (parentNamespace && parentNamespace.__importDefault) || function (mod) {
-	    return (mod && mod.__esModule) ? mod : { "default": mod };
-	};
-	Object.defineProperty(parentNamespace, "__esModule", { value: true });
-	parentNamespace.ParentNamespace = void 0;
-	const namespace_1 = requireNamespace();
-	const socket_io_adapter_1 = requireDist();
-	const debug_1 = __importDefault(requireSrc());
-	const debug = (0, debug_1.default)("socket.io:parent-namespace");
-	/**
-	 * A parent namespace is a special {@link Namespace} that holds a list of child namespaces which were created either
-	 * with a regular expression or with a function.
-	 *
-	 * @example
-	 * const parentNamespace = io.of(/\/dynamic-\d+/);
-	 *
-	 * parentNamespace.on("connection", (socket) => {
-	 *   const childNamespace = socket.nsp;
-	 * }
-	 *
-	 * // will reach all the clients that are in one of the child namespaces, like "/dynamic-101"
-	 * parentNamespace.emit("hello", "world");
-	 *
-	 */
-	class ParentNamespace extends namespace_1.Namespace {
-	    constructor(server) {
-	        super(server, "/_" + ParentNamespace.count++);
-	        this.children = new Set();
-	    }
-	    /**
-	     * @private
-	     */
-	    _initAdapter() {
-	        this.adapter = new ParentBroadcastAdapter(this);
-	    }
-	    emit(ev, ...args) {
-	        this.children.forEach((nsp) => {
-	            nsp.emit(ev, ...args);
-	        });
-	        return true;
-	    }
-	    createChild(name) {
-	        debug("creating child namespace %s", name);
-	        const namespace = new namespace_1.Namespace(this.server, name);
-	        this["_fns"].forEach((fn) => namespace.use(fn));
-	        this.listeners("connect").forEach((listener) => namespace.on("connect", listener));
-	        this.listeners("connection").forEach((listener) => namespace.on("connection", listener));
-	        this.children.add(namespace);
-	        if (this.server._opts.cleanupEmptyChildNamespaces) {
-	            const remove = namespace._remove;
-	            namespace._remove = (socket) => {
-	                remove.call(namespace, socket);
-	                if (namespace.sockets.size === 0) {
-	                    debug("closing child namespace %s", name);
-	                    namespace.adapter.close();
-	                    this.server._nsps.delete(namespace.name);
-	                    this.children.delete(namespace);
-	                }
-	            };
-	        }
-	        this.server._nsps.set(name, namespace);
-	        // @ts-ignore
-	        this.server.sockets.emitReserved("new_namespace", namespace);
-	        return namespace;
-	    }
-	    fetchSockets() {
-	        // note: we could make the fetchSockets() method work for dynamic namespaces created with a regex (by sending the
-	        // regex to the other Socket.IO servers, and returning the sockets of each matching namespace for example), but
-	        // the behavior for namespaces created with a function is less clear
-	        // note²: we cannot loop over each children namespace, because with multiple Socket.IO servers, a given namespace
-	        // may exist on one node but not exist on another (since it is created upon client connection)
-	        throw new Error("fetchSockets() is not supported on parent namespaces");
-	    }
-	}
-	parentNamespace.ParentNamespace = ParentNamespace;
-	ParentNamespace.count = 0;
-	/**
-	 * A dummy adapter that only supports broadcasting to child (concrete) namespaces.
-	 * @private file
-	 */
-	class ParentBroadcastAdapter extends socket_io_adapter_1.Adapter {
-	    broadcast(packet, opts) {
-	        this.nsp.children.forEach((nsp) => {
-	            nsp.adapter.broadcast(packet, opts);
-	        });
-	    }
-	}
-	return parentNamespace;
-}
-
-export { requireParentNamespace as __require };