effect 2.0.0-next.44 → 2.0.0-next.46

package/internal/stm/{tHub.esm.js → tPubSub.esm.js}

@@ -1,19 +1,19 @@
 import { acquireRelease } from '../../Effect/dist/effect-Effect.esm.js';
 import { dual, pipe, identity } from '../../Function/dist/effect-Function.esm.js';
 import { empty, add, forEach as forEach$1, remove } from '../../HashSet/dist/effect-HashSet.esm.js';
+import { some, none } from '../../Option/dist/effect-Option.esm.js';
+import { every } from '../../ReadonlyArray/dist/effect-ReadonlyArray.esm.js';
 import { flatMap, map, effect, retry, withSTMRuntime, interruptAs, succeed } from './core.esm.js';
 import { OP_SLIDING_STRATEGY, OP_DROPPING_STRATEGY, OP_BACKPRESSURE_STRATEGY } from './opCodes/strategy.esm.js';
 import { all, tap, unit, forEach } from './stm.esm.js';
 import { shutdown, BackPressure, Dropping, Sliding, TEnqueueTypeId, tEnqueueVariance, TDequeueTypeId, tDequeueVariance } from './tQueue.esm.js';
 import { make, get, set, unsafeGet, TRefImpl, unsafeSet } from './tRef.esm.js';
-import { some, none } from '../../Option/dist/effect-Option.esm.js';
-import { every } from '../../ReadonlyArray/dist/effect-ReadonlyArray.esm.js';
 
 /** @internal */
-const THubSymbolKey = "effect/THub";
+const TPubSubSymbolKey = "effect/TPubSub";
 
 /** @internal */
-const THubTypeId = /*#__PURE__*/Symbol.for(THubSymbolKey);
+const TPubSubTypeId = /*#__PURE__*/Symbol.for(TPubSubSymbolKey);
 
 /** @internal */
 
@@ -25,11 +25,11 @@ const makeNode = (head, subscribers, tail) => ({
 });
 
 /** @internal */
