effect 2.0.0-next.38 → 2.0.0-next.39

package/{dist/Stack-765c2298.esm.js → internal/Stack.esm.js}

@@ -6,4 +6,4 @@ class Stack {
   }
 }
 
-export { Stack as S };
+export { Stack };

package/internal/blockedRequests.esm.js

@@ -0,0 +1,365 @@
+import { right, left } from '../Either/dist/effect-Either.esm.js';
+import { equals } from '../Equal/dist/effect-Equal.esm.js';
+import { empty as empty$2, make, reduce as reduce$2, set, get, isEmpty, keys, map } from '../HashMap/dist/effect-HashMap.esm.js';
+import { of, isCons, cons, reduce as reduce$1, empty as empty$1, unsafeHead, unsafeTail, isNil, appendAll, reverse } from '../List/dist/effect-List.esm.js';
+import { match } from '../Option/dist/effect-Option.esm.js';
+
+/** @internal */
+const empty = {
+  _tag: "Empty"
+};
+
+/**
+ * Combines this collection of blocked requests with the specified collection
+ * of blocked requests, in parallel.
+ *
+ * @internal
+ */
+const par = (self, that) => ({
+  _tag: "Par",
+  left: self,
+  right: that
+});
+
+/**
+ * Combines this collection of blocked requests with the specified collection
+ * of blocked requests, in sequence.
+ *
+ * @internal
+ */
+const seq = (self, that) => ({
+  _tag: "Seq",
+  left: self,
+  right: that
+});
+
+/**
+ * Constructs a collection of blocked requests from the specified blocked
+ * request and data source.
+ *
+ * @internal
+ */
+const single = (dataSource, blockedRequest) => ({
+  _tag: "Single",
+  dataSource,
+  blockedRequest
+});
+
+/** @internal */
+const MapRequestResolversReducer = f => ({
+  emptyCase: () => empty,
+  parCase: (left, right) => par(left, right),
+  seqCase: (left, right) => seq(left, right),
+  singleCase: (dataSource, blockedRequest) => single(f(dataSource), blockedRequest)
+});
+/**
+ * Transforms all data sources with the specified data source aspect, which
+ * can change the environment type of data sources but must preserve the
+ * request type of each data source.
+ *
+ * @internal
+ */
+const mapRequestResolvers = (self, f) => reduce(self, MapRequestResolversReducer(f));
+
+/**
+ * Folds over the cases of this collection of blocked requests with the
+ * specified functions.
+ *
+ * @internal
+ */
+const reduce = (self, reducer) => {
+  let input = of(self);
+  let output = empty$1();
+  while (isCons(input)) {
+    const current = input.head;
+    switch (current._tag) {
+      case "Empty":
+        {
+          output = cons(right(reducer.emptyCase()), output);
+          input = input.tail;
+          break;
+        }
+      case "Par":
+        {
+          output = cons(left({
+            _tag: "ParCase"
+          }), output);
+          input = cons(current.left, cons(current.right, input.tail));
+          break;
+        }
+      case "Seq":
+        {
+          output = cons(left({
+            _tag: "SeqCase"
+          }), output);
+          input = cons(current.left, cons(current.right, input.tail));
+          break;
+        }
+      case "Single":
+        {
+          const result = reducer.singleCase(current.dataSource, current.blockedRequest);
+          output = cons(right(result), output);
+          input = input.tail;
+          break;
+        }
+    }
+  }
+  const result = reduce$1(output, empty$1(), (acc, current) => {
+    switch (current._tag) {
+      case "Left":
+        {
+          const left = unsafeHead(acc);
+          const right = unsafeHead(unsafeTail(acc));
+          const tail = unsafeTail(unsafeTail(acc));
+          switch (current.left._tag) {
+            case "ParCase":
+              {
+                return cons(reducer.parCase(left, right), tail);
+              }
+            case "SeqCase":
+              {
+                return cons(reducer.seqCase(left, right), tail);
+              }
+          }
+        }
+      case "Right":
+        {
+          return cons(current.right, acc);
+        }
+    }
+  });
+  if (isNil(result)) {
+    throw new Error("BUG: BlockedRequests.reduce - please report an issue at https://github.com/Effect-TS/query/issues");
+  }
+  return result.head;
+};
+
+/**
+ * Flattens a collection of blocked requests into a collection of pipelined
+ * and batched requests that can be submitted for execution.
+ *
+ * @internal
+ */
+const flatten = self => {
+  let current = of(self);
+  let updated = empty$1();
+  // eslint-disable-next-line no-constant-condition
+  while (1) {
+    const [parallel, sequential] = reduce$1(current, [parallelCollectionEmpty(), empty$1()], ([parallel, sequential], blockedRequest) => {
+      const [par, seq] = step(blockedRequest);
+      return [parallelCollectionCombine(parallel, par), appendAll(sequential, seq)];
+    });
+    updated = merge(updated, parallel);
+    if (isNil(sequential)) {
+      return reverse(updated);
+    }
+    current = sequential;
+  }
+  throw new Error("BUG: BlockedRequests.flatten - please report an issue at https://github.com/Effect-TS/query/issues");
+};
+
+/**
+ * Takes one step in evaluating a collection of blocked requests, returning a
+ * collection of blocked requests that can be performed in parallel and a list
+ * of blocked requests that must be performed sequentially after those
+ * requests.
+ */
+const step = requests => {
+  let current = requests;
+  let parallel = parallelCollectionEmpty();
+  let stack = empty$1();
+  let sequential = empty$1();
+  // eslint-disable-next-line no-constant-condition
+  while (1) {
+    switch (current._tag) {
+      case "Empty":
+        {
+          if (isNil(stack)) {
+            return [parallel, sequential];
+          }
+          current = stack.head;
+          stack = stack.tail;
+          break;
+        }
+      case "Par":
+        {
+          stack = cons(current.right, stack);
+          current = current.left;
+          break;
+        }
+      case "Seq":
+        {
+          const left = current.left;
+          const right = current.right;
+          switch (left._tag) {
+            case "Empty":
+              {
+                current = right;
+                break;
+              }
+            case "Par":
+              {
+                const l = left.left;
+                const r = left.right;
+                current = par(seq(l, right), seq(r, right));
+                break;
+              }
+            case "Seq":
+              {
+                const l = left.left;
+                const r = left.right;
+                current = seq(l, seq(r, right));
+                break;
+              }
+            case "Single":
+              {
+                current = left;
+                sequential = cons(right, sequential);
+                break;
+              }
+          }
+          break;
+        }
+      case "Single":
+        {
+          parallel = parallelCollectionCombine(parallel, parallelCollectionMake(current.dataSource, current.blockedRequest));
+          if (isNil(stack)) {
+            return [parallel, sequential];
+          }
+          current = stack.head;
+          stack = stack.tail;
+          break;
+        }
+    }
+  }
+  throw new Error("BUG: BlockedRequests.step - please report an issue at https://github.com/Effect-TS/query/issues");
+};
+
+/**
+ * Merges a collection of requests that must be executed sequentially with a
+ * collection of requests that can be executed in parallel. If the collections
+ * are both from the same single data source then the requests can be
+ * pipelined while preserving ordering guarantees.
+ */
+const merge = (sequential, parallel) => {
+  if (isNil(sequential)) {
+    return of(parallelCollectionToSequentialCollection(parallel));
+  }
+  if (parallelCollectionIsEmpty(parallel)) {
+    return sequential;
+  }
+  const seqHeadKeys = sequentialCollectionKeys(sequential.head);
+  const parKeys = parallelCollectionKeys(parallel);
+  if (seqHeadKeys.length === 1 && parKeys.length === 1 && equals(seqHeadKeys[0], parKeys[0])) {
+    return cons(sequentialCollectionCombine(sequential.head, parallelCollectionToSequentialCollection(parallel)), sequential.tail);
+  }
+  return cons(parallelCollectionToSequentialCollection(parallel), sequential);
+};
+
+//
+// circular
+//
+
+/** @internal */
+const EntryTypeId = /*#__PURE__*/Symbol.for("effect/RequestBlock/Entry");
+
+/** @internal */
+class EntryImpl {
+  [EntryTypeId] = blockedRequestVariance;
+  constructor(request, result, listeners, ownerId, state) {
+    this.request = request;
+    this.result = result;
+    this.listeners = listeners;
+    this.ownerId = ownerId;
+    this.state = state;
+  }
+}
+
+/** @internal */
+const blockedRequestVariance = {
+  _R: _ => _
+};
+
+/** @internal */
+const isEntry = u => {
+  return typeof u === "object" && u != null && EntryTypeId in u;
+};
+
+/** @internal */
+const makeEntry = options => new EntryImpl(options.request, options.result, options.listeners, options.ownerId, options.state);
+
+/** @internal */
+const RequestBlockParallelTypeId = /*#__PURE__*/Symbol.for("effect/RequestBlock/RequestBlockParallel");
+const parallelVariance = {
+  _R: _ => _
+};
+class ParallelImpl {
+  [RequestBlockParallelTypeId] = parallelVariance;
+  constructor(map) {
+    this.map = map;
+  }
+}
+
+/** @internal */
+const parallelCollectionEmpty = () => new ParallelImpl(empty$2());
+
+/** @internal */
+const parallelCollectionMake = (dataSource, blockedRequest) => new ParallelImpl(make([dataSource, Array.of(blockedRequest)]));
+
+/** @internal */
+const parallelCollectionCombine = (self, that) => new ParallelImpl(reduce$2(self.map, that.map, (map, value, key) => set(map, key, match(get(map, key), {
+  onNone: () => value,
+  onSome: a => [...a, ...value]
+}))));
+
+/** @internal */
+const parallelCollectionIsEmpty = self => isEmpty(self.map);
+
+/** @internal */
+const parallelCollectionKeys = self => Array.from(keys(self.map));
+
+/** @internal */
+const parallelCollectionToSequentialCollection = self => sequentialCollectionMake(map(self.map, x => Array.of(x)));
+
+/** @internal */
+const SequentialCollectionTypeId = /*#__PURE__*/Symbol.for("effect/RequestBlock/RequestBlockSequential");
+
+/** @internal */
+const sequentialVariance = {
+  _R: _ => _
+};
+class SequentialImpl {
+  [SequentialCollectionTypeId] = sequentialVariance;
+  constructor(map) {
+    this.map = map;
+  }
+}
+
+/** @internal */
+const sequentialCollectionMake = map => new SequentialImpl(map);
+
+/** @internal */
+const sequentialCollectionCombine = (self, that) => new SequentialImpl(reduce$2(that.map, self.map, (map, value, key) => set(map, key, match(get(map, key), {
+  onNone: () => [],
+  onSome: a => [...a, ...value]
+}))));
+
+/** @internal */
+const sequentialCollectionKeys = self => Array.from(keys(self.map));
+
+/** @internal */
+const sequentialCollectionToChunk = self => Array.from(self.map);
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+
+export { EntryTypeId, MapRequestResolversReducer, RequestBlockParallelTypeId, SequentialCollectionTypeId, empty, flatten, isEntry, makeEntry, mapRequestResolvers, par, parallelCollectionCombine, parallelCollectionEmpty, parallelCollectionIsEmpty, parallelCollectionKeys, parallelCollectionMake, parallelCollectionToSequentialCollection, reduce, seq, sequentialCollectionCombine, sequentialCollectionKeys, sequentialCollectionMake, sequentialCollectionToChunk, single };

