effect 3.5.2 → 3.5.4

package/src/Data.ts

@@ -532,7 +532,7 @@ export const Error: new<A extends Record<string, any> = {}>(
 ) => Cause.YieldableError & Readonly<A> = (function() {
   return class Base extends core.YieldableError {
     constructor(args: any) {
-      super(args?.message, { cause: args?.cause })
+      super(args?.message, args?.cause ? { cause: args.cause } : undefined)
       if (args) {
         Object.assign(this, args)
       }

package/src/Option.ts

@@ -422,14 +422,16 @@ export const orElseEither: {
  * @category error handling
  * @since 2.0.0
  */
-export const firstSomeOf = <A>(collection: Iterable<Option<A>>): Option<A> => {
-  let out: Option<A> = none()
+export const firstSomeOf = <T, C extends Iterable<Option<T>> = Iterable<Option<T>>>(
+  collection: C
+): [C] extends [Iterable<Option<infer A>>] ? Option<A> : never => {
+  let out: Option<unknown> = none()
   for (out of collection) {
     if (isSome(out)) {
-      return out
+      return out as any
     }
   }
-  return out
+  return out as any
 }
 
 /**

package/src/Predicate.ts

@@ -750,6 +750,8 @@ export const not = <A>(self: Predicate<A>): Predicate<A> => (a) => !self(a)
  * @since 2.0.0
  */
 export const or: {
+  <A, C extends A>(that: Refinement<A, C>): <B extends A>(self: Refinement<A, B>) => Refinement<A, B | C>
+  <A, B extends A, C extends A>(self: Refinement<A, B>, that: Refinement<A, C>): Refinement<A, B | C>
   <A>(that: Predicate<A>): (self: Predicate<A>) => Predicate<A>
   <A>(self: Predicate<A>, that: Predicate<A>): Predicate<A>
 } = dual(2, <A>(self: Predicate<A>, that: Predicate<A>): Predicate<A> => (a) => self(a) || that(a))

package/src/Stream.ts

@@ -3679,7 +3679,7 @@ export const retry: {
 export const run: {
   <A2, A, E2, R2>(
     sink: Sink.Sink<A2, A, unknown, E2, R2>
-  ): <E, R>(self: Stream<A, E, R>) => Effect.Effect<A2, E2 | E, R2 | R>
+  ): <E, R>(self: Stream<A, E, R>) => Effect.Effect<A2, E2 | E, Exclude<R | R2, Scope.Scope>>
   <A, E, R, A2, E2, R2>(
     self: Stream<A, E, R>,
     sink: Sink.Sink<A2, A, unknown, E2, R2>

package/src/internal/cause.ts

@@ -990,6 +990,9 @@ const renderErrorCause = (cause: PrettyError, prefix: string) => {
   for (let i = 1, len = lines.length; i < len; i++) {
     stack += `\n${prefix}${lines[i]}`
   }
+  if (cause.cause) {
+    stack += ` {\n${renderErrorCause(cause.cause as PrettyError, `${prefix}  `)}\n${prefix}}`
+  }
   return stack
 }
 
@@ -999,11 +1002,12 @@ class PrettyError extends globalThis.Error implements Cause.PrettyError {
     const originalErrorIsObject = typeof originalError === "object" && originalError !== null
     const prevLimit = Error.stackTraceLimit
     Error.stackTraceLimit = 1
-    super(prettyErrorMessage(originalError), {
-      cause: originalErrorIsObject && "cause" in originalError && typeof originalError.cause !== "undefined"
-        ? new PrettyError(originalError.cause)
+    super(
+      prettyErrorMessage(originalError),
+      originalErrorIsObject && "cause" in originalError && typeof originalError.cause !== "undefined"
+        ? { cause: new PrettyError(originalError.cause) }
         : undefined
-    })
+    )
     if (this.message === "") {
       this.message = "An error has occurred"
     }

package/src/internal/clock.ts

@@ -42,6 +42,8 @@ const performanceNowNanos = (function() {
   const bigint1e6 = BigInt(1_000_000)
   if (typeof performance === "undefined") {
     return () => BigInt(Date.now()) * bigint1e6
+  } else if (typeof performance.timeOrigin === "number" && performance.timeOrigin === 0) {
+    return () => BigInt(Math.round(performance.now() * 1_000_000))
   }
   const origin = (BigInt(Date.now()) * bigint1e6) - BigInt(Math.round(performance.now() * 1_000_000))
   return () => origin + BigInt(Math.round(performance.now() * 1_000_000))

package/src/internal/logger.ts

@@ -416,9 +416,16 @@ const defaultDateFormat = (date: Date): string =>
     date.getSeconds().toString().padStart(2, "0")
   }.${date.getMilliseconds().toString().padStart(3, "0")}`
 
-const processStdoutIsTTY = typeof process === "object" && "stdout" in process && process.stdout.isTTY === true
+const processStdoutIsTTY = typeof process === "object" &&
+  process !== null &&
+  typeof process.stdout === "object" &&
+  process.stdout !== null &&
+  process.stdout.isTTY === true
 const hasWindow = typeof window === "object"
-const isWorker = typeof self === "object" && self.constructor && self.constructor.name.includes("Worker")
+const isWorker = typeof self === "object" &&
+  self !== null &&
+  typeof self.constructor === "function" &&
+  self.constructor.name.includes("Worker")
 
 /** @internal */
 export const prettyLogger = (options?: {
@@ -534,7 +541,7 @@ const prettyLoggerBrowser = (options: {
         if (typeof firstMaybeString === "string") {
           firstLine += ` ${color}${firstMaybeString}`
           if (options.colors) {
-            firstParams.push("color:blue")
+            firstParams.push("color:deepskyblue")
           }
           messageIndex++
         }

package/src/internal/version.ts

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