@greendrake/rpc 0.7.0 → 0.8.0

package/README.md

@@ -177,7 +177,7 @@ The contract:
 - **Relevance.** `when` decides whether a push concerns what the binding shows; omitted, every push does.
 - **Apply or resync.** `apply` folds the push in and nothing else happens. Without it the push runs `resync` — so `{}` means "every such push re-reads". A handler with neither `apply` nor a `resync` to fall back on throws at binding time.
 - **Reconnect.** `resync` also runs when the socket returns from a drop the binding witnessed: a connection has no memory, so what it missed is only recoverable by asking. The first connect after the binding is created is not a return from a drop. A binding without `resync` subscribes to nothing connection-related.
-- **Coalescing.** One `resync` at a time; pushes arriving during a run collapse into a single follow-up after it, however many there are — they ask the same question.
+- **Coalescing.** One `resync` at a time; pushes arriving during a run collapse into a single follow-up after it, however many there are — they ask the same question. This is `@greendrake/util`'s `coalesced`, which a server building what it pushes can use the same way.
 - **No error policy.** The binding awaits `resync` only to know when the slot is free, and interprets neither outcome: `resync` owns its errors. It must also not be served by a response cache the missed pushes would have invalidated — invalidate the entries its read would hit, then read.
 - **Release.** The returned function detaches every subscription and drops any pending follow-up; calling it twice is harmless.
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@greendrake/rpc",
-    "version": "0.7.0",
+    "version": "0.8.0",
     "description": "RPC client over JSON: typed method-map API, HTTP and reconnecting WebSocket transports, pluggable codec and headers, TTL response cache",
     "license": "MIT",
     "author": "Eugene Greendrake <eugene@greendrake.nz>",
@@ -34,7 +34,7 @@
     },
     "prettier": "@greendrake/dev-config/prettier",
     "dependencies": {
-        "@greendrake/util": "0.7.0"
+        "@greendrake/util": "^0.8.0"
     },
     "devDependencies": {
         "@greendrake/dev-config": "0.7.0",

package/src/liveBinding.ts

@@ -1,3 +1,4 @@
+import { coalesced } from '@greendrake/util'
 import type { PushMapConstraint, WsTransport } from './WsTransport'
 
 // What one push means to the thing the binding keeps current.
@@ -36,38 +37,17 @@ export interface LiveOptions<PEvents, PData> {
 export const liveBinding = <PEvents extends PushMapConstraint<PEvents>, PData extends PushMapConstraint<PData>>(transport: WsTransport<PEvents, PData>, options: LiveOptions<PEvents, PData>): (() => void) => {
     const { resync } = options
     const releases: (() => void)[] = []
-    let running = false
-    let queued = false
     let released = false
 
+    // One re-read at a time, and at most one more behind it however many
+    // pushes land while it runs: they all ask the same question, and the answer
+    // to the last one is the answer to all of them. One still queued when the
+    // binding is released has nobody left to answer, and does nothing.
+    const reread = coalesced(() => (released ? undefined : resync?.()))
+    // The outcome belongs to resync — swallowed here rather than left
+    // unhandled because this runs from a subscription callback nobody awaits.
     const runResync = (): void => {
-        if (!resync || released) return
-        // One re-read at a time, and at most one more behind it however many
-        // pushes land while it runs: they all ask the same question, and the
-        // answer to the last one is the answer to all of them.
-        if (running) {
-            queued = true
-            return
-        }
-        running = true
-        // `new Promise(resolve => resolve(…))` rather than Promise.resolve(…):
-        // it puts the call inside the promise, so a resync that throws
-        // synchronously becomes a rejection like any other failure instead of
-        // escaping with the slot still held — which would wedge this binding for
-        // good, and abort the transport's dispatch to every other subscriber of
-        // the same frame.
-        void new Promise(resolve => resolve(resync()))
-            // Whatever the outcome, the slot is free and a push that arrived
-            // during the run gets its re-read. The outcome itself belongs to
-            // resync — swallowed here rather than left unhandled because this
-            // runs from a subscription callback nobody awaits.
-            .catch(() => {})
-            .then(() => {
-                running = false
-                if (!queued) return
-                queued = false
-                runResync()
-            })
+        void reread().catch(() => {})
     }
 
     const attach = <P>(handlers: { [K in keyof P]?: LiveHandler<P[K]> } | undefined, subscribe: <K extends keyof P & string>(key: K, handler: (data: P[K]) => void) => () => void): (() => () => void)[] =>
@@ -109,7 +89,6 @@ export const liveBinding = <PEvents extends PushMapConstraint<PEvents>, PData ex
 
     return () => {
         released = true
-        queued = false
         releases.forEach(release => release())
         releases.length = 0
     }