package/{dist/cache-d62912e6.esm.js → internal/cache.esm.js}

@@ -1,20 +1,20 @@
-import { e as empty$1 } from './Context-c41aa832.esm.js';
-import { s as struct } from './Data-dee529b9.esm.js';
-import { u as unsafeMake, _ as _await, b as interrupt, d as done } from './Deferred-9010d2ac.esm.js';
-import { d as decode, t as toMillis } from './Duration-98bca14c.esm.js';
-import { m as merge, r as right, l as left } from './Either-aa46c018.esm.js';
-import { e as equals, s as symbol$1 } from './Equal-2a99fde3.esm.js';
-import { s as succeed$1 } from './Exit-666b4f01.esm.js';
-import { p as pipe } from './Function-12511160.esm.js';
-import { s as symbol, c as combine, h as hash } from './Hash-7910f34f.esm.js';
-import { a as size, g as get, h as has, s as set, r as remove, e as empty } from './MutableHashMap-02b39969.esm.js';
-import { o as offer, a as poll, E as EmptyMutableQueue, u as unbounded } from './MutableQueue-446ac662.esm.js';
-import { c as compareAndSet, s as set$1, m as make$1 } from './MutableRef-2734b082.esm.js';
-import { b as match, n as none, i as isSome, s as some, c as getOrUndefined } from './Option-df40d2b9.esm.js';
-import { m as map, bv as context, n as fiberId, s as sync, a as suspend, j as succeed, f as flatMap, c as asUnit, o as onInterrupt, z as zipRight, P as exit, bC as provideContext } from './core-64ab7ff5.esm.js';
-import { $ as clockWith, ao as when } from './core-effect-57445976.esm.js';
-import { b as none$1 } from './FiberId-17e50f05.esm.js';
-import { a as all } from './fiberRuntime-bfcf5f49.esm.js';
+import { empty as empty$1 } from '../Context/dist/effect-Context.esm.js';
+import { struct } from '../Data/dist/effect-Data.esm.js';
+import { unsafeMake, await as _await, interrupt, done } from '../Deferred/dist/effect-Deferred.esm.js';
+import { decode, toMillis } from '../Duration/dist/effect-Duration.esm.js';
+import { merge, right, left } from '../Either/dist/effect-Either.esm.js';
+import { equals, symbol as symbol$1 } from '../Equal/dist/effect-Equal.esm.js';
+import { succeed as succeed$1 } from '../Exit/dist/effect-Exit.esm.js';
+import { pipe } from '../Function/dist/effect-Function.esm.js';
+import { symbol, combine, hash } from '../Hash/dist/effect-Hash.esm.js';
+import { size, get, has, set, remove, empty } from '../MutableHashMap/dist/effect-MutableHashMap.esm.js';
+import { offer, poll, EmptyMutableQueue, unbounded } from '../MutableQueue/dist/effect-MutableQueue.esm.js';
+import { compareAndSet, set as set$1, make as make$1 } from '../MutableRef/dist/effect-MutableRef.esm.js';
+import { match, none, isSome, some, getOrUndefined } from '../Option/dist/effect-Option.esm.js';
+import { map, context, fiberId, sync, suspend, succeed, flatMap, asUnit, onInterrupt, zipRight, exit, provideContext } from './core.esm.js';
+import { clockWith, when } from './core-effect.esm.js';
+import { none as none$1 } from './fiberId.esm.js';
+import { all } from './fiberRuntime.esm.js';
 
 /**
  * A `MapValue` represents a value in the cache. A value may either be
@@ -511,4 +511,4 @@ const makeWith = options => map(all([context(), fiberId]), ([context, fiberId])
 /** @internal */
 const unsafeMakeWith = (capacity, lookup, timeToLive) => new CacheImpl(capacity, empty$1(), none$1, lookup, exit => decode(timeToLive(exit)));
 
-export { CacheTypeId as C, makeWith as a, makeCacheStats as b, makeEntryStats as c, makeMapKey as d, makeKeySet as e, make as m, unsafeMakeWith as u };
+export { CacheTypeId, MapKeyTypeId, complete, initialCacheState, isMapKey, make, makeCacheState, makeCacheStats, makeEntryStats, makeKeySet, makeMapKey, makeWith, pending, refreshing, unsafeMakeWith };