effect 4.0.0-beta.51 → 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) => {
@@ -6812,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
@@ -6822,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
@@ -6949,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":