effect 2.4.3 → 2.4.5

package/src/internal/core.ts

@@ -26,7 +26,7 @@ import type * as MetricLabel from "../MetricLabel.js"
 import * as MutableRef from "../MutableRef.js"
 import * as Option from "../Option.js"
 import { pipeArguments } from "../Pipeable.js"
-import { hasProperty, isObject, isPromise, isString, type Predicate, type Refinement } from "../Predicate.js"
+import { hasProperty, isObject, isPromiseLike, isString, type Predicate, type Refinement } from "../Predicate.js"
 import * as ReadonlyArray from "../ReadonlyArray.js"
 import type * as Request from "../Request.js"
 import type * as BlockedRequests from "../RequestBlock.js"
@@ -694,35 +694,35 @@ export const andThen: {
   ): <E, R>(
     self: Effect.Effect<A, E, R>
   ) => [X] extends [Effect.Effect<infer A1, infer E1, infer R1>] ? Effect.Effect<A1, E | E1, R | R1>
-    : [X] extends [Promise<infer A1>] ? Effect.Effect<A1, E | Cause.UnknownException, R>
+    : [X] extends [PromiseLike<infer A1>] ? Effect.Effect<A1, E | Cause.UnknownException, R>
     : Effect.Effect<X, E, R>
   <X>(
     f: NotFunction<X>
   ): <A, E, R>(
     self: Effect.Effect<A, E, R>
   ) => [X] extends [Effect.Effect<infer A1, infer E1, infer R1>] ? Effect.Effect<A1, E | E1, R | R1>
-    : [X] extends [Promise<infer A1>] ? Effect.Effect<A1, E | Cause.UnknownException, R>
+    : [X] extends [PromiseLike<infer A1>] ? Effect.Effect<A1, E | Cause.UnknownException, R>
     : Effect.Effect<X, E, R>
   <A, E, R, X>(
     self: Effect.Effect<A, E, R>,
     f: (a: NoInfer<A>) => X
   ): [X] extends [Effect.Effect<infer A1, infer E1, infer R1>] ? Effect.Effect<A1, E | E1, R | R1>
-    : [X] extends [Promise<infer A1>] ? Effect.Effect<A1, E | Cause.UnknownException, R>
+    : [X] extends [PromiseLike<infer A1>] ? Effect.Effect<A1, E | Cause.UnknownException, R>
     : Effect.Effect<X, E, R>
   <A, E, R, X>(
     self: Effect.Effect<A, E, R>,
     f: NotFunction<X>
   ): [X] extends [Effect.Effect<infer A1, infer E1, infer R1>] ? Effect.Effect<A1, E | E1, R | R1>
