effect 3.4.9 → 3.5.0

package/dist/cjs/internal/pubsub.js

@@ -36,16 +36,28 @@ const removeSubscribers = (subscription, pollers) => subscribers => {
   }
 };
 /** @internal */
-const bounded = requestedCapacity => (0, _Function.pipe)(core.sync(() => makeBoundedPubSub(requestedCapacity)), core.flatMap(atomicPubSub => makePubSub(atomicPubSub, new BackPressureStrategy())));
+const bounded = capacity => core.suspend(() => {
+  const pubsub = makeBoundedPubSub(capacity);
+  return makePubSub(pubsub, new BackPressureStrategy());
+});
 /** @internal */
 exports.bounded = bounded;
-const dropping = requestedCapacity => (0, _Function.pipe)(core.sync(() => makeBoundedPubSub(requestedCapacity)), core.flatMap(atomicPubSub => makePubSub(atomicPubSub, new DroppingStrategy())));
+const dropping = capacity => core.suspend(() => {
+  const pubsub = makeBoundedPubSub(capacity);
+  return makePubSub(pubsub, new DroppingStrategy());
+});
 /** @internal */
 exports.dropping = dropping;
-const sliding = requestedCapacity => (0, _Function.pipe)(core.sync(() => makeBoundedPubSub(requestedCapacity)), core.flatMap(atomicPubSub => makePubSub(atomicPubSub, new SlidingStrategy())));
+const sliding = capacity => core.suspend(() => {
+  const pubsub = makeBoundedPubSub(capacity);
+  return makePubSub(pubsub, new SlidingStrategy());
+});
 /** @internal */
 exports.sliding = sliding;
-const unbounded = () => (0, _Function.pipe)(core.sync(() => makeUnboundedPubSub()), core.flatMap(atomicPubSub => makePubSub(atomicPubSub, new DroppingStrategy())));
+const unbounded = options => core.suspend(() => {
+  const pubsub = makeUnboundedPubSub(options);
+  return makePubSub(pubsub, new DroppingStrategy());
+});
 /** @internal */
 exports.unbounded = unbounded;
 const capacity = self => self.capacity();
