gritty 8.0.0 → 8.1.0

package/ChangeLog

@@ -1,3 +1,8 @@
+2024.03.16, v8.1.0
+
+feature:
+- 72e34e0 gritty: serve-once v3.0.0
+
 2024.03.12, v8.0.0
 
 feature:

package/dist/gritty.js

@@ -4447,6 +4447,29 @@ class Socket extends component_emitter_1.Emitter {
          */
         this._queueSeq = 0;
         this.ids = 0;
+        /**
+         * A map containing acknowledgement handlers.
+         *
+         * The `withError` attribute is used to differentiate handlers that accept an error as first argument:
+         *
+         * - `socket.emit("test", (err, value) => { ... })` with `ackTimeout` option
+         * - `socket.timeout(5000).emit("test", (err, value) => { ... })`
+         * - `const value = await socket.emitWithAck("test")`
+         *
+         * From those that don't:
+         *
+         * - `socket.emit("test", (value) => { ... });`
+         *
+         * In the first case, the handlers will be called with an error when:
+         *
+         * - the timeout is reached
+         * - the socket gets disconnected
+         *
+         * In the second case, the handlers will be simply discarded upon disconnection, since the client will never receive
+         * an acknowledgement from the server.
+         *
+         * @private
+         */
         this.acks = {};
         this.flags = {};
         this.io = io;
@@ -4636,11 +4659,13 @@ class Socket extends component_emitter_1.Emitter {
             debug("event with ack id %d has timed out after %d ms", id, timeout);
             ack.call(this, new Error("operation has timed out"));
         }, timeout);
-        this.acks[id] = (...args) => {
+        const fn = (...args) => {
             // @ts-ignore
             this.io.clearTimeoutFn(timer);
-            ack.apply(this, [null, ...args]);
+            ack.apply(this, args);
         };
+        fn.withError = true;
+        this.acks[id] = fn;
     }
     /**
      * Emits an event and waits for an acknowledgement
@@ -4659,17 +4684,12 @@ class Socket extends component_emitter_1.Emitter {
      * @return a Promise that will be fulfilled when the server acknowledges the event
      */
     emitWithAck(ev, ...args) {
-        // the timeout flag is optional
-        const withErr = this.flags.timeout !== undefined || this._opts.ackTimeout !== undefined;
         return new Promise((resolve, reject) => {
-            args.push((arg1, arg2) => {
-                if (withErr) {
-                    return arg1 ? reject(arg1) : resolve(arg2);
-                }
-                else {
-                    return resolve(arg1);
-                }
-            });
+            const fn = (arg1, arg2) => {
+                return arg1 ? reject(arg1) : resolve(arg2);
+            };
+            fn.withError = true;
+            args.push(fn);
             this.emit(ev, ...args);
         });
     }
@@ -4803,6 +4823,26 @@ class Socket extends component_emitter_1.Emitter {
         this.connected = false;
         delete this.id;
         this.emitReserved("disconnect", reason, description);
+        this._clearAcks();
+    }
+    /**
+     * Clears the acknowledgement handlers upon disconnection, since the client will never receive an acknowledgement from
+     * the server.
+     *
+     * @private
+     */
+    _clearAcks() {
+        Object.keys(this.acks).forEach((id) => {
+            const isBuffered = this.sendBuffer.some((packet) => String(packet.id) === id);
+            if (!isBuffered) {
+                // note: handlers that do not accept an error as first argument are ignored here
+                const ack = this.acks[id];
+                delete this.acks[id];
+                if (ack.withError) {
+                    ack.call(this, new Error("socket has been disconnected"));
+                }
+            }
+        });
     }
     /**
      * Called with socket packet.
@@ -4897,21 +4937,25 @@ class Socket extends component_emitter_1.Emitter {
         };
     }
     /**
-     * Called upon a server acknowlegement.
+     * Called upon a server acknowledgement.
      *
      * @param packet
      * @private
      */
     onack(packet) {
         const ack = this.acks[packet.id];
-        if ("function" === typeof ack) {
-            debug("calling ack %s with %j", packet.id, packet.data);
-            ack.apply(this, packet.data);
-            delete this.acks[packet.id];
-        }
-        else {
+        if (typeof ack !== "function") {
             debug("bad ack %s", packet.id);
+            return;
+        }
+        delete this.acks[packet.id];
+        debug("calling ack %s with %j", packet.id, packet.data);
+        // @ts-ignore FIXME ack is incorrectly inferred as 'never'
+        if (ack.withError) {
+            packet.data.unshift(null);
         }
+        // @ts-ignore
+        ack.apply(this, packet.data);
     }
     /**
      * Called upon server connect.