@wabot-dev/framework 0.0.12 → 0.0.14

package/dist/src/node_modules/side-channel-map/index.js

@@ -0,0 +1,82 @@
+import { __require as requireGetIntrinsic } from '../get-intrinsic/index.js';
+import { __require as requireCallBound } from '../call-bound/index.js';
+import { __require as requireObjectInspect } from '../object-inspect/index.js';
+import { __require as requireType } from '../es-errors/type.js';
+
+var sideChannelMap;
+var hasRequiredSideChannelMap;
+
+function requireSideChannelMap () {
+	if (hasRequiredSideChannelMap) return sideChannelMap;
+	hasRequiredSideChannelMap = 1;
+
+	var GetIntrinsic = /*@__PURE__*/ requireGetIntrinsic();
+	var callBound = /*@__PURE__*/ requireCallBound();
+	var inspect = /*@__PURE__*/ requireObjectInspect();
+
+	var $TypeError = /*@__PURE__*/ requireType();
+	var $Map = GetIntrinsic('%Map%', true);
+
+	/** @type {<K, V>(thisArg: Map<K, V>, key: K) => V} */
+	var $mapGet = callBound('Map.prototype.get', true);
+	/** @type {<K, V>(thisArg: Map<K, V>, key: K, value: V) => void} */
+	var $mapSet = callBound('Map.prototype.set', true);
+	/** @type {<K, V>(thisArg: Map<K, V>, key: K) => boolean} */
+	var $mapHas = callBound('Map.prototype.has', true);
+	/** @type {<K, V>(thisArg: Map<K, V>, key: K) => boolean} */
+	var $mapDelete = callBound('Map.prototype.delete', true);
+	/** @type {<K, V>(thisArg: Map<K, V>) => number} */
+	var $mapSize = callBound('Map.prototype.size', true);
+
+	/** @type {import('.')} */
+	sideChannelMap = !!$Map && /** @type {Exclude<import('.'), false>} */ function getSideChannelMap() {
+		/** @typedef {ReturnType<typeof getSideChannelMap>} Channel */
+		/** @typedef {Parameters<Channel['get']>[0]} K */
+		/** @typedef {Parameters<Channel['set']>[1]} V */
+
+		/** @type {Map<K, V> | undefined} */ var $m;
+
+		/** @type {Channel} */
+		var channel = {
+			assert: function (key) {
+				if (!channel.has(key)) {
+					throw new $TypeError('Side channel does not contain ' + inspect(key));
+				}
+			},
+			'delete': function (key) {
+				if ($m) {
+					var result = $mapDelete($m, key);
+					if ($mapSize($m) === 0) {
+						$m = void 0;
+					}
+					return result;
+				}
+				return false;
+			},
+			get: function (key) { // eslint-disable-line consistent-return
+				if ($m) {
+					return $mapGet($m, key);
+				}
+			},
+			has: function (key) {
+				if ($m) {
+					return $mapHas($m, key);
+				}
+				return false;
+			},
+			set: function (key, value) {
+				if (!$m) {
+					// @ts-expect-error TS can't handle narrowing a variable inside a closure
+					$m = new $Map();
+				}
+				$mapSet($m, key, value);
+			}
+		};
+
+		// @ts-expect-error TODO: figure out why TS is erroring here
+		return channel;
+	};
+	return sideChannelMap;
+}
+
+export { requireSideChannelMap as __require };

package/dist/src/node_modules/side-channel-weakmap/index.js

