effect 4.0.0-beta.50 → 4.0.0-beta.52

package/dist/Schema.js

@@ -96,7 +96,7 @@ import * as Equal from "./Equal.js";
 import * as Equivalence from "./Equivalence.js";
 import * as Exit_ from "./Exit.js";
 import { format, formatPropertyKey } from "./Formatter.js";
-import { identity } from "./Function.js";
+import { identity, memoize } from "./Function.js";
 import * as HashMap_ from "./HashMap.js";
 import * as HashSet_ from "./HashSet.js";
 import * as core from "./internal/core.js";
@@ -106,7 +106,6 @@ import * as InternalEquivalence from "./internal/schema/equivalence.js";
 import * as InternalStandard from "./internal/schema/representation.js";
 import * as InternalSchema from "./internal/schema/schema.js";
 import { SchemaError } from "./internal/schema/schema.js";
-import * as InternalToCodec from "./internal/schema/to-codec.js";
 import * as JsonPatch from "./JsonPatch.js";
 import * as JsonSchema from "./JsonSchema.js";
 import { remainder } from "./Number.js";
@@ -2441,7 +2440,6 @@ export function instanceOf(constructor, annotations) {
  * Used when building low-level AST transformations that bridge two schema types.
  *
  * @since 4.0.0
- * @experimental
  */
 export function link() {
   return (encodeTo, transformation) => {
@@ -2454,18 +2452,47 @@ export function link() {
 /**
  * Creates a custom filter check from a predicate function. The predicate
  * receives the input value, the schema's AST, and parse options, and returns
- * `true`/`undefined` on success or a failure description on error.
+ * a value of type {@link FilterOutput}.
+ *
+ * **Example** (Failure at a nested path)
  *
- * **Example** (Custom filter check)
  * ```ts
  * import { Schema } from "effect"
  *
- * // Check that a number is even
- * const isEven = Schema.makeFilter(
- *   (n: number) => n % 2 === 0 || "expected an even number"
+ * const schema = Schema.Struct({ password: Schema.String, confirmPassword: Schema.String }).check(
+ *   Schema.makeFilter((o) =>
+ *     o.password === o.confirmPassword
+ *       ? undefined
+ *       : { path: ["password"], issue: "password and confirmPassword must match" }
+ *   )
  * )
  *
- * const EvenNumber = Schema.Number.check(isEven)
+ * console.log(String(Schema.decodeUnknownExit(schema)({ password: "123456", confirmPassword: "1234567" })))
+ * // Failure(Cause([Fail(SchemaError: password and confirmPassword must match
+ * //   at ["password"])]))
+ * ```
+ *
+ * **Example** (Reporting multiple failures at once)
+ *
+ * ```ts
+ * import { Schema } from "effect"
+ *
+ * const schema = Schema.Struct({ a: Schema.Finite, b: Schema.Finite, c: Schema.Finite }).check(
+ *   Schema.makeFilter((o) => {
+ *     const issues: Array<Schema.FilterIssue> = []
+ *     if (o.a > 0) {
+ *       if (o.b <= 0) issues.push({ path: ["b"], issue: "b must be greater than 0" })
+ *       if (o.c <= 0) issues.push({ path: ["c"], issue: "c must be greater than 0" })
+ *     }
+ *     return issues
+ *   })
+ * )
+ *
+ * console.log(String(Schema.decodeUnknownExit(schema)({ a: 1, b: 0, c: 0 })))
+ * // Failure(Cause([Fail(SchemaError: b must be greater than 0
+ * //   at ["b"]
+ * // c must be greater than 0
+ * //   at ["c"])]))
  * ```
  *
  * @category Checks Constructors
@@ -5287,6 +5314,7 @@ export const Duration = /*#__PURE__*/declare(Duration_.isDuration, {
   toFormatter: () => globalThis.String,
   toEquivalence: () => Duration_.Equivalence
 });
+const bigint0 = /*#__PURE__*/globalThis.BigInt(0);
 /**
  * A transformation schema that decodes a non-negative `bigint` into a
  * `Duration`, treating the `bigint` value as the duration in nanoseconds.
@@ -5300,7 +5328,7 @@ export const Duration = /*#__PURE__*/declare(Duration_.isDuration, {
  * @category Duration
  * @since 4.0.0
  */
-export const DurationFromNanos = /*#__PURE__*/BigInt.check(isGreaterThanOrEqualToBigInt(0n)).pipe(/*#__PURE__*/decodeTo(Duration, Transformation.durationFromNanos));
+export const DurationFromNanos = /*#__PURE__*/BigInt.check(isGreaterThanOrEqualToBigInt(bigint0)).pipe(/*#__PURE__*/decodeTo(Duration, Transformation.durationFromNanos));
 /**
  * A transformation schema that decodes a non-negative (possibly infinite)
  * integer into a `Duration`, treating the integer value as the duration in
@@ -6782,7 +6810,60 @@ export function toJsonSchemaDocument(schema, options) {
  * @since 4.0.0
  */
 export function toCodecJson(schema) {
-  return make(InternalToCodec.toCodecJson(schema.ast));
+  return make(toCodecJsonTop(schema.ast));
+}
+const toCodecJsonTop = /*#__PURE__*/AST.toCodec(ast => {
+  const out = toCodecJsonBase(ast, toCodecJsonTop);
+  return out !== ast && AST.isOptional(ast) ? AST.optionalKeyLastLink(out) : out;
+});
+function toCodecJsonBase(ast, recur) {
+  switch (ast._tag) {
+    case "Declaration":
+      {
+        const getLink = ast.annotations?.toCodecJson ?? ast.annotations?.toCodec;
+        if (Predicate.isFunction(getLink)) {
+          const tps = AST.isDeclaration(ast) ? ast.typeParameters.map(tp => InternalSchema.make(AST.toEncoded(tp))) : [];
+          const link = getLink(tps);
+          const to = recur(link.to);
+          return AST.replaceEncoding(ast, to === link.to ? [link] : [new AST.Link(to, link.transformation)]);
+        }
+        return AST.replaceEncoding(ast, [AST.unknownToNull]);
+      }
+    case "Unknown":
+    case "ObjectKeyword":
+      return AST.replaceEncoding(ast, [AST.unknownToJson]);
+    case "Undefined":
+    case "Void":
+    case "Literal":
+    case "Number":
+      return ast.toCodecJson();
+    case "UniqueSymbol":
+    case "Symbol":
+    case "BigInt":
+      return ast.toCodecStringTree();
+    case "Objects":
+      {
+        if (ast.propertySignatures.some(ps => typeof ps.name !== "string")) {
+          throw new globalThis.Error("Objects property names must be strings", {
+            cause: ast
+          });
+        }
+        return ast.recur(recur);
+      }
+    case "Union":
+      {
+        const sortedTypes = InternalSchema.jsonReorder(ast.types);
+        if (sortedTypes !== ast.types) {
+          return new AST.Union(sortedTypes, ast.mode, ast.annotations, ast.checks, ast.encoding, ast.context).recur(recur);
+        }
+        return ast.recur(recur);
+      }
+    case "Arrays":
+    case "Suspend":
+      return ast.recur(recur);
+  }
+  // `Schema.Any` is used as an escape hatch
+  return ast;
 }
 /**
  * Derives an isomorphism codec from a schema. The encoded form is the
@@ -6792,14 +6873,34 @@ export function toCodecJson(schema) {
  * @since 4.0.0
  */
 export function toCodecIso(schema) {
-  return make(InternalToCodec.toCodecIso(AST.toType(schema.ast)));
+  return make(toCodecIsoTop(AST.toType(schema.ast)));
 }
-export function toCodecStringTree(schema, options) {
-  if (options?.keepDeclarations === true) {
-    return make(toCodecEnsureArray(serializerStringTreeKeepDeclarations(schema.ast)));
-  } else {
-    return make(toCodecEnsureArray(serializerStringTree(schema.ast)));
+const toCodecIsoTop = /*#__PURE__*/memoize(ast => {
+  const out = toCodecIsoBase(ast, toCodecIsoTop);
+  return out !== ast && AST.isOptional(ast) ? AST.optionalKeyLastLink(out) : out;
+});
+function toCodecIsoBase(ast, recur) {
+  switch (ast._tag) {
+    case "Declaration":
+      {
+        const getLink = ast.annotations?.toCodecIso ?? ast.annotations?.toCodec;
+        if (Predicate.isFunction(getLink)) {
+          const link = getLink(ast.typeParameters.map(tp => InternalSchema.make(tp)));
+          const to = recur(link.to);
+          return AST.replaceEncoding(ast, to === link.to ? [link] : [new AST.Link(to, link.transformation)]);
+        }
+        return ast;
+      }
+    case "Arrays":
+    case "Objects":
+    case "Union":
+    case "Suspend":
+      return ast.recur(recur);
   }
+  return ast;
+}
+export function toCodecStringTree(schema, options) {
+  return make(toCodecEnsureArray(options?.keepDeclarations === true ? serializerStringTreeKeepDeclarations(schema.ast) : serializerStringTree(schema.ast)));
 }
 /**
  * Derives an XML encoder from a codec. Encodes a value to an XML string by
@@ -6919,7 +7020,7 @@ function getStringTreePriority(ast) {
       return 1;
   }
 }
-const treeReorder = /*#__PURE__*/InternalToCodec.makeReorder(getStringTreePriority);
+const treeReorder = /*#__PURE__*/InternalSchema.makeReorder(getStringTreePriority);
 function serializerTree(ast, recur, onMissingAnnotation) {
   switch (ast._tag) {
     case "Declaration":