effect 3.4.8 → 3.5.0

package/dist/esm/internal/pubsub.js

@@ -28,13 +28,25 @@ const removeSubscribers = (subscription, pollers) => subscribers => {
   }
 };
 /** @internal */
-export const bounded = requestedCapacity => pipe(core.sync(() => makeBoundedPubSub(requestedCapacity)), core.flatMap(atomicPubSub => makePubSub(atomicPubSub, new BackPressureStrategy())));
+export const bounded = capacity => core.suspend(() => {
+  const pubsub = makeBoundedPubSub(capacity);
+  return makePubSub(pubsub, new BackPressureStrategy());
+});
 /** @internal */
-export const dropping = requestedCapacity => pipe(core.sync(() => makeBoundedPubSub(requestedCapacity)), core.flatMap(atomicPubSub => makePubSub(atomicPubSub, new DroppingStrategy())));
+export const dropping = capacity => core.suspend(() => {
+  const pubsub = makeBoundedPubSub(capacity);
+  return makePubSub(pubsub, new DroppingStrategy());
+});
 /** @internal */
-export const sliding = requestedCapacity => pipe(core.sync(() => makeBoundedPubSub(requestedCapacity)), core.flatMap(atomicPubSub => makePubSub(atomicPubSub, new SlidingStrategy())));
+export const sliding = capacity => core.suspend(() => {
+  const pubsub = makeBoundedPubSub(capacity);
+  return makePubSub(pubsub, new SlidingStrategy());
+});
 /** @internal */
-export const unbounded = () => pipe(core.sync(() => makeUnboundedPubSub()), core.flatMap(atomicPubSub => makePubSub(atomicPubSub, new DroppingStrategy())));
+export const unbounded = options => core.suspend(() => {
+  const pubsub = makeUnboundedPubSub(options);
+  return makePubSub(pubsub, new DroppingStrategy());
+});
 /** @internal */
 export const capacity = self => self.capacity();
 /** @internal */
@@ -56,42 +68,47 @@ export const publishAll = /*#__PURE__*/dual(2, (self, elements) => self.publishA
 /** @internal */
 export const subscribe = self => self.subscribe;
 /** @internal */
-const makeBoundedPubSub = requestedCapacity => {
-  ensureCapacity(requestedCapacity);
-  if (requestedCapacity === 1) {
-    return new BoundedPubSubSingle();
-  } else if (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 (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 */
-export const unsafeMakeSubscription = (pubsub, subscribers, subscription, pollers, shutdownHook, shutdownFlag, strategy) => {
-  return new SubscriptionImpl(pubsub, subscribers, subscription, pollers, shutdownHook, shutdownFlag, strategy);
-};
+export const unsafeMakeSubscription = (pubsub, subscribers, subscription, pollers, shutdownHook, shutdownFlag, strategy) => new SubscriptionImpl(pubsub, subscribers, subscription, pollers, shutdownHook, shutdownFlag, strategy, pubsub.replayWindow());
 /** @internal */
 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;
@@ -112,10 +129,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);
@@ -134,6 +157,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);
   }
@@ -144,6 +170,9 @@ class BoundedPubSubArb {
       this.subscribers[index] = 0;
       this.subscribersIndex += 1;
     }
+    if (this.replayBuffer) {
+      this.replayBuffer.slide();
+    }
   }
   subscribe() {
     this.subscriberCount += 1;
@@ -230,22 +259,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;
@@ -266,10 +300,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);
@@ -288,6 +328,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);
   }
@@ -298,6 +341,9 @@ class BoundedPubSubPow2 {
       this.subscribers[index] = 0;
       this.subscribersIndex += 1;
     }
+    if (this.replayBuffer) {
+      this.replayBuffer.slide();
+    }
   }
   subscribe() {
     this.subscriberCount += 1;
@@ -385,11 +431,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 pipeArguments(this, arguments);
   }
@@ -411,10 +464,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);
@@ -432,6 +491,9 @@ class BoundedPubSubSingle {
       this.subscribers = 0;
       this.value = AbsentValue;
     }
+    if (this.replayBuffer) {
+      this.replayBuffer.slide();
+    }
   }
   subscribe() {
     this.subscriberCount += 1;
@@ -493,6 +555,7 @@ class BoundedPubSubSingleSubscription {
 }
 /** @internal */
 class UnboundedPubSub {
+  replayBuffer;
   publisherHead = {
     value: AbsentValue,
     subscribers: 0,
@@ -502,6 +565,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;
   }
@@ -522,6 +591,9 @@ class UnboundedPubSub {
       this.publisherTail = this.publisherTail.next;
       this.publisherIndex += 1;
     }
+    if (this.replayBuffer) {
+      this.replayBuffer.offer(value);
+    }
     return true;
   }
   publishAll(elements) {
@@ -529,6 +601,8 @@ class UnboundedPubSub {
       for (const a of elements) {
         this.publish(a);
       }
+    } else if (this.replayBuffer) {
+      this.replayBuffer.offerAll(elements);
     }
     return Chunk.empty();
   }
@@ -538,6 +612,9 @@ class UnboundedPubSub {
       this.publisherHead.value = AbsentValue;
       this.subscribersIndex += 1;
     }
+    if (this.replayBuffer) {
+      this.replayBuffer.slide();
+    }
   }
   subscribe() {
     this.publisherTail.subscribers += 1;
@@ -652,8 +729,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;
@@ -661,6 +739,7 @@ class SubscriptionImpl {
     this.shutdownHook = shutdownHook;
     this.shutdownFlag = shutdownFlag;
     this.strategy = strategy;
+    this.replayWindow = replayWindow;
   }
   pipe() {
     return pipeArguments(this, arguments);
@@ -672,16 +751,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);
@@ -707,6 +786,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());
@@ -729,6 +812,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);
     });
   }
@@ -737,9 +823,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) {
@@ -865,9 +959,7 @@ class PubSubImpl {
 /** @internal */
 export 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 */
-export const unsafeMakePubSub = (pubsub, subscribers, scope, shutdownHook, shutdownFlag, strategy) => {
-  return new PubSubImpl(pubsub, subscribers, scope, shutdownHook, shutdownFlag, strategy);
-};
+export const unsafeMakePubSub = (pubsub, subscribers, scope, shutdownHook, shutdownFlag, strategy) => new PubSubImpl(pubsub, subscribers, scope, shutdownHook, shutdownFlag, strategy);
 /** @internal */
 const ensureCapacity = capacity => {
   if (capacity <= 0) {
@@ -1075,4 +1167,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