effect 3.13.9 → 3.13.11

package/src/internal/core.ts

@@ -2349,9 +2349,10 @@ export const TimeoutExceptionTypeId: Cause.TimeoutExceptionTypeId = Symbol.for(
 export const TimeoutException = makeException<Cause.TimeoutException>({
   [TimeoutExceptionTypeId]: TimeoutExceptionTypeId
 }, "TimeoutException")
+
 /** @internal */
 export const timeoutExceptionFromDuration = (duration: Duration.DurationInput): Cause.TimeoutException =>
-  new TimeoutException(`Operation timed out before the specified duration of '${Duration.format(duration)}' elapsed`)
+  new TimeoutException(`Operation timed out after '${Duration.format(duration)}'`)
 
 /** @internal */
 export const isTimeoutException = (u: unknown): u is Cause.TimeoutException => hasProperty(u, TimeoutExceptionTypeId)

package/src/internal/schema/util.ts

@@ -1,4 +1,4 @@
-import * as array_ from "../../Array.js"
+import type { NonEmptyReadonlyArray } from "../../Array.js"
 import type * as ParseResult from "../../ParseResult.js"
 import * as Predicate from "../../Predicate.js"
 import type * as AST from "../../SchemaAST.js"
@@ -53,41 +53,51 @@ export const formatDate = (date: Date): string => {
 }
 
 /** @internal */
-export const formatUnknown = (u: unknown): string => {
+export const formatUnknown = (u: unknown, checkCircular: boolean = true): string => {
+  if (Array.isArray(u)) {
+    return `[${u.map((i) => formatUnknown(i, checkCircular)).join(",")}]`
+  }
+  if (Predicate.isDate(u)) {
+    return formatDate(u)
+  }
+  if (
+    Predicate.hasProperty(u, "toString")
+    && Predicate.isFunction(u["toString"])
+    && u["toString"] !== Object.prototype.toString
+  ) {
+    return u["toString"]()
+  }
   if (Predicate.isString(u)) {
     return JSON.stringify(u)
-  } else if (
+  }
+  if (
     Predicate.isNumber(u)
     || u == null
     || Predicate.isBoolean(u)
     || Predicate.isSymbol(u)
   ) {
     return String(u)
-  } else if (Predicate.isDate(u)) {
-    return formatDate(u)
-  } else if (Predicate.isBigInt(u)) {
+  }
+  if (Predicate.isBigInt(u)) {
     return String(u) + "n"
-  } else if (
-    !array_.isArray(u)
-    && Predicate.hasProperty(u, "toString")
-    && Predicate.isFunction(u["toString"])
-    && u["toString"] !== Object.prototype.toString
-  ) {
-    return u["toString"]()
+  }
+  if (Predicate.isIterable(u)) {
+    return `${u.constructor.name}(${formatUnknown(Array.from(u), checkCircular)})`
   }
   try {
-    JSON.stringify(u)
-    if (array_.isArray(u)) {
-      return `[${u.map(formatUnknown).join(",")}]`
-    } else {
-      return `{${
-        ownKeys(u).map((k) =>
-          `${Predicate.isString(k) ? JSON.stringify(k) : String(k)}:${formatUnknown((u as any)[k])}`
-        ).join(",")
-      }}`
+    if (checkCircular) {
+      JSON.stringify(u) // check for circular references
     }
+    const pojo = `{${
+      ownKeys(u).map((k) =>
+        `${Predicate.isString(k) ? JSON.stringify(k) : String(k)}:${formatUnknown((u as any)[k], false)}`
+      )
+        .join(",")
+    }}`
+    const name = u.constructor.name
+    return u.constructor !== Object.prototype.constructor ? `${name}(${pojo})` : pojo
   } catch (e) {
-    return String(u)
+    return "<circular structure>"
   }
 }
 
@@ -99,8 +109,7 @@ export const formatPropertyKey = (name: PropertyKey): string =>
 export type SingleOrArray<A> = A | ReadonlyArray<A>
 
 /** @internal */
-export const isNonEmpty = <A>(x: ParseResult.SingleOrNonEmpty<A>): x is array_.NonEmptyReadonlyArray<A> =>
-  Array.isArray(x)
+export const isNonEmpty = <A>(x: ParseResult.SingleOrNonEmpty<A>): x is NonEmptyReadonlyArray<A> => Array.isArray(x)
 
 /** @internal */
 export const isSingle = <A>(x: A | ReadonlyArray<A>): x is A => !Array.isArray(x)

package/src/internal/version.ts

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