anyvali 0.3.1 → 0.3.4

package/src/schemas/intersection.ts

@@ -1,81 +1,81 @@
-import type { ParseContext, SchemaNode } from "../types.js";
-import { BaseSchema } from "./base.js";
-
-/** Convert a union of types to an intersection. */
-type UnionToIntersection<U> = (
-  U extends any ? (x: U) => void : never
-) extends (x: infer I) => void
-  ? I
-  : never;
-
-/** Flatten an intersection into a clean single-level type. */
-type Prettify<T> = { [K in keyof T]: T[K] } & {};
-
-export class IntersectionSchema<
-  T extends BaseSchema<any, any>[] = BaseSchema[],
-> extends BaseSchema<
-  unknown,
-  Prettify<UnionToIntersection<T[number]["_output"]>>
-> {
-  private _schemas: T;
-
-  constructor(schemas: [...T]) {
-    super();
-    this._schemas = schemas as T;
-  }
-
-  _validate(input: unknown, ctx: ParseContext): unknown {
-    let result: unknown = input;
-    let anyFailed = false;
-
-    for (const schema of this._schemas) {
-      const innerCtx: ParseContext = {
-        path: [...ctx.path],
-        issues: [],
-        // Propagate recursion depth and circular-reference tracking so the
-        // depth guard is not reset (and bypassed) at each intersection member.
-        definitions: ctx.definitions,
-        seen: ctx.seen,
-        depth: ctx.depth,
-      };
-      const validated = schema._runPipeline(input, innerCtx);
-
-      if (innerCtx.issues.length > 0) {
-        ctx.issues.push(...innerCtx.issues);
-        anyFailed = true;
-      } else {
-        // Merge object results
-        if (
-          typeof result === "object" &&
-          result !== null &&
-          typeof validated === "object" &&
-          validated !== null &&
-          !Array.isArray(result) &&
-          !Array.isArray(validated)
-        ) {
-          result = {
-            ...(result as Record<string, unknown>),
-            ...(validated as Record<string, unknown>),
-          };
-        } else {
-          result = validated;
-        }
-      }
-    }
-
-    if (anyFailed) {
-      return undefined;
-    }
-
-    return result;
-  }
-
-  _toNode(): SchemaNode {
-    const node = {
-      kind: "intersection" as const,
-      allOf: this._schemas.map((s) => s._toNode()),
-    };
-    this._addDefault(node as unknown as SchemaNode);
-    return node as unknown as SchemaNode;
-  }
-}
+import type { ParseContext, SchemaNode } from "../types.js";
+import { BaseSchema } from "./base.js";
+
+/** Convert a union of types to an intersection. */
+type UnionToIntersection<U> = (
+  U extends any ? (x: U) => void : never
+) extends (x: infer I) => void
+  ? I
+  : never;
+
+/** Flatten an intersection into a clean single-level type. */
+type Prettify<T> = { [K in keyof T]: T[K] } & {};
+
+export class IntersectionSchema<
+  T extends BaseSchema<any, any>[] = BaseSchema[],
+> extends BaseSchema<
+  unknown,
+  Prettify<UnionToIntersection<T[number]["_output"]>>
+> {
+  private _schemas: T;
+
+  constructor(schemas: [...T]) {
+    super();
+    this._schemas = schemas as T;
+  }
+
+  _validate(input: unknown, ctx: ParseContext): unknown {
+    let result: unknown = input;
+    let anyFailed = false;
+
+    for (const schema of this._schemas) {
+      const innerCtx: ParseContext = {
+        path: [...ctx.path],
+        issues: [],
+        // Propagate recursion depth and circular-reference tracking so the
+        // depth guard is not reset (and bypassed) at each intersection member.
+        definitions: ctx.definitions,
+        seen: ctx.seen,
+        depth: ctx.depth,
+      };
+      const validated = schema._runPipeline(input, innerCtx);
+
+      if (innerCtx.issues.length > 0) {
+        ctx.issues.push(...innerCtx.issues);
+        anyFailed = true;
+      } else {
+        // Merge object results
+        if (
+          typeof result === "object" &&
+          result !== null &&
+          typeof validated === "object" &&
+          validated !== null &&
+          !Array.isArray(result) &&
+          !Array.isArray(validated)
+        ) {
+          result = {
+            ...(result as Record<string, unknown>),
+            ...(validated as Record<string, unknown>),
+          };
+        } else {
+          result = validated;
+        }
+      }
+    }
+
+    if (anyFailed) {
+      return undefined;
+    }
+
+    return result;
+  }
+
+  _toNode(): SchemaNode {
+    const node = {
+      kind: "intersection" as const,
+      allOf: this._schemas.map((s) => s._toNode()),
+    };
+    this._addDefault(node as unknown as SchemaNode);
+    return node as unknown as SchemaNode;
+  }
+}

