effect 4.0.0-beta.94 → 4.0.0-beta.98

package/dist/SchemaRepresentation.js

@@ -17,6 +17,7 @@ import { format, formatPropertyKey } from "./Formatter.js";
 import { collectBrands } from "./internal/schema/annotations.js";
 import * as InternalRepresentation from "./internal/schema/representation.js";
 import { unescapeToken } from "./JsonPointer.js";
+import { remainder } from "./Number.js";
 import * as Option from "./Option.js";
 import * as Predicate from "./Predicate.js";
 import * as Rec from "./Record.js";
@@ -2041,46 +2042,30 @@ export function fromJsonSchemaDocument(document, options) {
  * @since 4.0.0
  */
 export function fromJsonSchemaMultiDocument(document, options) {
-  let visited;
+  let definitionIdentifier;
   const references = {};
-  const slots = new Map();
-  function getSlot(identifier) {
-    const existing = slots.get(identifier);
-    if (existing) return existing;
-    // Create the slot *before* resolving, so self-references can see it.
-    const slot = {
-      state: 0,
-      value: undefined
-    };
-    slots.set(identifier, slot);
-    return slot;
-  }
+  const resolvedReferences = new Map();
   function resolveReference($ref) {
     const definition = document.definitions[$ref];
     if (definition === undefined) {
       throw new Error(`Reference ${$ref} not found`);
     }
-    const slot = getSlot($ref);
-    if (slot.state === 2) {
-      // Already built: return the built schema directly
-      return slot.value;
-    }
-    if (slot.state === 1) {
-      // Circular: we're currently building this identifier.
+    const resolved = resolvedReferences.get($ref);
+    if (resolved === null) {
       throw new Error(`Circular reference detected: ${$ref}`);
     }
-    // First time: build it.
-    slot.state = 1;
+    if (resolved !== undefined) return resolved;
+    resolvedReferences.set($ref, null);
     const value = recur(definition);
-    slot.value = value._tag === "Reference" ? resolveReference(value.$ref) : value;
-    slot.state = 2;
-    return slot.value;
+    const out = value._tag === "Reference" ? resolveReference(value.$ref) : value;
+    resolvedReferences.set($ref, out);
+    return out;
   }
-  Object.entries(document.definitions).forEach(([identifier, definition]) => {
-    visited = new Set([identifier]);
+  for (const [identifier, definition] of Object.entries(document.definitions)) {
+    definitionIdentifier = identifier;
     references[identifier] = unknownToJson(recur(definition));
-  });
-  visited = new Set();
+  }
+  definitionIdentifier = undefined;
   const representations = Arr.map(document.schemas, schema => unknownToJson(recur(schema)));
   return {
     representations,
@@ -2141,7 +2126,7 @@ export function fromJsonSchemaMultiDocument(document, options) {
           _tag: "Reference",
           $ref: unescapeToken($ref)
         };
-        if (visited.has($ref)) {
+        if (definitionIdentifier === $ref) {
           return {
             _tag: "Suspend",
             thunk: reference,
@@ -2293,129 +2278,104 @@ export function fromJsonSchemaMultiDocument(document, options) {
       case "Never":
         return a;
       case "Unknown":
-        switch (b._tag) {
-          case "Reference":
-            return combine(a, resolveReference(b.$ref));
-          default:
-            return {
-              ...b,
-              ...combineAnnotations(a.annotations, b.annotations)
-            };
+        {
+          const resolved = b._tag === "Reference" ? resolveReference(b.$ref) : b;
+          return {
+            ...resolved,
+            ...combineAnnotations(a.annotations, resolved.annotations)
+          };
         }
       case "Null":
-        switch (b._tag) {
-          case "Unknown":
-          case "Null":
-            return {
-              ...a,
-              ...combineAnnotations(a.annotations, b.annotations)
-            };
-          case "Union":
-            return combine(b, a);
-          case "Reference":
-            return combine(a, resolveReference(b.$ref));
-          default:
-            return never;
-        }
       case "String":
-        switch (b._tag) {
-          case "Unknown":
-            return {
-              ...a,
-              ...combineAnnotations(a.annotations, b.annotations)
-            };
-          case "String":
-            {
-              const checks = combineChecks(a.checks, b.checks, b.annotations);
-              return {
-                _tag: "String",
-                checks: checks ?? a.checks,
-                ...combineAnnotations(a.annotations, checks ? undefined : b.annotations)
-              };
-            }
-          case "Literal":
-            return typeof b.literal === "string" ? {
+      case "Number":
+      case "Boolean":
+      case "Literal":
+      case "Arrays":
+      case "Objects":
+      case "Union":
+        break;
+    }
+    if (b._tag === "Reference") {
+      return combine(a, resolveReference(b.$ref));
+    }
+    if (b._tag === "Unknown") {
+      return {
+        ...a,
+        ...combineAnnotations(a.annotations, b.annotations)
+      };
+    }
+    if (a._tag === "Union") {
+      const types = a.types.map(s => combine(s, b)).filter(s => s !== never);
+      if (types.length === 0) return never;
+      return {
+        _tag: "Union",
+        types,
+        mode: a.mode,
+        ...makeAnnotations(a.annotations)
+      };
+    }
+    if (b._tag === "Union") {
+      return combine(b, a);
+    }
+    switch (a._tag) {
+      case "Null":
+        return b._tag === "Null" ? {
+          ...a,
+          ...combineAnnotations(a.annotations, b.annotations)
+        } : never;
+      case "String":
+        {
+          if (b._tag === "Literal") {
+            return satisfiesLiteral(a, b) ? {
               ...b,
               ...combineAnnotations(a.annotations, b.annotations)
             } : never;
-          case "Union":
-            return combine(b, a);
-          case "Reference":
-            return combine(a, resolveReference(b.$ref));
-          default:
-            return never;
+          }
+          if (b._tag !== "String") return never;
+          const checks = combineChecks(a.checks, b.checks, b.annotations);
+          return {
+            _tag: "String",
+            checks: checks ?? a.checks,
+            ...combineAnnotations(a.annotations, checks ? undefined : b.annotations)
+          };
         }
       case "Number":
-        switch (b._tag) {
-          case "Unknown":
-            return {
-              ...a,
-              ...combineAnnotations(a.annotations, b.annotations)
-            };
-          case "Number":
-            {
-              const checks = combineNumberChecks(a.checks, b.checks, b.annotations);
-              return {
-                _tag: "Number",
-                checks: checks ?? a.checks,
-                ...combineAnnotations(a.annotations, checks ? undefined : b.annotations)
-              };
-            }
-          case "Literal":
-            return typeof b.literal === "number" ? {
+        {
+          if (b._tag === "Literal") {
+            return satisfiesLiteral(a, b) ? {
               ...b,
               ...combineAnnotations(a.annotations, b.annotations)
             } : never;
-          case "Union":
-            return combine(b, a);
-          case "Reference":
-            return combine(a, resolveReference(b.$ref));
-          default:
-            return never;
+          }
+          if (b._tag !== "Number") return never;
+          const checks = combineNumberChecks(a.checks, b.checks, b.annotations);
+          return {
+            _tag: "Number",
+            checks: checks ?? a.checks,
+            ...combineAnnotations(a.annotations, checks ? undefined : b.annotations)
+          };
         }
       case "Boolean":
-        switch (b._tag) {
-          case "Unknown":
-            return {
-              ...a,
-              ...combineAnnotations(a.annotations, b.annotations)
-            };
-          case "Boolean":
-            return {
-              _tag: "Boolean",
-              ...combineAnnotations(a.annotations, b.annotations)
-            };
-          case "Literal":
-            return typeof b.literal === "boolean" ? {
-              ...b,
-              ...combineAnnotations(a.annotations, b.annotations)
-            } : never;
-          case "Union":
-            return combine(b, a);
-          case "Reference":
-            return combine(a, resolveReference(b.$ref));
-          default:
-            return never;
+        if (b._tag === "Boolean") {
+          return {
+            _tag: "Boolean",
+            ...combineAnnotations(a.annotations, b.annotations)
+          };
         }
+        return b._tag === "Literal" && typeof b.literal === "boolean" ? {
+          ...b,
+          ...combineAnnotations(a.annotations, b.annotations)
+        } : never;
       case "Literal":
         switch (b._tag) {
-          case "Unknown":
-            return {
-              ...a,
-              ...combineAnnotations(a.annotations, b.annotations)
-            };
           case "Literal":
             return a.literal === b.literal ? {
               ...a,
               ...combineAnnotations(a.annotations, b.annotations)
             } : never;
           case "String":
-            return typeof a.literal === "string" ? {
-              ...a,
-              ...combineAnnotations(a.annotations, b.annotations)
-            } : never;
           case "Number":
-            return typeof a.literal === "number" ? {
+            return satisfiesLiteral(b, a) ? {
               ...a,
               ...combineAnnotations(a.annotations, b.annotations)
             } : never;
@@ -2424,86 +2384,76 @@ export function fromJsonSchemaMultiDocument(document, options) {
               ...a,
               ...combineAnnotations(a.annotations, b.annotations)
             } : never;
-          case "Union":
-            return combine(b, a);
-          case "Reference":
-            return combine(a, resolveReference(b.$ref));
           default:
             return never;
         }
       case "Arrays":
-        switch (b._tag) {
-          case "Unknown":
-            return {
-              ...a,
-              ...combineAnnotations(a.annotations, b.annotations)
-            };
-          case "Arrays":
-            {
-              const checks = combineArraysChecks(a.checks, b.checks, b.annotations);
-              return {
-                _tag: "Arrays",
-                elements: combineElements(a.elements, b.elements),
-                rest: combineRest(a.rest, b.rest),
-                checks: checks ?? a.checks,
-                ...combineAnnotations(a.annotations, checks ? undefined : b.annotations)
-              };
-            }
-          case "Union":
-            return combine(b, a);
-          case "Reference":
-            return combine(a, resolveReference(b.$ref));
-          default:
-            return never;
+        {
+          if (b._tag !== "Arrays") return never;
+          const arrays = combineArrays(a, b);
+          if (arrays === undefined) return never;
+          const checks = combineArraysChecks(a.checks, b.checks, b.annotations);
+          return {
+            _tag: "Arrays",
+            elements: arrays.elements,
+            rest: arrays.rest,
+            checks: checks ?? a.checks,
+            ...combineAnnotations(a.annotations, checks ? undefined : b.annotations)
+          };
         }
       case "Objects":
-        switch (b._tag) {
-          case "Unknown":
-            return {
-              ...a,
-              ...combineAnnotations(a.annotations, b.annotations)
-            };
-          case "Objects":
-            {
-              const checks = combineChecks(a.checks, b.checks, b.annotations);
-              return {
-                _tag: "Objects",
-                propertySignatures: combinePropertySignatures(a.propertySignatures, b.propertySignatures),
-                indexSignatures: combineIndexSignatures(a.indexSignatures, b.indexSignatures),
-                checks: checks ?? a.checks,
-                ...combineAnnotations(a.annotations, checks ? undefined : b.annotations)
-              };
-            }
-          case "Union":
-            return combine(b, a);
-          case "Reference":
-            return combine(a, resolveReference(b.$ref));
-          default:
-            return never;
-        }
-      case "Union":
         {
-          switch (b._tag) {
-            case "Unknown":
-              return {
-                ...a,
-                ...combineAnnotations(a.annotations, b.annotations)
-              };
-            default:
-              {
-                const types = a.types.map(s => combine(s, b)).filter(s => s !== never);
-                if (types.length === 0) return never;
-                return {
-                  _tag: "Union",
-                  types,
-                  mode: a.mode,
-                  ...makeAnnotations(a.annotations)
-                };
-              }
-          }
+          if (b._tag !== "Objects") return never;
+          const checks = combineChecks(a.checks, b.checks, b.annotations);
+          return {
+            _tag: "Objects",
+            propertySignatures: combinePropertySignatures(a.propertySignatures, b.propertySignatures),
+            indexSignatures: combineIndexSignatures(a.indexSignatures, b.indexSignatures),
+            checks: checks ?? a.checks,
+            ...combineAnnotations(a.annotations, checks ? undefined : b.annotations)
+          };
         }
+      default:
+        return never;
     }
   }
+  function satisfiesPrimitiveCheck(check, value) {
+    if (check._tag === "FilterGroup") {
+      return check.checks.every(check => satisfiesPrimitiveCheck(check, value));
+    }
+    const meta = check.meta;
+    switch (meta._tag) {
+      case "isMinLength":
+        return typeof value === "string" && value.length >= meta.minLength;
+      case "isMaxLength":
+        return typeof value === "string" && value.length <= meta.maxLength;
+      case "isPattern":
+        return typeof value === "string" && meta.regExp.test(value);
+      case "isFinite":
+        return typeof value === "number" && globalThis.Number.isFinite(value);
+      case "isInt":
+        return typeof value === "number" && globalThis.Number.isSafeInteger(value);
+      case "isMultipleOf":
+        return typeof value === "number" && remainder(value, meta.divisor) === 0;
+      case "isGreaterThan":
+        return typeof value === "number" && value > meta.exclusiveMinimum;
+      case "isGreaterThanOrEqualTo":
+        return typeof value === "number" && value >= meta.minimum;
+      case "isLessThan":
+        return typeof value === "number" && value < meta.exclusiveMaximum;
+      case "isLessThanOrEqualTo":
+        return typeof value === "number" && value <= meta.maximum;
+      default:
+        return false;
+    }
+  }
+  function satisfiesLiteral(type, literal) {
+    const value = literal.literal;
+    if (type._tag === "String" ? typeof value !== "string" : typeof value !== "number") {
+      return false;
+    }
+    return type.checks.every(check => satisfiesPrimitiveCheck(check, value));
+  }
   function collectProperties(js) {
     const properties = Predicate.isObject(js.properties) ? js.properties : {};
     const required = Array.isArray(js.required) ? js.required : [];
@@ -2544,34 +2494,46 @@ export function fromJsonSchemaMultiDocument(document, options) {
     }
     return out;
   }
-  function combineElements(a, b) {
-    const len = Math.max(a.length, b.length);
-    let out = [];
+  function combineArrays(a, b) {
+    const elements = [];
+    const len = Math.max(a.elements.length, b.elements.length);
     for (let i = 0; i < len; i++) {
-      out.push({
-        isOptional: a[i].isOptional && b[i].isOptional,
-        type: combine(a[i].type, b[i].type)
+      const ae = a.elements[i];
+      const be = b.elements[i];
+      const isOptional = ae?.isOptional !== false && be?.isOptional !== false;
+      const at = ae?.type ?? a.rest[0];
+      const bt = be?.type ?? b.rest[0];
+      if (at === undefined || bt === undefined) {
+        return isOptional ? {
+          elements,
+          rest: []
+        } : undefined;
+      }
+      const type = combine(at, bt);
+      if (type === never) {
+        return isOptional ? {
+          elements,
+          rest: []
+        } : undefined;
+      }
+      elements.push({
+        isOptional,
+        type
       });
     }
-    if (a.length > len) {
-      out = [...out, ...a.slice(len)];
-    } else if (b.length > len) {
-      out = [...out, ...b.slice(len)];
-    }
-    return out;
-  }
-  function combineRest(a, b) {
-    const len = Math.max(a.length, b.length);
-    let out = [];
-    for (let i = 0; i < len; i++) {
-      out.push(combine(a[i], b[i]));
-    }
-    if (a.length > len) {
-      out = [...out, ...a.slice(len)];
-    } else if (b.length > len) {
-      out = [...out, ...b.slice(len)];
+    const ar = a.rest[0];
+    const br = b.rest[0];
+    if (ar === undefined || br === undefined) {
+      return {
+        elements,
+        rest: []
+      };
     }
-    return out;
+    const rest = combine(ar, br);
+    return {
+      elements,
+      rest: rest === never ? [] : [rest]
+    };
   }
   function combinePropertySignatures(a, b) {
     const propertySignatures = [];