@@ -0,0 +1,99 @@
+import { __require as requireGetIntrinsic } from '../get-intrinsic/index.js';
+import { __require as requireCallBound } from '../call-bound/index.js';
+import { __require as requireObjectInspect } from '../object-inspect/index.js';
+import { __require as requireSideChannelMap } from '../side-channel-map/index.js';
+import { __require as requireType } from '../es-errors/type.js';
+
+var sideChannelWeakmap;
+var hasRequiredSideChannelWeakmap;
+
+function requireSideChannelWeakmap () {
+	if (hasRequiredSideChannelWeakmap) return sideChannelWeakmap;
+	hasRequiredSideChannelWeakmap = 1;
+
+	var GetIntrinsic = /*@__PURE__*/ requireGetIntrinsic();
+	var callBound = /*@__PURE__*/ requireCallBound();
+	var inspect = /*@__PURE__*/ requireObjectInspect();
+	var getSideChannelMap = requireSideChannelMap();
+
+	var $TypeError = /*@__PURE__*/ requireType();
+	var $WeakMap = GetIntrinsic('%WeakMap%', true);
+
+	/** @type {<K extends object, V>(thisArg: WeakMap<K, V>, key: K) => V} */
+	var $weakMapGet = callBound('WeakMap.prototype.get', true);
+	/** @type {<K extends object, V>(thisArg: WeakMap<K, V>, key: K, value: V) => void} */
+	var $weakMapSet = callBound('WeakMap.prototype.set', true);
+	/** @type {<K extends object, V>(thisArg: WeakMap<K, V>, key: K) => boolean} */
+	var $weakMapHas = callBound('WeakMap.prototype.has', true);
+	/** @type {<K extends object, V>(thisArg: WeakMap<K, V>, key: K) => boolean} */
+	var $weakMapDelete = callBound('WeakMap.prototype.delete', true);
+
+	/** @type {import('.')} */
+	sideChannelWeakmap = $WeakMap
+		? /** @type {Exclude<import('.'), false>} */ function getSideChannelWeakMap() {
+			/** @typedef {ReturnType<typeof getSideChannelWeakMap>} Channel */
+			/** @typedef {Parameters<Channel['get']>[0]} K */
+			/** @typedef {Parameters<Channel['set']>[1]} V */
+
+			/** @type {WeakMap<K & object, V> | undefined} */ var $wm;
+			/** @type {Channel | undefined} */ var $m;
+
+			/** @type {Channel} */
+			var channel = {
+				assert: function (key) {
+					if (!channel.has(key)) {
+						throw new $TypeError('Side channel does not contain ' + inspect(key));
+					}
+				},
+				'delete': function (key) {
+					if ($WeakMap && key && (typeof key === 'object' || typeof key === 'function')) {
+						if ($wm) {
+							return $weakMapDelete($wm, key);
+						}
+					} else if (getSideChannelMap) {
+						if ($m) {
+							return $m['delete'](key);
+						}
+					}
+					return false;
+				},
+				get: function (key) {
+					if ($WeakMap && key && (typeof key === 'object' || typeof key === 'function')) {
+						if ($wm) {
+							return $weakMapGet($wm, key);
+						}
+					}
+					return $m && $m.get(key);
+				},
+				has: function (key) {
+					if ($WeakMap && key && (typeof key === 'object' || typeof key === 'function')) {
+						if ($wm) {
+							return $weakMapHas($wm, key);
+						}
+					}
+					return !!$m && $m.has(key);
+				},
+				set: function (key, value) {
+					if ($WeakMap && key && (typeof key === 'object' || typeof key === 'function')) {
+						if (!$wm) {
+							$wm = new $WeakMap();
+						}
+						$weakMapSet($wm, key, value);
+					} else if (getSideChannelMap) {
+						if (!$m) {
+							$m = getSideChannelMap();
+						}
+						// eslint-disable-next-line no-extra-parens
+						/** @type {NonNullable<typeof $m>} */ ($m).set(key, value);
+					}
+				}
+			};
+
+			// @ts-expect-error TODO: figure out why this is erroring
+			return channel;
+		}
+		: getSideChannelMap;
+	return sideChannelWeakmap;
+}
+
+export { requireSideChannelWeakmap as __require };

package/dist/src/node_modules/socket.io/dist/broadcast-operator.js

