@actuallab/rpc 12.3.2 → 12.3.6

package/dist/index.cjs

@@ -864,7 +864,7 @@ var RpcStreamSender = class _RpcStreamSender {
     await this._started.promise;
     const iterator = source[Symbol.asyncIterator]();
     try {
-      while (true) {
+      for (; ; ) {
         const next = await iterator.next();
         if (next.done || this._ended) break;
         const item = next.value;
@@ -1150,30 +1150,29 @@ var RpcStream = class _RpcStream {
     if (this._iterating)
       throw new Error("RpcStream can only be iterated once.");
     this._iterating = true;
-    const self = this;
     return {
-      async next() {
-        if (!self._started) {
-          self._started = true;
-          self._sendAck(0, true);
+      next: async () => {
+        if (!this._started) {
+          this._started = true;
+          this._sendAck(0, true);
         }
-        while (true) {
-          if (!self._buffer.isEmpty()) {
-            const value = self._buffer.shift();
+        for (; ; ) {
+          if (!this._buffer.isEmpty()) {
+            const value = this._buffer.shift();
             return { value, done: false };
           }
-          if (self._completed) {
-            if (self._completionError) throw self._completionError;
+          if (this._completed) {
+            if (this._completionError) throw this._completionError;
             return { value: void 0, done: true };
           }
-          self._consumerWaiting = new import_core5.PromiseSource();
-          await self._consumerWaiting.promise;
+          this._consumerWaiting = new import_core5.PromiseSource();
+          await this._consumerWaiting.promise;
         }
       },
-      async return() {
-        self._sendAckEnd();
-        self.dispose();
-        return { value: void 0, done: true };
+      return: () => {
+        this._sendAckEnd();
+        this.dispose();
+        return Promise.resolve({ value: void 0, done: true });
       }
     };
   }
@@ -1782,21 +1781,18 @@ var RpcPeer = class {
     }
     const signal = options?.signal;
     if (signal !== void 0) {
-      const peer = this;
-      const hub = this._hub;
-      const tracker = this.outbound;
       const onAbort = () => {
-        if (tracker.remove(callId) !== void 0) {
+        if (this.outbound.remove(callId) !== void 0) {
           outboundCall.result.reject(new Error("Call cancelled."));
           outboundCall.onDisconnect();
-          if (peer._connection !== void 0)
-            hub.systemCallSender.cancel(peer._connection, peer.format, callId);
+          if (this._connection !== void 0)
+            this._hub.systemCallSender.cancel(this._connection, this.format, callId);
         } else {
-          const idx = peer._pendingSends.findIndex(
+          const idx = this._pendingSends.findIndex(
             (c) => c.callId === callId
           );
           if (idx !== -1) {
-            peer._pendingSends.splice(idx, 1);
+            this._pendingSends.splice(idx, 1);
             outboundCall.result.reject(
               new Error("Call cancelled.")
             );
@@ -1890,51 +1886,49 @@ var RpcPeer = class {
       this.inbound.register(call);
     }
     const serviceHost = this._hub.serviceHost;
-    if (serviceHost !== void 0) {
-      void (async () => {
-        try {
-          const context = this._connection !== void 0 ? {
-            __rpcDispatch: true,
-            callId: relatedId,
-            connection: this._connection
-          } : void 0;
-          const result = await serviceHost.dispatch(
-            method,
-            args,
-            context
+    void (async () => {
+      try {
+        const context = this._connection !== void 0 ? {
+          __rpcDispatch: true,
+          callId: relatedId,
+          connection: this._connection
+        } : void 0;
+        const result = await serviceHost.dispatch(
+          method,
+          args,
+          context
+        );
+        if (methodDef?.stream === true && this._connection !== void 0) {
+          const stream = result instanceof RpcStream ? result : new RpcStream(result);
+          this._hub.systemCallSender.ok(
+            this._connection,
+            this.format,
+            relatedId,
+            stream.toRef(this)
+          );
+        } else if (!isNoWait && this._connection !== void 0) {
+          this._hub.systemCallSender.ok(
+            this._connection,
+            this.format,
+            relatedId,
+            result
           );
-          if (methodDef?.stream === true && this._connection !== void 0) {
-            const stream = result instanceof RpcStream ? result : new RpcStream(result);
-            this._hub.systemCallSender.ok(
-              this._connection,
-              this.format,
-              relatedId,
-              stream.toRef(this)
-            );
-          } else if (!isNoWait && this._connection !== void 0) {
-            this._hub.systemCallSender.ok(
-              this._connection,
-              this.format,
-              relatedId,
-              result
-            );
-          }
-        } catch (e) {
-          if (!isNoWait && this._connection !== void 0) {
-            this._hub.systemCallSender.error(
-              this._connection,
-              this.format,
-              relatedId,
-              e
-            );
-          }
-        } finally {
-          if (!isNoWait) {
-            this.inbound.remove(relatedId);
-          }
         }
-      })();
-    }
+      } catch (e) {
+        if (!isNoWait && this._connection !== void 0) {
+          this._hub.systemCallSender.error(
+            this._connection,
+            this.format,
+            relatedId,
+            e
+          );
+        }
+      } finally {
+        if (!isNoWait) {
+          this.inbound.remove(relatedId);
+        }
+      }
+    })();
   }
   _startKeepAlive() {
     this._keepAliveTimer = setInterval(() => {
@@ -2803,6 +2797,7 @@ var RpcHub = class {
     this.registry.registerService(def.name, def.methods);
   }
   /** Create a typed client proxy for a service on a remote peer. */
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters -- T is used for caller-specified proxy type
   addClient(peer, defOrContract) {
     const def = this._resolveServiceDef(defOrContract);
     this.registry.registerService(def.name, def.methods);