@@ -76,43 +88,48 @@ const publishAll = exports.publishAll = /*#__PURE__*/(0, _Function.dual)(2, (sel
 const subscribe = self => self.subscribe;
 /** @internal */
 exports.subscribe = subscribe;
-const makeBoundedPubSub = requestedCapacity => {
-  ensureCapacity(requestedCapacity);
-  if (requestedCapacity === 1) {
-    return new BoundedPubSubSingle();
-  } else if ((0, _Number.nextPow2)(requestedCapacity) === requestedCapacity) {
-    return new BoundedPubSubPow2(requestedCapacity);
+const makeBoundedPubSub = capacity => {
+  const options = typeof capacity === "number" ? {
+    capacity
+  } : capacity;
+  ensureCapacity(options.capacity);
+  const replayBuffer = options.replay && options.replay > 0 ? new ReplayBuffer(Math.ceil(options.replay)) : undefined;
+  if (options.capacity === 1) {
+    return new BoundedPubSubSingle(replayBuffer);
+  } else if ((0, _Number.nextPow2)(options.capacity) === options.capacity) {
+    return new BoundedPubSubPow2(options.capacity, replayBuffer);
   } else {
-    return new BoundedPubSubArb(requestedCapacity);
+    return new BoundedPubSubArb(options.capacity, replayBuffer);
   }
 };
 /** @internal */
-const makeUnboundedPubSub = () => {
-  return new UnboundedPubSub();
-};
+const makeUnboundedPubSub = options => new UnboundedPubSub(options?.replay ? new ReplayBuffer(options.replay) : undefined);
 /** @internal */
 const makeSubscription = (pubsub, subscribers, strategy) => core.map(core.deferredMake(), deferred => unsafeMakeSubscription(pubsub, subscribers, pubsub.subscribe(), MutableQueue.unbounded(), deferred, MutableRef.make(false), strategy));
 /** @internal */
-const unsafeMakeSubscription = (pubsub, subscribers, subscription, pollers, shutdownHook, shutdownFlag, strategy) => {
-  return new SubscriptionImpl(pubsub, subscribers, subscription, pollers, shutdownHook, shutdownFlag, strategy);
-};
+const unsafeMakeSubscription = (pubsub, subscribers, subscription, pollers, shutdownHook, shutdownFlag, strategy) => new SubscriptionImpl(pubsub, subscribers, subscription, pollers, shutdownHook, shutdownFlag, strategy, pubsub.replayWindow());
 /** @internal */
 exports.unsafeMakeSubscription = unsafeMakeSubscription;
 class BoundedPubSubArb {
+  capacity;
+  replayBuffer;
   array;
   publisherIndex = 0;
   subscribers;
   subscriberCount = 0;
   subscribersIndex = 0;
-  capacity;
-  constructor(requestedCapacity) {
+  constructor(capacity, replayBuffer) {
+    this.capacity = capacity;
+    this.replayBuffer = replayBuffer;
     this.array = Array.from({
-      length: requestedCapacity
+      length: capacity
     });
     this.subscribers = Array.from({
-      length: requestedCapacity
+      length: capacity
     });
-    this.capacity = requestedCapacity;
+  }
+  replayWindow() {
+    return this.replayBuffer ? new ReplayWindowImpl(this.replayBuffer) : emptyReplayWindow;
   }
   isEmpty() {
     return this.publisherIndex === this.subscribersIndex;
@@ -133,10 +150,16 @@ class BoundedPubSubArb {
       this.subscribers[index] = this.subscriberCount;
       this.publisherIndex += 1;
     }
+    if (this.replayBuffer) {
+      this.replayBuffer.offer(value);
+    }
     return true;
   }
   publishAll(elements) {
     if (this.subscriberCount === 0) {
+      if (this.replayBuffer) {
+        this.replayBuffer.offerAll(elements);
+      }
       return Chunk.empty();
     }
     const chunk = Chunk.fromIterable(elements);
@@ -155,6 +178,9 @@ class BoundedPubSubArb {
       this.array[index] = a;
       this.subscribers[index] = this.subscriberCount;
       this.publisherIndex += 1;
+      if (this.replayBuffer) {
+        this.replayBuffer.offer(a);
+      }
     }
     return Chunk.drop(chunk, iteratorIndex);
   }
@@ -165,6 +191,9 @@ class BoundedPubSubArb {
       this.subscribers[index] = 0;
       this.subscribersIndex += 1;
     }
+    if (this.replayBuffer) {
+      this.replayBuffer.slide();
+    }
   }
   subscribe() {
     this.subscriberCount += 1;
@@ -251,22 +280,27 @@ class BoundedPubSubArbSubscription {
 }
 /** @internal */
 class BoundedPubSubPow2 {
+  capacity;
+  replayBuffer;
   array;
   mask;
   publisherIndex = 0;
   subscribers;
   subscriberCount = 0;
   subscribersIndex = 0;
-  capacity;
-  constructor(requestedCapacity) {
+  constructor(capacity, replayBuffer) {
+    this.capacity = capacity;
+    this.replayBuffer = replayBuffer;
     this.array = Array.from({
-      length: requestedCapacity
+      length: capacity
     });
-    this.mask = requestedCapacity - 1;
+    this.mask = capacity - 1;
     this.subscribers = Array.from({
-      length: requestedCapacity
+      length: capacity
     });
-    this.capacity = requestedCapacity;
+  }
+  replayWindow() {
+    return this.replayBuffer ? new ReplayWindowImpl(this.replayBuffer) : emptyReplayWindow;
   }
   isEmpty() {
     return this.publisherIndex === this.subscribersIndex;
@@ -287,10 +321,16 @@ class BoundedPubSubPow2 {
       this.subscribers[index] = this.subscriberCount;
       this.publisherIndex += 1;
     }
+    if (this.replayBuffer) {
+      this.replayBuffer.offer(value);
+    }
     return true;
   }
   publishAll(elements) {
     if (this.subscriberCount === 0) {
+      if (this.replayBuffer) {
+        this.replayBuffer.offerAll(elements);
+      }
       return Chunk.empty();
     }
     const chunk = Chunk.fromIterable(elements);
@@ -309,6 +349,9 @@ class BoundedPubSubPow2 {
       this.array[index] = elem;
       this.subscribers[index] = this.subscriberCount;
       this.publisherIndex += 1;
+      if (this.replayBuffer) {
+        this.replayBuffer.offer(elem);
+      }
     }
     return Chunk.drop(chunk, iteratorIndex);
   }
@@ -319,6 +362,9 @@ class BoundedPubSubPow2 {
       this.subscribers[index] = 0;
       this.subscribersIndex += 1;
     }
+    if (this.replayBuffer) {
+      this.replayBuffer.slide();
+    }
   }
   subscribe() {
     this.subscriberCount += 1;
@@ -406,11 +452,18 @@ class BoundedPubSubPow2Subscription {
 }
 /** @internal */
 class BoundedPubSubSingle {
+  replayBuffer;
   publisherIndex = 0;
   subscriberCount = 0;
   subscribers = 0;
   value = AbsentValue;
   capacity = 1;
+  constructor(replayBuffer) {
+    this.replayBuffer = replayBuffer;
+  }
+  replayWindow() {
+    return this.replayBuffer ? new ReplayWindowImpl(this.replayBuffer) : emptyReplayWindow;
+  }
   pipe() {
     return (0, _Pipeable.pipeArguments)(this, arguments);
   }
@@ -432,10 +485,16 @@ class BoundedPubSubSingle {
       this.subscribers = this.subscriberCount;
       this.publisherIndex += 1;
     }
+    if (this.replayBuffer) {
+      this.replayBuffer.offer(value);
+    }
     return true;
   }
   publishAll(elements) {
     if (this.subscriberCount === 0) {
+      if (this.replayBuffer) {
+        this.replayBuffer.offerAll(elements);
+      }
       return Chunk.empty();
     }
     const chunk = Chunk.fromIterable(elements);
@@ -453,6 +512,9 @@ class BoundedPubSubSingle {
       this.subscribers = 0;
       this.value = AbsentValue;
     }
+    if (this.replayBuffer) {
+      this.replayBuffer.slide();
+    }
   }
   subscribe() {
     this.subscriberCount += 1;
@@ -514,6 +576,7 @@ class BoundedPubSubSingleSubscription {
 }
 /** @internal */
 class UnboundedPubSub {
+  replayBuffer;
   publisherHead = {
     value: AbsentValue,
     subscribers: 0,
@@ -523,6 +586,12 @@ class UnboundedPubSub {
   publisherIndex = 0;
   subscribersIndex = 0;
   capacity = Number.MAX_SAFE_INTEGER;
+  constructor(replayBuffer) {
+    this.replayBuffer = replayBuffer;
+  }
+  replayWindow() {
+    return this.replayBuffer ? new ReplayWindowImpl(this.replayBuffer) : emptyReplayWindow;
+  }
   isEmpty() {
     return this.publisherHead === this.publisherTail;
   }
@@ -543,6 +612,9 @@ class UnboundedPubSub {
       this.publisherTail = this.publisherTail.next;
       this.publisherIndex += 1;
     }
+    if (this.replayBuffer) {
+      this.replayBuffer.offer(value);
+    }
     return true;
   }
   publishAll(elements) {
@@ -550,6 +622,8 @@ class UnboundedPubSub {
       for (const a of elements) {
         this.publish(a);
       }
+    } else if (this.replayBuffer) {
+      this.replayBuffer.offerAll(elements);
     }
     return Chunk.empty();
   }
@@ -559,6 +633,9 @@ class UnboundedPubSub {
       this.publisherHead.value = AbsentValue;
       this.subscribersIndex += 1;
     }
+    if (this.replayBuffer) {
+      this.replayBuffer.slide();
+    }
   }
   subscribe() {
     this.publisherTail.subscribers += 1;
@@ -673,8 +750,9 @@ class SubscriptionImpl {
   shutdownHook;
   shutdownFlag;
   strategy;
+  replayWindow;
   [queue.DequeueTypeId] = queue.dequeueVariance;
-  constructor(pubsub, subscribers, subscription, pollers, shutdownHook, shutdownFlag, strategy) {
+  constructor(pubsub, subscribers, subscription, pollers, shutdownHook, shutdownFlag, strategy, replayWindow) {
     this.pubsub = pubsub;
     this.subscribers = subscribers;
     this.subscription = subscription;
@@ -682,6 +760,7 @@ class SubscriptionImpl {
     this.shutdownHook = shutdownHook;
     this.shutdownFlag = shutdownFlag;
     this.strategy = strategy;
+    this.replayWindow = replayWindow;
   }
   pipe() {
     return (0, _Pipeable.pipeArguments)(this, arguments);
@@ -693,16 +772,16 @@ class SubscriptionImpl {
     return !MutableRef.get(this.shutdownFlag);
   }
   get size() {
-    return core.suspend(() => MutableRef.get(this.shutdownFlag) ? core.interrupt : core.succeed(this.subscription.size()));
+    return core.suspend(() => MutableRef.get(this.shutdownFlag) ? core.interrupt : core.succeed(this.subscription.size() + this.replayWindow.remaining));
   }
   unsafeSize() {
     if (MutableRef.get(this.shutdownFlag)) {
       return Option.none();
     }
-    return Option.some(this.subscription.size());
+    return Option.some(this.subscription.size() + this.replayWindow.remaining);
   }
   get isFull() {
-    return core.map(this.size, size => size === this.capacity());
+    return core.suspend(() => MutableRef.get(this.shutdownFlag) ? core.interrupt : core.succeed(this.subscription.size() === this.capacity()));
   }
   get isEmpty() {
     return core.map(this.size, size => size === 0);
@@ -728,6 +807,10 @@ class SubscriptionImpl {
       if (MutableRef.get(this.shutdownFlag)) {
         return core.interrupt;
       }
+      if (this.replayWindow.remaining > 0) {
+        const message = this.replayWindow.take();
+        return core.succeed(message);
+      }
       const message = MutableQueue.isEmpty(this.pollers) ? this.subscription.poll(MutableQueue.EmptyMutableQueue) : MutableQueue.EmptyMutableQueue;
       if (message === MutableQueue.EmptyMutableQueue) {
         const deferred = core.deferredUnsafeMake(state.id());
@@ -750,6 +833,9 @@ class SubscriptionImpl {
       }
       const as = MutableQueue.isEmpty(this.pollers) ? unsafePollAllSubscription(this.subscription) : Chunk.empty();
       this.strategy.unsafeOnPubSubEmptySpace(this.pubsub, this.subscribers);
+      if (this.replayWindow.remaining > 0) {
+        return core.succeed(Chunk.appendAll(this.replayWindow.takeAll(), as));
+      }
       return core.succeed(as);
     });
   }
@@ -758,9 +844,17 @@ class SubscriptionImpl {
       if (MutableRef.get(this.shutdownFlag)) {
         return core.interrupt;
       }
+      let replay = undefined;
+      if (this.replayWindow.remaining >= max) {
+        const as = this.replayWindow.takeN(max);
+        return core.succeed(as);
+      } else if (this.replayWindow.remaining > 0) {
+        replay = this.replayWindow.takeAll();
+        max = max - replay.length;
+      }
       const as = MutableQueue.isEmpty(this.pollers) ? unsafePollN(this.subscription, max) : Chunk.empty();
       this.strategy.unsafeOnPubSubEmptySpace(this.pubsub, this.subscribers);
-      return core.succeed(as);
+      return replay ? core.succeed(Chunk.appendAll(replay, as)) : core.succeed(as);
     });
   }
   takeBetween(min, max) {
@@ -887,9 +981,7 @@ class PubSubImpl {
 const makePubSub = (pubsub, strategy) => core.flatMap(fiberRuntime.scopeMake(), scope => core.map(core.deferredMake(), deferred => unsafeMakePubSub(pubsub, new Map(), scope, deferred, MutableRef.make(false), strategy)));
 /** @internal */
 exports.makePubSub = makePubSub;
-const unsafeMakePubSub = (pubsub, subscribers, scope, shutdownHook, shutdownFlag, strategy) => {
-  return new PubSubImpl(pubsub, subscribers, scope, shutdownHook, shutdownFlag, strategy);
-};
+const unsafeMakePubSub = (pubsub, subscribers, scope, shutdownHook, shutdownFlag, strategy) => new PubSubImpl(pubsub, subscribers, scope, shutdownHook, shutdownFlag, strategy);
 /** @internal */
 exports.unsafeMakePubSub = unsafeMakePubSub;
 const ensureCapacity = capacity => {
@@ -1100,4 +1192,92 @@ const unsafeStrategyCompleteSubscribers = (strategy, pubsub, subscribers) => {
     }
   }
 };
+class ReplayBuffer {
+  capacity;
+  constructor(capacity) {
+    this.capacity = capacity;
+  }
+  head = {
+    value: AbsentValue,
+    next: null
+  };
+  tail = this.head;
+  size = 0;
+  index = 0;
+  slide() {
+    this.index++;
+  }
+  offer(a) {
+    this.tail.value = a;
+    this.tail.next = {
+      value: AbsentValue,
+      next: null
+    };
+    this.tail = this.tail.next;
+    if (this.size === this.capacity) {
+      this.head = this.head.next;
+    } else {
+      this.size += 1;
+    }
+  }
+  offerAll(as) {
+    for (const a of as) {
+      this.offer(a);
+    }
+  }
+}
+class ReplayWindowImpl {
+  buffer;
+  head;
+  index;
+  remaining;
+  constructor(buffer) {
+    this.buffer = buffer;
+    this.index = buffer.index;
+    this.remaining = buffer.size;
+    this.head = buffer.head;
+  }
+  fastForward() {
+    while (this.index < this.buffer.index) {
+      this.head = this.head.next;
+      this.index++;
+    }
+  }
+  take() {
+    if (this.remaining === 0) {
+      return undefined;
+    } else if (this.index < this.buffer.index) {
+      this.fastForward();
+    }
+    this.remaining--;
+    const value = this.head.value;
+    this.head = this.head.next;
+    return value;
+  }
+  takeN(n) {
+    if (this.remaining === 0) {
+      return Chunk.empty();
+    } else if (this.index < this.buffer.index) {
+      this.fastForward();
+    }
+    const len = Math.min(n, this.remaining);
+    const items = new Array(len);
+    for (let i = 0; i < len; i++) {
+      const value = this.head.value;
+      this.head = this.head.next;
+      items[i] = value;
+    }
+    this.remaining -= len;
+    return Chunk.unsafeFromArray(items);
+  }
+  takeAll() {
+    return this.takeN(this.remaining);
+  }
+}
+const emptyReplayWindow = {
+  remaining: 0,
+  take: () => undefined,
+  takeN: () => Chunk.empty(),
+  takeAll: () => Chunk.empty()
+};
 //# sourceMappingURL=pubsub.js.map