Changeset e29cc2e for trip-planner-front/node_modules/socket.io/dist/socket.js

Timestamp:

11/25/21 22:08:24 (3 years ago)

Author:

Ema <ema_spirova@…>

Branches:

master

Children:

8d391a1

Parents:

59329aa

Message:

primeNG components

File:

• trip-planner-front/node_modules/socket.io/dist/socket.js (modified) (14 diffs)

trip-planner-front/node_modules/socket.io/dist/socket.js

@@ -5 +5 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Socket = exports.RESERVED_EVENTS = void 0;
-const events_1 = require("events");
 const socket_io_parser_1 = require("socket.io-parser");
-const url = require("url");
 const debug_1 = __importDefault(require("debug"));
+const typed_events_1 = require("./typed-events");
 const base64id_1 = __importDefault(require("base64id"));
-const debug = debug_1.default("socket.io:socket");
+const broadcast_operator_1 = require("./broadcast-operator");
+const debug = (0, debug_1.default)("socket.io:socket");
 exports.RESERVED_EVENTS = new Set([
     "connect",
@@ -16 +16 @@
     "disconnect",
     "disconnecting",
-    // EventEmitter reserved events: https://nodejs.org/api/events.html#events_event_newlistener
     "newListener",
     "removeListener",
 ]);
-class Socket extends events_1.EventEmitter {
+class Socket extends typed_events_1.StrictEventEmitter {
     /**
      * Interface to a `Client` for a given `Namespace`.
@@ -33 +32 @@
         this.nsp = nsp;
         this.client = client;
+        /**
+         * Additional information that can be attached to the Socket instance and which will be used in the fetchSockets method
+         */
+        this.data = {};
+        this.connected = false;
         this.acks = new Map();
         this.fns = [];
         this.flags = {};
-        this._rooms = new Set();
         this.server = nsp.server;
         this.adapter = this.nsp.adapter;
@@ -46 +49 @@
             this.id = base64id_1.default.generateId(); // don't reuse the Engine.IO id because it's sensitive information
         }
-        this.connected = true;
-        this.disconnected = false;
         this.handshake = this.buildHandshake(auth);
     }
@@ -65 +66 @@
             issued: +new Date(),
             url: this.request.url,
-            query: url.parse(this.request.url, true).query,
+            // @ts-ignore
+            query: this.request._query,
             auth,
         };
@@ -79 +81 @@
             throw new Error(`"${ev}" is a reserved event name`);
         }
-        args.unshift(ev);
+        const data = [ev, ...args];
         const packet = {
             type: socket_io_parser_1.PacketType.EVENT,
-            data: args,
+            data: data,
         };
         // access last argument to see if it's an ACK callback
-        if (typeof args[args.length - 1] === "function") {
-            if (this._rooms.size || this.flags.broadcast) {
-                throw new Error("Callbacks are not supported when broadcasting");
-            }
-            debug("emitting packet with ack id %d", this.nsp._ids);
-            this.acks.set(this.nsp._ids, args.pop());
-            packet.id = this.nsp._ids++;
-        }
-        const rooms = new Set(this._rooms);
+        if (typeof data[data.length - 1] === "function") {
+            const id = this.nsp._ids++;
+            debug("emitting packet with ack id %d", id);
+            this.registerAckCallback(id, data.pop());
+            packet.id = id;
+        }
         const flags = Object.assign({}, this.flags);
-        // reset flags
-        this._rooms.clear();
         this.flags = {};
-        if (rooms.size || flags.broadcast) {
-            this.adapter.broadcast(packet, {
-                except: new Set([this.id]),
-                rooms: rooms,
-                flags: flags,
-            });
-        }
-        else {
-            // dispatch packet
-            this.packet(packet, flags);
-        }
+        this.packet(packet, flags);
         return true;
     }
     /**
+     * @private
+     */
+    registerAckCallback(id, ack) {
+        const timeout = this.flags.timeout;
+        if (timeout === undefined) {
+            this.acks.set(id, ack);
+            return;
+        }
+        const timer = setTimeout(() => {
+            debug("event with ack id %d has timed out after %d ms", id, timeout);
+            this.acks.delete(id);
+            ack.call(this, new Error("operation has timed out"));
+        }, timeout);
+        this.acks.set(id, (...args) => {
+            clearTimeout(timer);
+            ack.apply(this, [null, ...args]);
+        });
+    }
+    /**
      * Targets a room when broadcasting.
      *
-     * @param name
+     * @param room
      * @return self
      * @public
      */
-    to(name) {
-        this._rooms.add(name);
-        return this;
+    to(room) {
+        return this.newBroadcastOperator().to(room);
     }
     /**
      * Targets a room when broadcasting.
      *
-     * @param name
+     * @param room
      * @return self
      * @public
      */
-    in(name) {
-        this._rooms.add(name);
-        return this;
+    in(room) {
+        return this.newBroadcastOperator().in(room);
+    }
+    /**
+     * Excludes a room when broadcasting.
+     *
+     * @param room
+     * @return self
+     * @public
+     */
+    except(room) {
+        return this.newBroadcastOperator().except(room);
     }
     /**
@@ -205 +219 @@
     _onconnect() {
         debug("socket connected - writing packet");
+        this.connected = true;
         this.join(this.id);
         if (this.conn.protocol === 3) {
@@ -317 +332 @@
     _onerror(err) {
         if (this.listeners("error").length) {
-            super.emit("error", err);
+            this.emitReserved("error", err);
         }
         else {
@@ -336 +351 @@
             return this;
         debug("closing socket - reason %s", reason);
-        super.emit("disconnecting", reason);
+        this.emitReserved("disconnecting", reason);
         this.leaveAll();
         this.nsp._remove(this);
         this.client._remove(this);
         this.connected = false;
-        this.disconnected = true;
-        super.emit("disconnect", reason);
+        this.emitReserved("disconnect", reason);
         return;
     }
@@ -406 +420 @@
      */
     get broadcast() {
-        this.flags.broadcast = true;
-        return this;
+        return this.newBroadcastOperator();
     }
     /**
@@ -416 +429 @@
      */
     get local() {
-        this.flags.local = true;
+        return this.newBroadcastOperator().local;
+    }
+    /**
+     * Sets a modifier for a subsequent event emission that the callback will be called with an error when the
+     * given number of milliseconds have elapsed without an acknowledgement from the client:
+     *
+     * ```
+     * socket.timeout(5000).emit("my-event", (err) => {
+     *   if (err) {
+     *     // the client did not acknowledge the event in the given delay
+     *   }
+     * });
+     * ```
+     *
+     * @returns self
+     * @public
+     */
+    timeout(timeout) {
+        this.flags.timeout = timeout;
         return this;
     }
@@ -433 +464 @@
                 }
                 if (this.connected) {
-                    super.emit.apply(this, event);
+                    super.emitUntyped.apply(this, event);
                 }
                 else {
@@ -478 +509 @@
     }
     /**
+     * Whether the socket is currently disconnected
+     */
+    get disconnected() {
+        return !this.connected;
+    }
+    /**
      * A reference to the request that originated the underlying Engine.IO Socket.
      *
@@ -556 +593 @@
         return this._anyListeners || [];
     }
+    newBroadcastOperator() {
+        const flags = Object.assign({}, this.flags);
+        this.flags = {};
+        return new broadcast_operator_1.BroadcastOperator(this.adapter, new Set(), new Set([this.id]), flags);
+    }
 }
 exports.Socket = Socket;