@@ -0,0 +1,448 @@
+import { __exports as broadcastOperator } from '../../../_virtual/broadcast-operator.js';
+import { __require as requireSocketTypes } from './socket-types.js';
+import { __require as requireCjs } from '../../socket.io-parser/build/cjs/index.js';
+
+var hasRequiredBroadcastOperator;
+
+function requireBroadcastOperator () {
+	if (hasRequiredBroadcastOperator) return broadcastOperator;
+	hasRequiredBroadcastOperator = 1;
+	Object.defineProperty(broadcastOperator, "__esModule", { value: true });
+	broadcastOperator.RemoteSocket = broadcastOperator.BroadcastOperator = void 0;
+	const socket_types_1 = requireSocketTypes();
+	const socket_io_parser_1 = requireCjs();
+	class BroadcastOperator {
+	    constructor(adapter, rooms = new Set(), exceptRooms = new Set(), flags = {}) {
+	        this.adapter = adapter;
+	        this.rooms = rooms;
+	        this.exceptRooms = exceptRooms;
+	        this.flags = flags;
+	    }
+	    /**
+	     * Targets a room when emitting.
+	     *
+	     * @example
+	     * // the “foo” event will be broadcast to all connected clients in the “room-101” room
+	     * io.to("room-101").emit("foo", "bar");
+	     *
+	     * // with an array of rooms (a client will be notified at most once)
+	     * io.to(["room-101", "room-102"]).emit("foo", "bar");
+	     *
+	     * // with multiple chained calls
+	     * io.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) {
+	        const rooms = new Set(this.rooms);
+	        if (Array.isArray(room)) {
+	            room.forEach((r) => rooms.add(r));
+	        }
+	        else {
+	            rooms.add(room);
+	        }
+	        return new BroadcastOperator(this.adapter, rooms, this.exceptRooms, this.flags);
+	    }
+	    /**
+	     * Targets a room when emitting. Similar to `to()`, but might feel clearer in some cases:
+	     *
+	     * @example
+	     * // disconnect all clients in the "room-101" room
+	     * io.in("room-101").disconnectSockets();
+	     *
+	     * @param room - a room, or an array of rooms
+	     * @return a new {@link BroadcastOperator} instance for chaining
+	     */
+	    in(room) {
+	        return this.to(room);
+	    }
+	    /**
+	     * Excludes a room when emitting.
+	     *
+	     * @example
+	     * // the "foo" event will be broadcast to all connected clients, except the ones that are in the "room-101" room
+	     * io.except("room-101").emit("foo", "bar");
+	     *
+	     * // with an array of rooms
+	     * io.except(["room-101", "room-102"]).emit("foo", "bar");
+	     *
+	     * // with multiple chained calls
+	     * io.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) {
+	        const exceptRooms = new Set(this.exceptRooms);
+	        if (Array.isArray(room)) {
+	            room.forEach((r) => exceptRooms.add(r));
+	        }
+	        else {
+	            exceptRooms.add(room);
+	        }
+	        return new BroadcastOperator(this.adapter, this.rooms, exceptRooms, this.flags);
+	    }
+	    /**
+	     * Sets the compress flag.
+	     *
+	     * @example
+	     * io.compress(false).emit("hello");
+	     *
+	     * @param compress - if `true`, compresses the sending data
+	     * @return a new BroadcastOperator instance
+	     */
+	    compress(compress) {
+	        const flags = Object.assign({}, this.flags, { compress });
+	        return new BroadcastOperator(this.adapter, this.rooms, this.exceptRooms, flags);
+	    }
+	    /**
+	     * 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
+	     * io.volatile.emit("hello"); // the clients may or may not receive it
+	     *
+	     * @return a new BroadcastOperator instance
+	     */
+	    get volatile() {
+	        const flags = Object.assign({}, this.flags, { volatile: true });
+	        return new BroadcastOperator(this.adapter, this.rooms, this.exceptRooms, flags);
+	    }
+	    /**
+	     * Sets a modifier for a subsequent event emission that the event data will only be broadcast to the current node.
+	     *
+	     * @example
+	     * // the “foo” event will be broadcast to all connected clients on this node
+	     * io.local.emit("foo", "bar");
+	     *
+	     * @return a new {@link BroadcastOperator} instance for chaining
+	     */
+	    get local() {
+	        const flags = Object.assign({}, this.flags, { local: true });
+	        return new BroadcastOperator(this.adapter, this.rooms, this.exceptRooms, flags);
+	    }
+	    /**
+	     * Adds a timeout in milliseconds for the next operation
+	     *
+	     * @example
+	     * io.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) {
+	        const flags = Object.assign({}, this.flags, { timeout });
+	        return new BroadcastOperator(this.adapter, this.rooms, this.exceptRooms, flags);
+	    }
+	    /**
+	     * Emits to all clients.
+	     *
+	     * @example
+	     * // the “foo” event will be broadcast to all connected clients
+	     * io.emit("foo", "bar");
+	     *
+	     * // the “foo” event will be broadcast to all connected clients in the “room-101” room
+	     * io.to("room-101").emit("foo", "bar");
+	     *
+	     * // with an acknowledgement expected from all connected clients
+	     * io.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) {
+	        if (socket_types_1.RESERVED_EVENTS.has(ev)) {
+	            throw new Error(`"${String(ev)}" is a reserved event name`);
+	        }
+	        // set up packet object
+	        const data = [ev, ...args];
+	        const packet = {
+	            type: socket_io_parser_1.PacketType.EVENT,
+	            data: data,
+	        };
+	        const withAck = typeof data[data.length - 1] === "function";
+	        if (!withAck) {
+	            this.adapter.broadcast(packet, {
+	                rooms: this.rooms,
+	                except: this.exceptRooms,
+	                flags: this.flags,
+	            });
+	            return true;
+	        }
+	        const ack = data.pop();
+	        let timedOut = false;
+	        let responses = [];
+	        const timer = setTimeout(() => {
+	            timedOut = true;
+	            ack.apply(this, [
+	                new Error("operation has timed out"),
+	                this.flags.expectSingleResponse ? null : responses,
+	            ]);
+	        }, this.flags.timeout);
+	        let expectedServerCount = -1;
+	        let actualServerCount = 0;
+	        let expectedClientCount = 0;
+	        const checkCompleteness = () => {
+	            if (!timedOut &&
+	                expectedServerCount === actualServerCount &&
+	                responses.length === expectedClientCount) {
+	                clearTimeout(timer);
+	                ack.apply(this, [
+	                    null,
+	                    this.flags.expectSingleResponse ? responses[0] : responses,
+	                ]);
+	            }
+	        };
+	        this.adapter.broadcastWithAck(packet, {
+	            rooms: this.rooms,
+	            except: this.exceptRooms,
+	            flags: this.flags,
+	        }, (clientCount) => {
+	            // each Socket.IO server in the cluster sends the number of clients that were notified
+	            expectedClientCount += clientCount;
+	            actualServerCount++;
+	            checkCompleteness();
+	        }, (clientResponse) => {
+	            // each client sends an acknowledgement
+	            responses.push(clientResponse);
+	            checkCompleteness();
+	        });
+	        this.adapter.serverCount().then((serverCount) => {
+	            expectedServerCount = serverCount;
+	            checkCompleteness();
+	        });
+	        return true;
+	    }
+	    /**
+	     * Emits an event and waits for an acknowledgement from all clients.
+	     *
+	     * @example
+	     * try {
+	     *   const responses = await io.timeout(1000).emitWithAck("some-event");
+	     *   console.log(responses); // one response per client
+	     * } catch (e) {
+	     *   // some clients did not acknowledge the event in the given delay
+	     * }
+	     *
+	     * @return a Promise that will be fulfilled when all clients have acknowledged the event
+	     */
+	    emitWithAck(ev, ...args) {
+	        return new Promise((resolve, reject) => {
+	            args.push((err, responses) => {
+	                if (err) {
+	                    err.responses = responses;
+	                    return reject(err);
+	                }
+	                else {
+	                    return resolve(responses);
+	                }
+	            });
+	            this.emit(ev, ...args);
+	        });
+	    }
+	    /**
+	     * Gets a list of clients.
+	     *
+	     * @deprecated this method will be removed in the next major release, please use {@link Server#serverSideEmit} or
+	     * {@link fetchSockets} instead.
+	     */
+	    allSockets() {
+	        if (!this.adapter) {
+	            throw new Error("No adapter for this namespace, are you trying to get the list of clients of a dynamic namespace?");
+	        }
+	        return this.adapter.sockets(this.rooms);
+	    }
+	    /**
+	     * Returns the matching socket instances. This method works across a cluster of several Socket.IO servers.
+	     *
+	     * Note: this method also works within a cluster of multiple Socket.IO servers, with a compatible {@link Adapter}.
+	     *
+	     * @example
+	     * // return all Socket instances
+	     * const sockets = await io.fetchSockets();
+	     *
+	     * // return all Socket instances in the "room1" room
+	     * const sockets = await io.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 this.adapter
+	            .fetchSockets({
+	            rooms: this.rooms,
+	            except: this.exceptRooms,
+	            flags: this.flags,
+	        })
+	            .then((sockets) => {
+	            return sockets.map((socket) => {
+	                if (socket.server) {
+	                    return socket; // local instance
+	                }
+	                else {
+	                    return new RemoteSocket(this.adapter, socket);
+	                }
+	            });
+	        });
+	    }
+	    /**
+	     * 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
+	     *
+	     * // make all socket instances join the "room1" room
+	     * io.socketsJoin("room1");
+	     *
+	     * // make all socket instances in the "room1" room join the "room2" and "room3" rooms
+	     * io.in("room1").socketsJoin(["room2", "room3"]);
+	     *
+	     * @param room - a room, or an array of rooms
+	     */
+	    socketsJoin(room) {
+	        this.adapter.addSockets({
+	            rooms: this.rooms,
+	            except: this.exceptRooms,
+	            flags: this.flags,
+	        }, Array.isArray(room) ? room : [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
+	     * // make all socket instances leave the "room1" room
+	     * io.socketsLeave("room1");
+	     *
+	     * // make all socket instances in the "room1" room leave the "room2" and "room3" rooms
+	     * io.in("room1").socketsLeave(["room2", "room3"]);
+	     *
+	     * @param room - a room, or an array of rooms
+	     */
+	    socketsLeave(room) {
+	        this.adapter.delSockets({
+	            rooms: this.rooms,
+	            except: this.exceptRooms,
+	            flags: this.flags,
+	        }, Array.isArray(room) ? room : [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
+	     * // make all socket instances disconnect (the connections might be kept alive for other namespaces)
+	     * io.disconnectSockets();
+	     *
+	     * // make all socket instances in the "room1" room disconnect and close the underlying connections
+	     * io.in("room1").disconnectSockets(true);
+	     *
+	     * @param close - whether to close the underlying connection
+	     */
+	    disconnectSockets(close = false) {
+	        this.adapter.disconnectSockets({
+	            rooms: this.rooms,
+	            except: this.exceptRooms,
+	            flags: this.flags,
+	        }, close);
+	    }
+	}
+	broadcastOperator.BroadcastOperator = BroadcastOperator;
+	/**
+	 * Expose of subset of the attributes and methods of the Socket class
+	 */
+	class RemoteSocket {
+	    constructor(adapter, details) {
+	        this.id = details.id;
+	        this.handshake = details.handshake;
+	        this.rooms = new Set(details.rooms);
+	        this.data = details.data;
+	        this.operator = new BroadcastOperator(adapter, new Set([this.id]), new Set(), {
+	            expectSingleResponse: true, // so that remoteSocket.emit() with acknowledgement behaves like socket.emit()
+	        });
+	    }
+	    /**
+	     * Adds a timeout in milliseconds for the next operation.
+	     *
+	     * @example
+	     * const sockets = await io.fetchSockets();
+	     *
+	     * for (const socket of sockets) {
+	     *   if (someCondition) {
+	     *     socket.timeout(1000).emit("some-event", (err) => {
+	     *       if (err) {
+	     *         // the client did not acknowledge the event in the given delay
+	     *       }
+	     *     });
+	     *   }
+	     * }
+	     *
+	     * // note: if possible, using a room instead of looping over all sockets is preferable
+	     * io.timeout(1000).to(someConditionRoom).emit("some-event", (err, responses) => {
+	     *   // ...
+	     * });
+	     *
+	     * @param timeout
+	     */
+	    timeout(timeout) {
+	        return this.operator.timeout(timeout);
+	    }
+	    emit(ev, ...args) {
+	        return this.operator.emit(ev, ...args);
+	    }
+	    /**
+	     * Joins a room.
+	     *
+	     * @param {String|Array} room - room or array of rooms
+	     */
+	    join(room) {
+	        return this.operator.socketsJoin(room);
+	    }
+	    /**
+	     * Leaves a room.
+	     *
+	     * @param {String} room
+	     */
+	    leave(room) {
+	        return this.operator.socketsLeave(room);
+	    }
+	    /**
+	     * Disconnects this client.
+	     *
+	     * @param {Boolean} close - if `true`, closes the underlying connection
+	     * @return {Socket} self
+	     */
+	    disconnect(close = false) {
+	        this.operator.disconnectSockets(close);
+	        return this;
+	    }
+	}
+	broadcastOperator.RemoteSocket = RemoteSocket;
+	return broadcastOperator;
+}
+
+export { requireBroadcastOperator as __require };