bruce-models 7.1.102 → 7.1.103

package/dist/bruce-models.umd.js

@@ -12694,6 +12694,184 @@
         }
     }
 
+    /**
+     * Runs work that several callers keep asking for, at a rate the answer can actually arrive at.
+     */
+    (function (RequestLane) {
+        RequestLane.DISPOSED = "RequestLane disposed";
+        RequestLane.TIMED_OUT = "RequestLane timed out";
+        /**
+         * A set of independently rate-limited keys.
+         * One per subject, eg. one lane for Entity reads with the Entity ID as the key.
+         */
+        class Lane {
+            constructor(options = {}) {
+                this.options = options;
+                this.pending = new Map();
+                this.inFlight = new Set();
+                this.lastStarted = new Map();
+                this.timers = new Map();
+                // Keys with a pump owed at the end of this turn.
+                this.scheduled = new Set();
+                this.disposed = false;
+            }
+            /**
+             * Asks for this work to be run for this key, and resolves with whatever run answers for it.
+             * @param key what is being asked about, eg: an Entity ID.
+             * @param work how to find out.
+             */
+            Run(key, work) {
+                if (this.disposed) {
+                    return Promise.reject(new Error(RequestLane.DISPOSED));
+                }
+                return new Promise((resolve, reject) => {
+                    const slot = this.pending.get(key);
+                    if (slot) {
+                        // Newest wins: the older work has been overtaken, but whoever asked for it is
+                        // still owed an answer, so their waiter stays.
+                        slot.work = work;
+                        slot.waiters.push({ resolve, reject });
+                    }
+                    else {
+                        this.pending.set(key, { work, waiters: [{ resolve, reject }] });
+                    }
+                    this.schedulePump(key);
+                });
+            }
+            /**
+             * Whether a run is currently out for this key.
+             */
+            IsRunning(key) {
+                return this.inFlight.has(key);
+            }
+            /**
+             * How long this key must wait before it may run again, zero when it may run now.
+             */
+            WaitFor(key) {
+                const minInterval = this.options.minIntervalMs || 0;
+                if (!minInterval) {
+                    return 0;
+                }
+                const last = this.lastStarted.get(key);
+                if (last == null) {
+                    return 0;
+                }
+                const now = (this.options.now || Date.now)();
+                return Math.max(0, (last + minInterval) - now);
+            }
+            /**
+             * Forgets a key, answering whatever was waiting on it. For a caller that has gone away.
+             * @param key
+             */
+            Drop(key) {
+                const timer = this.timers.get(key);
+                if (timer != null) {
+                    clearTimeout(timer);
+                    this.timers.delete(key);
+                }
+                const slot = this.pending.get(key);
+                if (slot) {
+                    this.pending.delete(key);
+                    this.rejectAll(slot, new Error(RequestLane.DISPOSED));
+                }
+            }
+            Dispose() {
+                this.disposed = true;
+                for (const timer of Array.from(this.timers.values())) {
+                    clearTimeout(timer);
+                }
+                this.timers.clear();
+                this.scheduled.clear();
+                for (const slot of Array.from(this.pending.values())) {
+                    this.rejectAll(slot, new Error(RequestLane.DISPOSED));
+                }
+                this.pending.clear();
+                this.inFlight.clear();
+                this.lastStarted.clear();
+            }
+            /*
+             * Answers every waiter on a slot with the same failure.
+             */
+            rejectAll(slot, error) {
+                for (const waiter of slot.waiters) {
+                    waiter.reject(error);
+                }
+            }
+            /*
+             * Runs the pump at the end of this turn rather than during it.
+             */
+            schedulePump(key) {
+                if (this.disposed || this.scheduled.has(key)) {
+                    return;
+                }
+                this.scheduled.add(key);
+                Promise.resolve().then(() => {
+                    this.scheduled.delete(key);
+                    this.pump(key);
+                });
+            }
+            /*
+             * Starts the next run for a key when it has one and is allowed to.
+             */
+            pump(key) {
+                if (this.disposed || this.inFlight.has(key) || !this.pending.has(key)) {
+                    return;
+                }
+                const waitFor = this.WaitFor(key);
+                if (waitFor > 0) {
+                    // Whatever else is asked for during the wait folds into the same slot, so the run
+                    // that eventually goes is the newest one rather than the one that started the wait.
+                    if (!this.timers.has(key)) {
+                        this.timers.set(key, setTimeout(() => {
+                            this.timers.delete(key);
+                            this.pump(key);
+                        }, waitFor));
+                    }
+                    return;
+                }
+                const slot = this.pending.get(key);
+                this.pending.delete(key);
+                this.inFlight.add(key);
+                this.lastStarted.set(key, (this.options.now || Date.now)());
+                let settled = false;
+                const finish = (settle) => {
+                    if (settled) {
+                        return;
+                    }
+                    settled = true;
+                    this.inFlight.delete(key);
+                    settle();
+                    if (!this.disposed) {
+                        this.schedulePump(key);
+                    }
+                };
+                const timeoutMs = this.options.timeoutMs || 0;
+                let timeout = null;
+                if (timeoutMs > 0) {
+                    timeout = setTimeout(() => finish(() => this.rejectAll(slot, new Error(RequestLane.TIMED_OUT))), timeoutMs);
+                }
+                // Wrapped rather than called directly, so work that throws before returning a promise is
+                // a rejection like any other rather than something that leaves the key held forever.
+                Promise.resolve().then(slot.work).then((value) => {
+                    if (timeout != null) {
+                        clearTimeout(timeout);
+                    }
+                    finish(() => {
+                        for (const waiter of slot.waiters) {
+                            waiter.resolve(value);
+                        }
+                    });
+                }, (error) => {
+                    if (timeout != null) {
+                        clearTimeout(timeout);
+                    }
+                    finish(() => this.rejectAll(slot, error));
+                });
+            }
+        }
+        RequestLane.Lane = Lane;
+    })(exports.RequestLane || (exports.RequestLane = {}));
+
     /**
      * Describes a Bruce stored date.
      */
@@ -23727,7 +23905,7 @@
     }
 
     // This is updated with the package.json version on build.
-    const VERSION = "7.1.102";
+    const VERSION = "7.1.103";
 
     exports.VERSION = VERSION;
     exports.AbstractApi = AbstractApi;