-    : [X] extends [Promise<infer A1>] ? Effect.Effect<A1, E | Cause.UnknownException, R>
+    : [X] extends [PromiseLike<infer A1>] ? Effect.Effect<A1, E | Cause.UnknownException, R>
     : Effect.Effect<X, E, R>
 } = dual(2, (self, f) =>
   flatMap(self, (a) => {
     const b = typeof f === "function" ? (f as any)(a) : f
     if (isEffect(b)) {
       return b
-    } else if (isPromise(b)) {
+    } else if (isPromiseLike(b)) {
       return async<any, Cause.UnknownException>((resume) => {
-        b.then((a) => resume(succeed(a))).catch((e) => resume(fail(new UnknownException(e))))
+        b.then((a) => resume(succeed(a)), (e) => resume(fail(new UnknownException(e))))
       })
     }
     return succeed(b)
@@ -1166,14 +1166,14 @@ export const tap = dual<
     ): <E, R>(
       self: Effect.Effect<A, E, R>
     ) => [X] extends [Effect.Effect<infer _A1, infer E1, infer R1>] ? Effect.Effect<A, E | E1, R | R1>
-      : [X] extends [Promise<infer _A1>] ? Effect.Effect<A, E | Cause.UnknownException, R>
+      : [X] extends [PromiseLike<infer _A1>] ? Effect.Effect<A, E | Cause.UnknownException, R>
       : Effect.Effect<A, E, R>
     <X>(
       f: NotFunction<X>
     ): <A, E, R>(
       self: Effect.Effect<A, E, R>
     ) => [X] extends [Effect.Effect<infer _A1, infer E1, infer R1>] ? Effect.Effect<A, E | E1, R | R1>
-      : [X] extends [Promise<infer _A1>] ? Effect.Effect<A, E | Cause.UnknownException, R>
+      : [X] extends [PromiseLike<infer _A1>] ? Effect.Effect<A, E | Cause.UnknownException, R>
       : Effect.Effect<A, E, R>
   },
   {
@@ -1181,13 +1181,13 @@ export const tap = dual<
       self: Effect.Effect<A, E, R>,
       f: (a: NoInfer<A>) => X
     ): [X] extends [Effect.Effect<infer _A1, infer E1, infer R1>] ? Effect.Effect<A, E | E1, R | R1>
-      : [X] extends [Promise<infer _A1>] ? Effect.Effect<A, E | Cause.UnknownException, R>
+      : [X] extends [PromiseLike<infer _A1>] ? Effect.Effect<A, E | Cause.UnknownException, R>
       : Effect.Effect<A, E, R>
     <A, E, R, X>(
       self: Effect.Effect<A, E, R>,
       f: NotFunction<X>
     ): [X] extends [Effect.Effect<infer _A1, infer E1, infer R1>] ? Effect.Effect<A, E | E1, R | R1>
-      : [X] extends [Promise<infer _A1>] ? Effect.Effect<A, E | Cause.UnknownException, R>
+      : [X] extends [PromiseLike<infer _A1>] ? Effect.Effect<A, E | Cause.UnknownException, R>
       : Effect.Effect<A, E, R>
   }
 >(2, (self, f) =>
@@ -1195,9 +1195,9 @@ export const tap = dual<
     const b = typeof f === "function" ? (f as any)(a) : f
     if (isEffect(b)) {
       return as(b, a)
-    } else if (isPromise(b)) {
+    } else if (isPromiseLike(b)) {
       return async<any, Cause.UnknownException>((resume) => {
-        b.then((_) => resume(succeed(a))).catch((e) => resume(fail(new UnknownException(e))))
+        b.then((_) => resume(succeed(a)), (e) => resume(fail(new UnknownException(e))))
       })
     }
     return succeed(a)

package/src/internal/fiberRuntime.ts

@@ -234,13 +234,15 @@ const runBlockedRequests = (self: RequestBlock.RequestBlock) =>
         _RequestBlock.sequentialCollectionToChunk(requestsByRequestResolver),
         ([dataSource, sequential]) => {
           const map = new Map<Request<any, any>, Entry<any>>()
+          const arr: Array<Array<Entry<any>>> = []
           for (const block of sequential) {
+            arr.push(Chunk.toReadonlyArray(block) as any)
             for (const entry of block) {
               map.set(entry.request as Request<any, any>, entry)
             }
           }
           return core.fiberRefLocally(
-            invokeWithInterrupt(dataSource.runAll(sequential), sequential.flat()),
+            invokeWithInterrupt(dataSource.runAll(arr), arr.flat()),
             currentRequestMap,
             map
           )

package/src/internal/managedRuntime.ts

@@ -88,10 +88,12 @@ export const make = <R, ER>(
         internalRuntime.unsafeRunSyncEffect(provide(self, effect)) :
         internalRuntime.unsafeRunSync(self.cachedRuntime)(effect)
     },
-    runPromiseExit<A, E>(effect: Effect.Effect<A, E, R>): Promise<Exit<A, E | ER>> {
+    runPromiseExit<A, E>(effect: Effect.Effect<A, E, R>, options?: {
+      readonly signal?: AbortSignal | undefined
+    }): Promise<Exit<A, E | ER>> {
       return self.cachedRuntime === undefined ?
-        internalRuntime.unsafeRunPromiseExitEffect(provide(self, effect)) :
-        internalRuntime.unsafeRunPromiseExit(self.cachedRuntime)(effect)
+        internalRuntime.unsafeRunPromiseExitEffect(provide(self, effect), options) :
+        internalRuntime.unsafeRunPromiseExit(self.cachedRuntime)(effect, options)
     },
     runCallback<A, E>(
       effect: Effect.Effect<A, E, R>,
@@ -101,10 +103,12 @@ export const make = <R, ER>(
         internalRuntime.unsafeRunCallback(internalRuntime.defaultRuntime)(provide(self, effect), options) :
         internalRuntime.unsafeRunCallback(self.cachedRuntime)(effect, options)
     },
-    runPromise<A, E>(effect: Effect.Effect<A, E, R>): Promise<A> {
+    runPromise<A, E>(effect: Effect.Effect<A, E, R>, options?: {
+      readonly signal?: AbortSignal | undefined
+    }): Promise<A> {
       return self.cachedRuntime === undefined ?
-        internalRuntime.unsafeRunPromiseEffect(provide(self, effect)) :
-        internalRuntime.unsafeRunPromise(self.cachedRuntime)(effect)
+        internalRuntime.unsafeRunPromiseEffect(provide(self, effect), options) :
+        internalRuntime.unsafeRunPromise(self.cachedRuntime)(effect, options)
     }
   }
   return self

package/src/internal/runtime.ts

@@ -257,31 +257,51 @@ export const unsafeRunSyncExit =
   }
 
 /** @internal */
-export const unsafeRunPromise =
-  <R>(runtime: Runtime.Runtime<R>) => <A, E>(effect: Effect.Effect<A, E, R>): Promise<A> =>
-    unsafeRunPromiseExit(runtime)(effect).then((result) => {
-      switch (result._tag) {
-        case OpCodes.OP_SUCCESS: {
-          return result.i0
-        }
-        case OpCodes.OP_FAILURE: {
-          throw fiberFailure(result.i0)
-        }
+export const unsafeRunPromise = <R>(runtime: Runtime.Runtime<R>) =>
+<A, E>(
+  effect: Effect.Effect<A, E, R>,
+  options?: {
+    readonly signal?: AbortSignal | undefined
+  } | undefined
+): Promise<A> =>
+  unsafeRunPromiseExit(runtime)(effect, options).then((result) => {
+    switch (result._tag) {
+      case OpCodes.OP_SUCCESS: {
+        return result.i0
       }
-    })
+      case OpCodes.OP_FAILURE: {
+        throw fiberFailure(result.i0)
+      }
+    }
+  })
 
 /** @internal */
-export const unsafeRunPromiseExit =
-  <R>(runtime: Runtime.Runtime<R>) => <A, E>(effect: Effect.Effect<A, E, R>): Promise<Exit.Exit<A, E>> =>
-    new Promise((resolve) => {
-      const op = fastPath(effect)
-      if (op) {
-        resolve(op)
-      }
-      unsafeFork(runtime)(effect).addObserver((exit) => {
-        resolve(exit)
-      })
+export const unsafeRunPromiseExit = <R>(runtime: Runtime.Runtime<R>) =>
+<A, E>(
+  effect: Effect.Effect<A, E, R>,
+  options?: {
+    readonly signal?: AbortSignal | undefined
+  } | undefined
+): Promise<Exit.Exit<A, E>> =>
+  new Promise((resolve) => {
+    const op = fastPath(effect)
+    if (op) {
+      resolve(op)
+    }
+    const fiber = unsafeFork(runtime)(effect)
+    fiber.addObserver((exit) => {
+      resolve(exit)
     })
+    if (options?.signal !== undefined) {
+      if (options.signal.aborted) {
+        fiber.unsafeInterruptAsFork(fiber.id())
+      } else {
+        options.signal.addEventListener("abort", () => {
+          fiber.unsafeInterruptAsFork(fiber.id())
+        })
+      }
+    }
+  })
 
 /** @internal */
 export class RuntimeImpl<in R> implements Runtime.Runtime<R> {

package/src/internal/version.ts

@@ -1,4 +1,4 @@
-let moduleVersion = "2.4.3"
+let moduleVersion = "2.4.5"
 
 export const getCurrentVersion = () => moduleVersion