-class THubImpl {
-  [THubTypeId] = THubTypeId;
+class TPubSubImpl {
+  [TPubSubTypeId] = TPubSubTypeId;
   [TEnqueueTypeId] = tEnqueueVariance;
-  constructor(hubSize, publisherHead, publisherTail, requestedCapacity, strategy, subscriberCount, subscribers) {
-    this.hubSize = hubSize;
+  constructor(pubsubSize, publisherHead, publisherTail, requestedCapacity, strategy, subscriberCount, subscribers) {
+    this.pubsubSize = pubsubSize;
     this.publisherHead = publisherHead;
     this.publisherTail = publisherTail;
     this.requestedCapacity = requestedCapacity;
@@ -50,7 +50,7 @@ class THubImpl {
     if (currentPublisherTail === undefined) {
       return interruptAs(runtime.fiberId);
     }
-    return succeed(unsafeGet(this.hubSize, runtime.journal));
+    return succeed(unsafeGet(this.pubsubSize, runtime.journal));
   });
   isEmpty = map(this.size, size => size === 0);
   isFull = map(this.size, size => size === this.capacity());
@@ -64,13 +64,13 @@ class THubImpl {
       if (currentSubscriberCount === 0) {
         return succeed(true);
       }
-      const currentHubSize = unsafeGet(this.hubSize, runtime.journal);
-      if (currentHubSize < this.requestedCapacity) {
+      const currentPubSubSize = unsafeGet(this.pubsubSize, runtime.journal);
+      if (currentPubSubSize < this.requestedCapacity) {
         const updatedPublisherTail = new TRefImpl(void 0);
         const updatedNode = makeNode(value, currentSubscriberCount, updatedPublisherTail);
         unsafeSet(currentPublisherTail, updatedNode, runtime.journal);
         unsafeSet(this.publisherTail, updatedPublisherTail, runtime.journal);
-        unsafeSet(this.hubSize, currentHubSize + 1, runtime.journal);
+        unsafeSet(this.pubsubSize, currentPubSubSize + 1, runtime.journal);
         return succeed(true);
       }
       switch (this.strategy._tag) {
@@ -130,11 +130,11 @@ class THubImpl {
 }
 
 /** @internal */
-class THubSubscriptionImpl {
-  [THubTypeId] = THubTypeId;
+class TPubSubSubscriptionImpl {
+  [TPubSubTypeId] = TPubSubTypeId;
   [TDequeueTypeId] = tDequeueVariance;
-  constructor(hubSize, publisherHead, requestedCapacity, subscriberHead, subscriberCount, subscribers) {
-    this.hubSize = hubSize;
+  constructor(pubsubSize, publisherHead, requestedCapacity, subscriberHead, subscriberCount, subscribers) {
+    this.pubsubSize = pubsubSize;
     this.publisherHead = publisherHead;
     this.requestedCapacity = requestedCapacity;
     this.subscriberHead = subscriberHead;
@@ -239,11 +239,11 @@ class THubSubscriptionImpl {
           if (head !== undefined) {
             const subscribers = node.subscribers;
             if (subscribers === 1) {
-              const size = unsafeGet(this.hubSize, journal);
+              const size = unsafeGet(this.pubsubSize, journal);
               const updatedNode = makeNode(undefined, 0, tail);
               unsafeSet(currentSubscriberHead, updatedNode, journal);
               unsafeSet(this.publisherHead, tail, journal);
-              unsafeSet(this.hubSize, size - 1, journal);
+              unsafeSet(this.pubsubSize, size - 1, journal);
             } else {
               const updatedNode = makeNode(head, subscribers - 1, tail);
               unsafeSet(currentSubscriberHead, updatedNode, journal);
@@ -274,11 +274,11 @@ class THubSubscriptionImpl {
       if (head !== undefined) {
         const subscribers = node.subscribers;
         if (subscribers === 1) {
-          const size = unsafeGet(this.hubSize, runtime.journal);
+          const size = unsafeGet(this.pubsubSize, runtime.journal);
           const updatedNode = makeNode(void 0, 0, tail);
           unsafeSet(currentSubscriberHead, updatedNode, runtime.journal);
           unsafeSet(this.publisherHead, tail, runtime.journal);
-          unsafeSet(this.hubSize, size - 1, runtime.journal);
+          unsafeSet(this.pubsubSize, size - 1, runtime.journal);
         } else {
           const updatedNode = makeNode(head, subscribers - 1, tail);
           unsafeSet(currentSubscriberHead, updatedNode, runtime.journal);
@@ -311,11 +311,11 @@ class THubSubscriptionImpl {
           if (head !== undefined) {
             const subscribers = node.subscribers;
             if (subscribers === 1) {
-              const size = unsafeGet(this.hubSize, runtime.journal);
+              const size = unsafeGet(this.pubsubSize, runtime.journal);
               const updatedNode = makeNode(void 0, 0, tail);
               unsafeSet(currentSubscriberHead, updatedNode, runtime.journal);
               unsafeSet(this.publisherHead, tail, runtime.journal);
-              unsafeSet(this.hubSize, size - 1, runtime.journal);
+              unsafeSet(this.pubsubSize, size - 1, runtime.journal);
             } else {
               const updatedNode = makeNode(head, subscribers - 1, tail);
               unsafeSet(currentSubscriberHead, updatedNode, runtime.journal);
@@ -333,20 +333,20 @@ class THubSubscriptionImpl {
 }
 
 /** @internal */
-const makeHub = (requestedCapacity, strategy) => pipe(all([make(void 0), make(0)]), flatMap(([empty$1, hubSize]) => pipe(all([make(empty$1), make(empty$1), make(0), make(empty())]), map(([publisherHead, publisherTail, subscriberCount, subscribers]) => new THubImpl(hubSize, publisherHead, publisherTail, requestedCapacity, strategy, subscriberCount, subscribers)))));
-const makeSubscription = (hubSize, publisherHead, publisherTail, requestedCapacity, subscriberCount, subscribers) => pipe(get(publisherTail), flatMap(currentPublisherTail => pipe(all([make(currentPublisherTail), get(subscriberCount), get(subscribers)]), tap(([_, currentSubscriberCount]) => pipe(subscriberCount, set(currentSubscriberCount + 1))), tap(([subscriberHead, _, currentSubscribers]) => pipe(subscribers, set(pipe(currentSubscribers, add(subscriberHead))))), map(([subscriberHead]) => new THubSubscriptionImpl(hubSize, publisherHead, requestedCapacity, subscriberHead, subscriberCount, subscribers)))));
+const makeTPubSub = (requestedCapacity, strategy) => pipe(all([make(void 0), make(0)]), flatMap(([empty$1, pubsubSize]) => pipe(all([make(empty$1), make(empty$1), make(0), make(empty())]), map(([publisherHead, publisherTail, subscriberCount, subscribers]) => new TPubSubImpl(pubsubSize, publisherHead, publisherTail, requestedCapacity, strategy, subscriberCount, subscribers)))));
+const makeSubscription = (pubsubSize, publisherHead, publisherTail, requestedCapacity, subscriberCount, subscribers) => pipe(get(publisherTail), flatMap(currentPublisherTail => pipe(all([make(currentPublisherTail), get(subscriberCount), get(subscribers)]), tap(([_, currentSubscriberCount]) => pipe(subscriberCount, set(currentSubscriberCount + 1))), tap(([subscriberHead, _, currentSubscribers]) => pipe(subscribers, set(pipe(currentSubscribers, add(subscriberHead))))), map(([subscriberHead]) => new TPubSubSubscriptionImpl(pubsubSize, publisherHead, requestedCapacity, subscriberHead, subscriberCount, subscribers)))));
 
 /** @internal */
 const awaitShutdown = self => self.awaitShutdown;
 
 /** @internal */
-const bounded = requestedCapacity => makeHub(requestedCapacity, BackPressure);
+const bounded = requestedCapacity => makeTPubSub(requestedCapacity, BackPressure);
 
 /** @internal */
 const capacity = self => self.capacity();
 
 /** @internal */
-const dropping = requestedCapacity => makeHub(requestedCapacity, Dropping);
+const dropping = requestedCapacity => makeTPubSub(requestedCapacity, Dropping);
 
 /** @internal */
 const isEmpty = self => self.isEmpty;
@@ -367,15 +367,15 @@ const publishAll = /*#__PURE__*/dual(2, (self, iterable) => self.offerAll(iterab
 const size = self => self.size;
 
 /** @internal */
-const sliding = requestedCapacity => makeHub(requestedCapacity, Sliding);
+const sliding = requestedCapacity => makeTPubSub(requestedCapacity, Sliding);
 
 /** @internal */
-const subscribe = self => makeSubscription(self.hubSize, self.publisherHead, self.publisherTail, self.requestedCapacity, self.subscriberCount, self.subscribers);
+const subscribe = self => makeSubscription(self.pubsubSize, self.publisherHead, self.publisherTail, self.requestedCapacity, self.subscriberCount, self.subscribers);
 
 /** @internal */
 const subscribeScoped = self => acquireRelease(subscribe(self), dequeue => shutdown(dequeue));
 
 /** @internal */
-const unbounded = () => makeHub(Number.MAX_SAFE_INTEGER, Dropping);
+const unbounded = () => makeTPubSub(Number.MAX_SAFE_INTEGER, Dropping);
 
-export { THubTypeId, awaitShutdown, bounded, capacity, dropping, isEmpty, isFull, isShutdown, makeNode, publish, publishAll, size, sliding, subscribe, subscribeScoped, unbounded };
+export { TPubSubTypeId, awaitShutdown, bounded, capacity, dropping, isEmpty, isFull, isShutdown, makeNode, publish, publishAll, size, sliding, subscribe, subscribeScoped, unbounded };

package/internal/stream.esm.js

@@ -11,10 +11,10 @@ import { equals } from '../Equal/dist/effect-Equal.esm.js';
 import { match as match$3, failCause as failCause$2, fail as fail$2, isSuccess, succeed as succeed$4, unit as unit$3, isFailure } from '../Exit/dist/effect-Exit.esm.js';
 import { join, interrupt, poll as poll$1 } from '../Fiber/dist/effect-Fiber.esm.js';
 import { dual, pipe, identity, constTrue } from '../Function/dist/effect-Function.esm.js';
-import { bounded as bounded$1, subscribe, shutdown as shutdown$1 } from '../Hub/dist/effect-Hub.esm.js';
 import { build, context as context$2, merge as merge$1 } from '../Layer/dist/effect-Layer.esm.js';
 import { none, some as some$1, match as match$2, getOrElse, map as map$4, isSome, isNone } from '../Option/dist/effect-Option.esm.js';
 import { pipeArguments } from '../Pipeable/dist/effect-Pipeable.esm.js';
+import { bounded as bounded$1, subscribe, shutdown as shutdown$1 } from '../PubSub/dist/effect-PubSub.esm.js';
 import { take as take$2, shutdown, bounded, dropping, sliding as sliding$1, isShutdown, takeBetween, offerAll, offer as offer$1, unbounded } from '../Queue/dist/effect-Queue.esm.js';
 import { make as make$2, getAndSet, set, get, update, modify } from '../Ref/dist/effect-Ref.esm.js';
 import { runPromiseExit } from '../Runtime/dist/effect-Runtime.esm.js';
@@ -243,12 +243,12 @@ const broadcast = /*#__PURE__*/dual(3, (self, n, maximumLag) => pipe(self, broad
 const broadcastDynamic = /*#__PURE__*/dual(2, (self, maximumLag) => pipe(self, broadcastedQueuesDynamic(maximumLag), map$1(effect => flattenTake(flatMap(scoped(effect), fromQueue)))));
 
 /** @internal */
-const broadcastedQueues = /*#__PURE__*/dual(3, (self, n, maximumLag) => flatMap$2(bounded$1(maximumLag), hub => pipe(all(Array.from({
+const broadcastedQueues = /*#__PURE__*/dual(3, (self, n, maximumLag) => flatMap$2(bounded$1(maximumLag), pubsub => pipe(all(Array.from({
   length: n
-}, () => subscribe(hub))), tap$1(() => forkScoped(runIntoHubScoped(self, hub))))));
+}, () => subscribe(pubsub))), tap$1(() => forkScoped(runIntoPubSubScoped(self, pubsub))))));
 
 /** @internal */
-const broadcastedQueuesDynamic = /*#__PURE__*/dual(2, (self, maximumLag) => map$1(toHub(self, maximumLag), subscribe));
+const broadcastedQueuesDynamic = /*#__PURE__*/dual(2, (self, maximumLag) => map$1(toPubSub(self, maximumLag), subscribe));
 
 /** @internal */
 const buffer = /*#__PURE__*/dual(2, (self, options) => {
@@ -965,23 +965,26 @@ const fromChannel = channel => new StreamImpl(channel);
 
 /** @internal */
 const toChannel = stream => {
-  if (isEffect(stream)) {
+  if ("channel" in stream) {
+    return stream.channel;
+  } else if (isEffect(stream)) {
     return toChannel(fromEffect(stream));
+  } else {
+    throw new TypeError(`Expected a Stream.`);
   }
-  return stream.channel;
 };
 
 /** @internal */
 const fromChunk = chunk => new StreamImpl(isEmpty(chunk) ? unit$1 : write(chunk));
 
 /** @internal */
-const fromChunkHub = (hub, options) => {
+const fromChunkPubSub = (pubsub, options) => {
   if (options?.scoped) {
-    const effect = map$1(subscribe(hub), fromChunkQueue);
-    return options.shutdown ? map$1(effect, ensuring(shutdown$1(hub))) : effect;
+    const effect = map$1(subscribe(pubsub), fromChunkQueue);
+    return options.shutdown ? map$1(effect, ensuring(shutdown$1(pubsub))) : effect;
   }
-  const stream = flatMap(scoped(subscribe(hub)), fromChunkQueue);
-  return options?.shutdown ? ensuring(stream, shutdown$1(hub)) : stream;
+  const stream = flatMap(scoped(subscribe(pubsub)), fromChunkQueue);
+  return options?.shutdown ? ensuring(stream, shutdown$1(pubsub)) : stream;
 };
 
 /** @internal */
@@ -1003,19 +1006,19 @@ const fromEffectOption = effect => new StreamImpl(unwrap$1(match$1(effect, {
 })));
 
 /** @internal */
-const fromHub = (hub, options) => {
+const fromPubSub = (pubsub, options) => {
   const maxChunkSize = options?.maxChunkSize ?? DefaultChunkSize;
   if (options?.scoped) {
-    const effect = map$1(subscribe(hub), queue => fromQueue(queue, {
+    const effect = map$1(subscribe(pubsub), queue => fromQueue(queue, {
       maxChunkSize,
       shutdown: true
     }));
-    return options.shutdown ? map$1(effect, ensuring(shutdown$1(hub))) : effect;
+    return options.shutdown ? map$1(effect, ensuring(shutdown$1(pubsub))) : effect;
   }
-  const stream = flatMap(scoped(subscribe(hub)), queue => fromQueue(queue, {
+  const stream = flatMap(scoped(subscribe(pubsub)), queue => fromQueue(queue, {
     maxChunkSize
   }));
-  return options?.shutdown ? ensuring(stream, shutdown$1(hub)) : stream;
+  return options?.shutdown ? ensuring(stream, shutdown$1(pubsub)) : stream;
 };
 
 /** @internal */
@@ -1834,10 +1837,10 @@ const runForEachWhileScoped = /*#__PURE__*/dual(2, (self, f) => pipe(self, runSc
 const runHead = self => pipe(self, run(head()));
 
 /** @internal */
-const runIntoHub = /*#__PURE__*/dual(2, (self, hub) => pipe(self, runIntoQueue(hub)));
+const runIntoPubSub = /*#__PURE__*/dual(2, (self, pubsub) => pipe(self, runIntoQueue(pubsub)));
 
 /** @internal */
-const runIntoHubScoped = /*#__PURE__*/dual(2, (self, hub) => pipe(self, runIntoQueueScoped(hub)));
+const runIntoPubSubScoped = /*#__PURE__*/dual(2, (self, pubsub) => pipe(self, runIntoQueueScoped(pubsub)));
 
 /** @internal */
 const runIntoQueue = /*#__PURE__*/dual(2, (self, queue) => pipe(self, runIntoQueueScoped(queue), scoped$1));
@@ -2332,7 +2335,7 @@ const timeoutTo = /*#__PURE__*/dual(3, (self, duration, that) => {
 });
 
 /** @internal */
-const toHub = /*#__PURE__*/dual(2, (self, capacity) => pipe(acquireRelease$1(bounded$1(capacity), hub => shutdown$1(hub)), tap$1(hub => pipe(self, runIntoHubScoped(hub), forkScoped))));
+const toPubSub = /*#__PURE__*/dual(2, (self, capacity) => pipe(acquireRelease$1(bounded$1(capacity), pubsub => shutdown$1(pubsub)), tap$1(pubsub => pipe(self, runIntoPubSubScoped(pubsub), forkScoped))));
 
 /** @internal */
 const toPull = self => map$1(toPull$1(toChannel(self)), pull => pipe(pull, mapError$1(some$1), flatMap$2(match({
@@ -2981,4 +2984,4 @@ const encodeText = self => suspend(() => {
   return map(self, s => encoder.encode(s));
 });
 
-export { DefaultChunkSize, Do, StreamImpl, StreamTypeId, _async, acquireRelease, aggregate, aggregateWithin, aggregateWithinEither, as, asyncEffect, asyncInterrupt, asyncOption, asyncScoped, bind, bindTo, branchAfter, broadcast, broadcastDynamic, broadcastedQueues, broadcastedQueuesDynamic, buffer, bufferChunks, catchAll, catchAllCause, catchSome, catchSomeCause, catchTag, catchTags, changes, changesWith, changesWithEffect, channelToStream, chunks, chunksWith, combine, combineChunks, concat, concatAll, context, contextWith, contextWithEffect, contextWithStream, cross, crossLeft, crossRight, crossWith, debounce, decodeText, die, dieMessage, dieSync, distributedWith, distributedWithDynamic, distributedWithDynamicCallback, drain, drainFork, drop, dropRight, dropUntil, dropUntilEffect, dropWhile, dropWhileEffect, either, empty, encodeText, ensuring, ensuringWith, execute, fail, failCause, failCauseSync, failSync, filter, filterEffect, filterMap, filterMapEffect, filterMapWhile, filterMapWhileEffect, finalizer, find, findEffect, flatMap, flatten, flattenChunks, flattenEffect, flattenExitOption, flattenIterables, flattenTake, forever, fromAsyncIterable, fromChannel, fromChunk, fromChunkHub, fromChunkQueue, fromChunks, fromEffect, fromEffectOption, fromHub, fromIterable, fromIterableEffect, fromIteratorSucceed, fromPull, fromQueue, fromReadableStream, fromReadableStreamByob, fromSchedule, groupAdjacentBy, grouped, groupedWithin, haltAfter, haltWhen, haltWhenDeferred, identityStream, interleave, interleaveWith, interruptAfter, interruptWhen, interruptWhenDeferred, intersperse, intersperseAffixes, isStream, iterate, let_, make, map, mapAccum, mapAccumEffect, mapBoth, mapChunks, mapChunksEffect, mapConcat, mapConcatChunk, mapConcatChunkEffect, mapConcatEffect, mapEffectPar, mapEffectSequential, mapError, mapErrorCause, mapInputContext, matchConcurrency, merge, mergeAll, mergeEither, mergeLeft, mergeRight, mergeWith, mkString, never, onDone, onError, orDie, orDieWith, orElse, orElseEither, orElseFail, orElseIfEmpty, orElseIfEmptyChunk, orElseIfEmptyStream, orElseSucceed, paginate, paginateChunk, paginateChunkEffect, paginateEffect, partition, partitionEither, peel, pipeThrough, pipeThroughChannel, pipeThroughChannelOrFail, prepend, provideContext, provideLayer, provideService, provideServiceEffect, provideServiceStream, provideSomeLayer, range, rechunk, refineOrDie, refineOrDieWith, repeat, repeatEffect, repeatEffectChunk, repeatEffectChunkOption, repeatEffectOption, repeatEffectWithSchedule, repeatEither, repeatElements, repeatElementsWith, repeatValue, repeatWith, repeatWithSchedule, retry, run, runCollect, runCount, runDrain, runFold, runFoldEffect, runFoldScoped, runFoldScopedEffect, runFoldWhile, runFoldWhileEffect, runFoldWhileScoped, runFoldWhileScopedEffect, runForEach, runForEachChunk, runForEachChunkScoped, runForEachScoped, runForEachWhile, runForEachWhileScoped, runHead, runIntoHub, runIntoHubScoped, runIntoQueue, runIntoQueueElementsScoped, runIntoQueueScoped, runLast, runScoped, runSum, scan, scanEffect, scanReduce, scanReduceEffect, schedule, scheduleWith, scoped, sliding, slidingSize, some, someOrElse, someOrFail, split, splitLines, splitOnChunk, succeed, suspend, sync, take, takeRight, takeUntil, takeUntilEffect, takeWhile, tap, tapBoth, tapError, tapErrorCause, tapSink, throttle, throttleEffect, tick, timeout, timeoutFail, timeoutFailCause, timeoutTo, toChannel, toHub, toPull, toQueue, toQueueOfElements, toReadableStream, transduce, unfold, unfoldChunk, unfoldChunkEffect, unfoldEffect, unit, unwrap, unwrapScoped, updateService, when, whenCase, whenCaseEffect, whenEffect, withSpan, zip, zipAll, zipAllLeft, zipAllRight, zipAllSortedByKey, zipAllSortedByKeyLeft, zipAllSortedByKeyRight, zipAllSortedByKeyWith, zipAllWith, zipFlatten, zipLatest, zipLatestWith, zipLeft, zipRight, zipWith, zipWithChunks, zipWithIndex, zipWithNext, zipWithPrevious, zipWithPreviousAndNext };
+export { DefaultChunkSize, Do, StreamImpl, StreamTypeId, _async, acquireRelease, aggregate, aggregateWithin, aggregateWithinEither, as, asyncEffect, asyncInterrupt, asyncOption, asyncScoped, bind, bindTo, branchAfter, broadcast, broadcastDynamic, broadcastedQueues, broadcastedQueuesDynamic, buffer, bufferChunks, catchAll, catchAllCause, catchSome, catchSomeCause, catchTag, catchTags, changes, changesWith, changesWithEffect, channelToStream, chunks, chunksWith, combine, combineChunks, concat, concatAll, context, contextWith, contextWithEffect, contextWithStream, cross, crossLeft, crossRight, crossWith, debounce, decodeText, die, dieMessage, dieSync, distributedWith, distributedWithDynamic, distributedWithDynamicCallback, drain, drainFork, drop, dropRight, dropUntil, dropUntilEffect, dropWhile, dropWhileEffect, either, empty, encodeText, ensuring, ensuringWith, execute, fail, failCause, failCauseSync, failSync, filter, filterEffect, filterMap, filterMapEffect, filterMapWhile, filterMapWhileEffect, finalizer, find, findEffect, flatMap, flatten, flattenChunks, flattenEffect, flattenExitOption, flattenIterables, flattenTake, forever, fromAsyncIterable, fromChannel, fromChunk, fromChunkPubSub, fromChunkQueue, fromChunks, fromEffect, fromEffectOption, fromIterable, fromIterableEffect, fromIteratorSucceed, fromPubSub, fromPull, fromQueue, fromReadableStream, fromReadableStreamByob, fromSchedule, groupAdjacentBy, grouped, groupedWithin, haltAfter, haltWhen, haltWhenDeferred, identityStream, interleave, interleaveWith, interruptAfter, interruptWhen, interruptWhenDeferred, intersperse, intersperseAffixes, isStream, iterate, let_, make, map, mapAccum, mapAccumEffect, mapBoth, mapChunks, mapChunksEffect, mapConcat, mapConcatChunk, mapConcatChunkEffect, mapConcatEffect, mapEffectPar, mapEffectSequential, mapError, mapErrorCause, mapInputContext, matchConcurrency, merge, mergeAll, mergeEither, mergeLeft, mergeRight, mergeWith, mkString, never, onDone, onError, orDie, orDieWith, orElse, orElseEither, orElseFail, orElseIfEmpty, orElseIfEmptyChunk, orElseIfEmptyStream, orElseSucceed, paginate, paginateChunk, paginateChunkEffect, paginateEffect, partition, partitionEither, peel, pipeThrough, pipeThroughChannel, pipeThroughChannelOrFail, prepend, provideContext, provideLayer, provideService, provideServiceEffect, provideServiceStream, provideSomeLayer, range, rechunk, refineOrDie, refineOrDieWith, repeat, repeatEffect, repeatEffectChunk, repeatEffectChunkOption, repeatEffectOption, repeatEffectWithSchedule, repeatEither, repeatElements, repeatElementsWith, repeatValue, repeatWith, repeatWithSchedule, retry, run, runCollect, runCount, runDrain, runFold, runFoldEffect, runFoldScoped, runFoldScopedEffect, runFoldWhile, runFoldWhileEffect, runFoldWhileScoped, runFoldWhileScopedEffect, runForEach, runForEachChunk, runForEachChunkScoped, runForEachScoped, runForEachWhile, runForEachWhileScoped, runHead, runIntoPubSub, runIntoPubSubScoped, runIntoQueue, runIntoQueueElementsScoped, runIntoQueueScoped, runLast, runScoped, runSum, scan, scanEffect, scanReduce, scanReduceEffect, schedule, scheduleWith, scoped, sliding, slidingSize, some, someOrElse, someOrFail, split, splitLines, splitOnChunk, succeed, suspend, sync, take, takeRight, takeUntil, takeUntilEffect, takeWhile, tap, tapBoth, tapError, tapErrorCause, tapSink, throttle, throttleEffect, tick, timeout, timeoutFail, timeoutFailCause, timeoutTo, toChannel, toPubSub, toPull, toQueue, toQueueOfElements, toReadableStream, transduce, unfold, unfoldChunk, unfoldChunkEffect, unfoldEffect, unit, unwrap, unwrapScoped, updateService, when, whenCase, whenCaseEffect, whenEffect, withSpan, zip, zipAll, zipAllLeft, zipAllRight, zipAllSortedByKey, zipAllSortedByKeyLeft, zipAllSortedByKeyRight, zipAllSortedByKeyWith, zipAllWith, zipFlatten, zipLatest, zipLatestWith, zipLeft, zipRight, zipWith, zipWithChunks, zipWithIndex, zipWithNext, zipWithPrevious, zipWithPreviousAndNext };

package/internal/subscriptionRef.esm.js

@@ -1,12 +1,12 @@
 import { map, all, makeSemaphore, zipLeft, flatMap, succeed, as } from '../Effect/dist/effect-Effect.esm.js';
 import { pipe, dual } from '../Function/dist/effect-Function.esm.js';
-import { unbounded, publish } from '../Hub/dist/effect-Hub.esm.js';
 import { synchronizedVariance } from './effect/circular.esm.js';
 import { refVariance } from './ref.esm.js';
 import { pipeArguments } from '../Pipeable/dist/effect-Pipeable.esm.js';
+import { unbounded, publish } from '../PubSub/dist/effect-PubSub.esm.js';
 import { get as get$1, make as make$1, set as set$1, RefTypeId } from '../Ref/dist/effect-Ref.esm.js';
 import { SynchronizedRefTypeId } from '../SynchronizedRef/dist/effect-SynchronizedRef.esm.js';
-import { unwrapScoped, fromHub, concat, make as make$2 } from './stream.esm.js';
+import { unwrapScoped, fromPubSub, concat, make as make$2 } from './stream.esm.js';
 
 /** @internal */
 const SubscriptionRefSymbolKey = "effect/SubscriptionRef";
@@ -26,16 +26,16 @@ class SubscriptionRefImpl {
   // @ts-ignore
   [SynchronizedRefTypeId] = synchronizedVariance;
   [SubscriptionRefTypeId] = subscriptionRefVariance;
-  constructor(ref, hub, semaphore) {
+  constructor(ref, pubsub, semaphore) {
     this.ref = ref;
-    this.hub = hub;
+    this.pubsub = pubsub;
     this.semaphore = semaphore;
   }
   pipe() {
     return pipeArguments(this, arguments);
   }
   get changes() {
-    return pipe(get$1(this.ref), flatMap(a => map(fromHub(this.hub, {
+    return pipe(get$1(this.ref), flatMap(a => map(fromPubSub(this.pubsub, {
       scoped: true
     }), s => concat(make$2(a), s))), this.semaphore.withPermits(1), unwrapScoped);
   }
@@ -43,7 +43,7 @@ class SubscriptionRefImpl {
     return this.modifyEffect(a => succeed(f(a)));
   }
   modifyEffect(f) {
-    return pipe(get$1(this.ref), flatMap(f), flatMap(([b, a]) => pipe(set$1(this.ref, a), as(b), zipLeft(publish(this.hub, a)))), this.semaphore.withPermits(1));
+    return pipe(get$1(this.ref), flatMap(f), flatMap(([b, a]) => pipe(set$1(this.ref, a), as(b), zipLeft(publish(this.pubsub, a)))), this.semaphore.withPermits(1));
   }
 }
 
@@ -51,7 +51,7 @@ class SubscriptionRefImpl {
 const get = self => get$1(self.ref);
 
 /** @internal */
-const make = value => pipe(all([unbounded(), make$1(value), makeSemaphore(1)]), map(([hub, ref, semaphore]) => new SubscriptionRefImpl(ref, hub, semaphore)));
+const make = value => pipe(all([unbounded(), make$1(value), makeSemaphore(1)]), map(([pubsub, ref, semaphore]) => new SubscriptionRefImpl(ref, pubsub, semaphore)));
 
 /** @internal */
 const modify = /*#__PURE__*/dual(2, (self, f) => self.modify(f));
@@ -60,6 +60,6 @@ const modify = /*#__PURE__*/dual(2, (self, f) => self.modify(f));
 const modifyEffect = /*#__PURE__*/dual(2, (self, f) => self.modifyEffect(f));
 
 /** @internal */
-const set = /*#__PURE__*/dual(2, (self, value) => pipe(set$1(self.ref, value), zipLeft(publish(self.hub, value)), self.semaphore.withPermits(1)));
+const set = /*#__PURE__*/dual(2, (self, value) => pipe(set$1(self.ref, value), zipLeft(publish(self.pubsub, value)), self.semaphore.withPermits(1)));
 
 export { SubscriptionRefTypeId, get, make, modify, modifyEffect, set };