package/src/schemas/number.ts

@@ -3,6 +3,9 @@ import { BaseSchema } from "./base.js";
 import { ISSUE_CODES } from "../issue-codes.js";
 import { describeType } from "../util.js";
 
+/** Largest finite magnitude representable in IEEE 754 binary32. */
+const FLOAT32_MAX = 3.4028234663852886e38;
+
 export class NumberSchema extends BaseSchema<number, number> {
   protected _kind: SchemaKind;
   protected _min?: number;
@@ -62,6 +65,20 @@ export class NumberSchema extends BaseSchema<number, number> {
       return undefined;
     }
 
+    // float32 MUST reject values outside the binary32 representable range
+    // (spec 1.4). Without this, float32 silently accepts any float64 value,
+    // defeating the narrowing guarantee.
+    if (this._kind === "float32" && input !== 0 && Math.abs(input) > FLOAT32_MAX) {
+      ctx.issues.push({
+        code: ISSUE_CODES.TOO_LARGE,
+        message: `Value ${input} is outside the float32 range`,
+        path: [...ctx.path],
+        expected: "float32",
+        received: String(input),
+      });
+      return undefined;
+    }
+
     this._validateConstraints(input, ctx);
     return input;
   }

package/src/schemas/object.ts

@@ -1,203 +1,203 @@
-import type { ParseContext, SchemaNode, UnknownKeyMode } from "../types.js";
-import { BaseSchema, ABSENT } from "./base.js";
-import { ISSUE_CODES } from "../issue-codes.js";
-import { describeType } from "../util.js";
-import type { OptionalSchema } from "./optional.js";
-
-/** Flatten an intersection into a clean single-level type. */
-type Prettify<T> = { [K in keyof T]: T[K] } & {};
-
-/** Map a shape record to its inferred output type, separating required from optional fields. */
-export type InferShape<
-  T extends Record<string, BaseSchema<any, any>>,
-> = Prettify<
-  {
-    [K in keyof T as T[K] extends OptionalSchema<any> ? never : K]: T[K]["_output"];
-  } & {
-    [K in keyof T as T[K] extends OptionalSchema<any>
-      ? K
-      : never]?: T[K]["_output"];
-  }
->;
-
-interface PropertyDef {
-  schema: BaseSchema;
-  required: boolean;
-}
-
-export class ObjectSchema<
-  TShape extends Record<string, BaseSchema<any, any>> = Record<
-    string,
-    BaseSchema
-  >,
-> extends BaseSchema<Record<string, unknown>, InferShape<TShape>> {
-  private _properties: Map<string, PropertyDef>;
-  private _unknownKeys: UnknownKeyMode;
-  private _unknownKeysExplicit: boolean;
-
-  constructor(
-    shape: TShape,
-    options?: { unknownKeys?: UnknownKeyMode },
-  ) {
-    super();
-    this._properties = new Map();
-    this._unknownKeys = options?.unknownKeys ?? "strip";
-    this._unknownKeysExplicit = options?.unknownKeys !== undefined;
-
-    for (const [key, schema] of Object.entries(shape)) {
-      // Check if the schema is an OptionalSchema wrapper
-      const isOptional = (schema as any)._isOptionalWrapper === true;
-      this._properties.set(key, {
-        schema,
-        required: !isOptional,
-      });
-    }
-  }
-
-  unknownKeys(mode: UnknownKeyMode): ObjectSchema<TShape> {
-    const clone = this._clone();
-    clone._unknownKeys = mode;
-    clone._unknownKeysExplicit = true;
-    return clone;
-  }
-
-  private _effectiveUnknownKeys(): UnknownKeyMode {
-    return this._unknownKeysExplicit ? this._unknownKeys : "strip";
-  }
-
-  private _exportUnknownKeys(): UnknownKeyMode {
-    return this._unknownKeysExplicit ? this._unknownKeys : "strip";
-  }
-
-  _validate(input: unknown, ctx: ParseContext): unknown {
-    if (typeof input !== "object" || input === null || Array.isArray(input)) {
-      ctx.issues.push({
-        code: ISSUE_CODES.INVALID_TYPE,
-        message: `Expected object, received ${describeType(input)}`,
-        path: [...ctx.path],
-        expected: "object",
-        received: describeType(input),
-      });
-      return undefined;
-    }
-
-    // Circular reference detection
-    if (!ctx.seen) ctx.seen = new WeakSet();
-    if (ctx.seen.has(input as object)) {
-      ctx.issues.push({
-        code: ISSUE_CODES.INVALID_TYPE,
-        message: "Circular reference detected",
-        path: [...ctx.path],
-        expected: "object",
-        received: "circular",
-      });
-      return undefined;
-    }
-    ctx.seen.add(input as object);
-
-    const obj = input as Record<string, unknown>;
-    const result: Record<string, unknown> = Object.create(null);
-    const inputKeys = new Set(Object.keys(obj));
-
-    // Detect __proto__ via hasOwnProperty (Object.keys skips it)
-    if (Object.prototype.hasOwnProperty.call(obj, "__proto__")) {
-      inputKeys.add("__proto__");
-    }
-
-    // Validate declared properties
-    for (const [key, prop] of this._properties) {
-      ctx.path.push(key);
-      const hasKey = Object.prototype.hasOwnProperty.call(obj, key);
-      inputKeys.delete(key);
-
-      if (!hasKey) {
-        // Check if required
-        if (prop.required && prop.schema._defaultValue === ABSENT) {
-          const expectedKind = prop.schema._toNode().kind;
-          ctx.issues.push({
-            code: ISSUE_CODES.REQUIRED,
-            message: `Required property "${key}" is missing`,
-            path: [...ctx.path],
-            expected: expectedKind,
-            received: "undefined",
-          });
-          ctx.path.pop();
-          continue;
-        }
-      }
-
-      const rawValue = hasKey ? obj[key] : undefined;
-      const val = prop.schema._runPipeline(rawValue, ctx);
-
-      // Only include in result if value is not undefined or it was explicitly present
-      if (val !== undefined || hasKey || prop.schema._defaultValue !== ABSENT) {
-        Object.defineProperty(result, key, {
-          value: val,
-          writable: true,
-          enumerable: true,
-          configurable: true,
-        });
-      }
-
-      ctx.path.pop();
-    }
-
-    // Handle unknown keys
-    for (const key of inputKeys) {
-      switch (this._effectiveUnknownKeys()) {
-        case "reject":
-          ctx.issues.push({
-            code: ISSUE_CODES.UNKNOWN_KEY,
-            message: `Unknown key "${key}"`,
-            path: [...ctx.path, key],
-            expected: "undefined",
-            received: key,
-          });
-          break;
-        case "allow":
-          Object.defineProperty(result, key, {
-            value: obj[key],
-            writable: true,
-            enumerable: true,
-            configurable: true,
-          });
-          break;
-        case "strip":
-          // Just ignore it
-          break;
-      }
-    }
-
-    // Remove from the ancestor set now that this subtree is fully processed.
-    // The guard tracks the current ancestor chain (true cycles), not every
-    // object ever seen — otherwise a shared/repeated non-circular reference in
-    // sibling positions would be falsely rejected as circular.
-    ctx.seen.delete(input as object);
-
-    // Restore normal prototype so result behaves like a standard object
-    // while preventing __proto__ pollution via Object.create(null) above
-    Object.setPrototypeOf(result, Object.prototype);
-    return result;
-  }
-
-  _toNode(): SchemaNode {
-    const properties: Record<string, SchemaNode> = {};
-    const required: string[] = [];
-
-    for (const [key, prop] of this._properties) {
-      properties[key] = prop.schema._toNode();
-      if (prop.required) {
-        required.push(key);
-      }
-    }
-
-    const node = {
-      kind: "object" as const,
-      properties,
-      required,
-      unknownKeys: this._exportUnknownKeys(),
-    };
-    this._addDefault(node as unknown as SchemaNode);
-    return node as unknown as SchemaNode;
-  }
-}
+import type { ParseContext, SchemaNode, UnknownKeyMode } from "../types.js";
+import { BaseSchema, ABSENT } from "./base.js";
+import { ISSUE_CODES } from "../issue-codes.js";
+import { describeType } from "../util.js";
+import type { OptionalSchema } from "./optional.js";
+
+/** Flatten an intersection into a clean single-level type. */
+type Prettify<T> = { [K in keyof T]: T[K] } & {};
+
+/** Map a shape record to its inferred output type, separating required from optional fields. */
+export type InferShape<
+  T extends Record<string, BaseSchema<any, any>>,
+> = Prettify<
+  {
+    [K in keyof T as T[K] extends OptionalSchema<any> ? never : K]: T[K]["_output"];
+  } & {
+    [K in keyof T as T[K] extends OptionalSchema<any>
+      ? K
+      : never]?: T[K]["_output"];
+  }
+>;
+
+interface PropertyDef {
+  schema: BaseSchema;
+  required: boolean;
+}
+
+export class ObjectSchema<
+  TShape extends Record<string, BaseSchema<any, any>> = Record<
+    string,
+    BaseSchema
+  >,
+> extends BaseSchema<Record<string, unknown>, InferShape<TShape>> {
+  private _properties: Map<string, PropertyDef>;
+  private _unknownKeys: UnknownKeyMode;
+  private _unknownKeysExplicit: boolean;
+
+  constructor(
+    shape: TShape,
+    options?: { unknownKeys?: UnknownKeyMode },
+  ) {
+    super();
+    this._properties = new Map();
+    this._unknownKeys = options?.unknownKeys ?? "strip";
+    this._unknownKeysExplicit = options?.unknownKeys !== undefined;
+
+    for (const [key, schema] of Object.entries(shape)) {
+      // Check if the schema is an OptionalSchema wrapper
+      const isOptional = (schema as any)._isOptionalWrapper === true;
+      this._properties.set(key, {
+        schema,
+        required: !isOptional,
+      });
+    }
+  }
+
+  unknownKeys(mode: UnknownKeyMode): ObjectSchema<TShape> {
+    const clone = this._clone();
+    clone._unknownKeys = mode;
+    clone._unknownKeysExplicit = true;
+    return clone;
+  }
+
+  private _effectiveUnknownKeys(): UnknownKeyMode {
+    return this._unknownKeysExplicit ? this._unknownKeys : "strip";
+  }
+
+  private _exportUnknownKeys(): UnknownKeyMode {
+    return this._unknownKeysExplicit ? this._unknownKeys : "strip";
+  }
+
+  _validate(input: unknown, ctx: ParseContext): unknown {
+    if (typeof input !== "object" || input === null || Array.isArray(input)) {
+      ctx.issues.push({
+        code: ISSUE_CODES.INVALID_TYPE,
+        message: `Expected object, received ${describeType(input)}`,
+        path: [...ctx.path],
+        expected: "object",
+        received: describeType(input),
+      });
+      return undefined;
+    }
+
+    // Circular reference detection
+    if (!ctx.seen) ctx.seen = new WeakSet();
+    if (ctx.seen.has(input as object)) {
+      ctx.issues.push({
+        code: ISSUE_CODES.INVALID_TYPE,
+        message: "Circular reference detected",
+        path: [...ctx.path],
+        expected: "object",
+        received: "circular",
+      });
+      return undefined;
+    }
+    ctx.seen.add(input as object);
+
+    const obj = input as Record<string, unknown>;
+    const result: Record<string, unknown> = Object.create(null);
+    const inputKeys = new Set(Object.keys(obj));
+
+    // Detect __proto__ via hasOwnProperty (Object.keys skips it)
+    if (Object.prototype.hasOwnProperty.call(obj, "__proto__")) {
+      inputKeys.add("__proto__");
+    }
+
+    // Validate declared properties
+    for (const [key, prop] of this._properties) {
+      ctx.path.push(key);
+      const hasKey = Object.prototype.hasOwnProperty.call(obj, key);
+      inputKeys.delete(key);
+
+      if (!hasKey) {
+        // Check if required
+        if (prop.required && prop.schema._defaultValue === ABSENT) {
+          const expectedKind = prop.schema._toNode().kind;
+          ctx.issues.push({
+            code: ISSUE_CODES.REQUIRED,
+            message: `Required property "${key}" is missing`,
+            path: [...ctx.path],
+            expected: expectedKind,
+            received: "undefined",
+          });
+          ctx.path.pop();
+          continue;
+        }
+      }
+
+      const rawValue = hasKey ? obj[key] : undefined;
+      const val = prop.schema._runPipeline(rawValue, ctx);
+
+      // Only include in result if value is not undefined or it was explicitly present
+      if (val !== undefined || hasKey || prop.schema._defaultValue !== ABSENT) {
+        Object.defineProperty(result, key, {
+          value: val,
+          writable: true,
+          enumerable: true,
+          configurable: true,
+        });
+      }
+
+      ctx.path.pop();
+    }
+
+    // Handle unknown keys
+    for (const key of inputKeys) {
+      switch (this._effectiveUnknownKeys()) {
+        case "reject":
+          ctx.issues.push({
+            code: ISSUE_CODES.UNKNOWN_KEY,
+            message: `Unknown key "${key}"`,
+            path: [...ctx.path, key],
+            expected: "undefined",
+            received: key,
+          });
+          break;
+        case "allow":
+          Object.defineProperty(result, key, {
+            value: obj[key],
+            writable: true,
+            enumerable: true,
+            configurable: true,
+          });
+          break;
+        case "strip":
+          // Just ignore it
+          break;
+      }
+    }
+
+    // Remove from the ancestor set now that this subtree is fully processed.
+    // The guard tracks the current ancestor chain (true cycles), not every
+    // object ever seen — otherwise a shared/repeated non-circular reference in
+    // sibling positions would be falsely rejected as circular.
+    ctx.seen.delete(input as object);
+
+    // Restore normal prototype so result behaves like a standard object
+    // while preventing __proto__ pollution via Object.create(null) above
+    Object.setPrototypeOf(result, Object.prototype);
+    return result;
+  }
+
+  _toNode(): SchemaNode {
+    const properties: Record<string, SchemaNode> = {};
+    const required: string[] = [];
+
+    for (const [key, prop] of this._properties) {
+      properties[key] = prop.schema._toNode();
+      if (prop.required) {
+        required.push(key);
+      }
+    }
+
+    const node = {
+      kind: "object" as const,
+      properties,
+      required,
+      unknownKeys: this._exportUnknownKeys(),
+    };
+    this._addDefault(node as unknown as SchemaNode);
+    return node as unknown as SchemaNode;
+  }
+}

package/src/schemas/optional.ts

@@ -25,9 +25,10 @@ export class OptionalSchema<
   _runPipeline(input: unknown, ctx: ParseContext): unknown {
     const isAbsent = input === undefined || input === ABSENT;
 
-    // If absent and we have a default from inner, apply it
-    if (isAbsent && this._inner._defaultValue !== ABSENT) {
-      return this._inner._runPipeline(input, ctx);
+    // If absent and we have a default on this wrapper, use the normal
+    // BaseSchema default path so validation and cloning still run.
+    if (isAbsent && this._defaultValue !== ABSENT) {
+      return super._runPipeline(input, ctx);
     }
 
     if (isAbsent) {