anyvali 0.3.1

package/src/util.ts

@@ -0,0 +1,9 @@
+/**
+ * Describe the type of a value for error messages, matching the corpus expectations.
+ * null -> "null", array -> "array", otherwise typeof.
+ */
+export function describeType(value: unknown): string {
+  if (value === null) return "null";
+  if (Array.isArray(value)) return "array";
+  return typeof value;
+}

package/tests/conformance/runner.test.ts

@@ -0,0 +1,28 @@
+import { describe, it, expect } from "vitest";
+import * as path from "node:path";
+import { loadCorpus, runTestCase } from "./runner.js";
+
+const corpusDir = path.resolve(__dirname, "../../../../spec/corpus");
+
+const suites = loadCorpus(corpusDir);
+
+if (suites.length === 0) {
+  describe("Conformance corpus", () => {
+    it("no corpus files found (skipping)", () => {
+      expect(true).toBe(true);
+    });
+  });
+} else {
+  for (const suite of suites) {
+    describe(`Conformance: ${suite.suite}`, () => {
+      for (const tc of suite.cases) {
+        it(tc.description, () => {
+          const result = runTestCase(tc);
+          if (!result.passed) {
+            throw new Error(result.error);
+          }
+        });
+      }
+    });
+  }
+}

package/tests/conformance/runner.ts

@@ -0,0 +1,137 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { importSchema } from "../../src/interchange/importer.js";
+import type { AnyValiDocument } from "../../src/types.js";
+
+export interface CorpusFile {
+  suite: string;
+  cases: CorpusTestCase[];
+}
+
+export interface CorpusTestCase {
+  description: string;
+  schema: AnyValiDocument;
+  input: unknown;
+  valid: boolean;
+  output: unknown;
+  issues: Array<{
+    code: string;
+    path: (string | number)[];
+    expected?: string;
+    received?: string;
+  }>;
+}
+
+export interface CorpusTestResult {
+  description: string;
+  passed: boolean;
+  error?: string;
+}
+
+/**
+ * Load all corpus test files from the given directory (recursively).
+ * Returns an array of { suite, cases } objects.
+ */
+export function loadCorpus(corpusDir: string): CorpusFile[] {
+  const suites: CorpusFile[] = [];
+
+  if (!fs.existsSync(corpusDir)) {
+    return suites;
+  }
+
+  function walk(dir: string): void {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        walk(fullPath);
+      } else if (entry.name.endsWith(".json")) {
+        const content = fs.readFileSync(fullPath, "utf-8");
+        const parsed = JSON.parse(content) as CorpusFile;
+        suites.push(parsed);
+      }
+    }
+  }
+
+  walk(corpusDir);
+  return suites;
+}
+
+/**
+ * Run a single corpus test case.
+ */
+export function runTestCase(tc: CorpusTestCase): CorpusTestResult {
+  try {
+    const schema = importSchema(tc.schema);
+    const result = schema.safeParse(tc.input);
+
+    if (tc.valid) {
+      // Expect success
+      if (!result.success) {
+        return {
+          description: tc.description,
+          passed: false,
+          error: `Expected success but got failure: ${JSON.stringify(result.issues)}`,
+        };
+      }
+      // Compare output
+      const expectedJson = JSON.stringify(tc.output);
+      const actualJson = JSON.stringify(result.data);
+      if (expectedJson !== actualJson) {
+        return {
+          description: tc.description,
+          passed: false,
+          error: `Output mismatch: expected ${expectedJson}, got ${actualJson}`,
+        };
+      }
+      return { description: tc.description, passed: true };
+    } else {
+      // Expect failure
+      if (result.success) {
+        return {
+          description: tc.description,
+          passed: false,
+          error: `Expected failure but got success: ${JSON.stringify(result.data)}`,
+        };
+      }
+      // Check expected issue codes and paths
+      for (const expectedIssue of tc.issues) {
+        const found = result.issues.some((actual) => {
+          if (actual.code !== expectedIssue.code) return false;
+          if (
+            JSON.stringify(actual.path) !== JSON.stringify(expectedIssue.path)
+          ) {
+            return false;
+          }
+          if (
+            expectedIssue.expected !== undefined &&
+            actual.expected !== expectedIssue.expected
+          ) {
+            return false;
+          }
+          if (
+            expectedIssue.received !== undefined &&
+            actual.received !== expectedIssue.received
+          ) {
+            return false;
+          }
+          return true;
+        });
+        if (!found) {
+          return {
+            description: tc.description,
+            passed: false,
+            error: `Expected issue ${JSON.stringify(expectedIssue)} not found in actual issues: ${JSON.stringify(result.issues)}`,
+          };
+        }
+      }
+      return { description: tc.description, passed: true };
+    }
+  } catch (err: any) {
+    return {
+      description: tc.description,
+      passed: false,
+      error: `Exception: ${err.message}`,
+    };
+  }
+}

package/tests/forms.test.ts

@@ -0,0 +1,146 @@
+// @vitest-environment jsdom
+
+import { describe, expect, it } from "vitest";
+import { object, string, int, array, exportSchema } from "../src/index.js";
+import { createFormBindings, initForm } from "../src/forms/index.js";
+
+describe("forms bindings", () => {
+  it("derives native field attributes from a schema", () => {
+    const schema = object({
+      email: string().format("email").minLength(5),
+      age: int().min(18),
+      tags: array(string()).minItems(1),
+    });
+
+    const bindings = createFormBindings({ schema });
+
+    expect(bindings.field("email")).toMatchObject({
+      name: "email",
+      type: "email",
+      required: true,
+      minLength: 5,
+    });
+
+    expect(bindings.field("age")).toMatchObject({
+      name: "age",
+      type: "number",
+      required: true,
+      min: 18,
+      step: 1,
+    });
+
+    expect(bindings.field("tags")).toMatchObject({
+      name: "tags",
+      required: true,
+    });
+  });
+});
+
+describe("forms init", () => {
+  it("enhances an existing form and blocks invalid submit", () => {
+    document.body.innerHTML = `
+      <form id="signup">
+        <input name="email" />
+        <input name="age" />
+        <div data-anyvali-error-for="email"></div>
+      </form>
+    `;
+
+    const schema = exportSchema(
+      object({
+        email: string().format("email"),
+        age: int().min(18),
+      })
+    );
+
+    const controller = initForm("#signup", {
+      schema,
+      validateOn: ["blur", "submit"],
+    });
+
+    const form = document.querySelector("#signup") as HTMLFormElement;
+    const email = form.querySelector('[name="email"]') as HTMLInputElement;
+    const age = form.querySelector('[name="age"]') as HTMLInputElement;
+
+    expect(email.type).toBe("email");
+    expect(age.type).toBe("number");
+    expect(age.getAttribute("min")).toBe("18");
+
+    email.value = "not-an-email";
+    age.value = "21";
+
+    const submit = new Event("submit", { cancelable: true });
+    const accepted = form.dispatchEvent(submit);
+
+    expect(accepted).toBe(false);
+    expect(email.validationMessage.length).toBeGreaterThan(0);
+    expect(
+      form.querySelector('[data-anyvali-error-for="email"]')?.textContent
+    ).not.toBe("");
+
+    controller.destroy();
+  });
+
+  it("hooks into htmx validation events for custom validity", () => {
+    document.body.innerHTML = `
+      <form id="profile">
+        <input name="email" />
+      </form>
+    `;
+
+    const controller = initForm("#profile", {
+      schema: exportSchema(object({ email: string().format("email") })),
+      htmx: true,
+    });
+
+    const input = document.querySelector('[name="email"]') as HTMLInputElement;
+    input.value = "broken";
+    input.dispatchEvent(new CustomEvent("htmx:validation:validate", { bubbles: true }));
+
+    expect(input.validationMessage.length).toBeGreaterThan(0);
+
+    controller.destroy();
+  });
+
+  it("reads nested fields and multi-select values using schema paths", () => {
+    document.body.innerHTML = `
+      <form id="profile">
+        <input name="user.email" />
+        <select name="tags" multiple>
+          <option value="alpha">Alpha</option>
+          <option value="beta">Beta</option>
+          <option value="gamma">Gamma</option>
+        </select>
+        <div data-anyvali-error-for="user.email"></div>
+      </form>
+    `;
+
+    const controller = initForm("#profile", {
+      schema: exportSchema(
+        object({
+          user: object({
+            email: string().format("email"),
+          }),
+          tags: array(string()).minItems(1),
+        })
+      ),
+      validateOn: ["submit"],
+    });
+
+    const form = document.querySelector("#profile") as HTMLFormElement;
+    const email = form.querySelector('[name="user.email"]') as HTMLInputElement;
+    const tags = form.querySelector('[name="tags"]') as HTMLSelectElement;
+
+    email.value = "team@anyvali.dev";
+    tags.options[0].selected = true;
+    tags.options[2].selected = true;
+
+    expect(controller.getValues()).toEqual({
+      user: { email: "team@anyvali.dev" },
+      tags: ["alpha", "gamma"],
+    });
+    expect(controller.validate()).toBe(true);
+
+    controller.destroy();
+  });
+});

package/tests/unit/coerce.test.ts

@@ -0,0 +1,136 @@
+import { describe, it, expect } from "vitest";
+import {
+  applyCoercion,
+  normalizeCoercionConfig,
+} from "../../src/parse/coerce.js";
+
+describe("normalizeCoercionConfig", () => {
+  it("passes through object config as-is", () => {
+    const config = { from: "string", trim: true };
+    expect(normalizeCoercionConfig(config)).toBe(config);
+  });
+
+  it("converts single string 'trim' to config", () => {
+    expect(normalizeCoercionConfig("trim")).toEqual({ trim: true });
+  });
+
+  it("converts single string 'lower' to config", () => {
+    expect(normalizeCoercionConfig("lower")).toEqual({ lower: true });
+  });
+
+  it("converts single string 'upper' to config", () => {
+    expect(normalizeCoercionConfig("upper")).toEqual({ upper: true });
+  });
+
+  it("converts 'string->int' to from config", () => {
+    expect(normalizeCoercionConfig("string->int")).toEqual({ from: "string" });
+  });
+
+  it("converts 'string->number' to from config", () => {
+    expect(normalizeCoercionConfig("string->number")).toEqual({
+      from: "string",
+    });
+  });
+
+  it("converts 'string->bool' to from config", () => {
+    expect(normalizeCoercionConfig("string->bool")).toEqual({
+      from: "string",
+    });
+  });
+
+  it("converts array of strings", () => {
+    expect(normalizeCoercionConfig(["trim", "lower"])).toEqual({
+      trim: true,
+      lower: true,
+    });
+  });
+});
+
+describe("applyCoercion edge cases", () => {
+  it("applies trim to string input", () => {
+    const result = applyCoercion("  hello  ", { trim: true }, "string");
+    expect(result).toEqual({ success: true, value: "hello" });
+  });
+
+  it("applies lower to string input", () => {
+    const result = applyCoercion("HELLO", { lower: true }, "string");
+    expect(result).toEqual({ success: true, value: "hello" });
+  });
+
+  it("applies upper to string input", () => {
+    const result = applyCoercion("hello", { upper: true }, "string");
+    expect(result).toEqual({ success: true, value: "HELLO" });
+  });
+
+  it("applies trim + lower together", () => {
+    const result = applyCoercion("  HELLO  ", { trim: true, lower: true }, "string");
+    expect(result).toEqual({ success: true, value: "hello" });
+  });
+
+  it("fails coercing non-integer string to int", () => {
+    const result = applyCoercion("3.5", { from: "string" }, "int");
+    expect(result.success).toBe(false);
+  });
+
+  it("fails coercing non-finite string to int", () => {
+    // A very large number that becomes Infinity
+    const huge = "9".repeat(400);
+    const result = applyCoercion(huge, { from: "string" }, "int");
+    expect(result.success).toBe(false);
+  });
+
+  it("fails coercing empty string to float", () => {
+    const result = applyCoercion("", { from: "string" }, "number");
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.message).toContain("empty string");
+    }
+  });
+
+  it("fails coercing empty string to float32", () => {
+    const result = applyCoercion("", { from: "string" }, "float32");
+    expect(result.success).toBe(false);
+  });
+
+  it("fails coercing empty string to float64", () => {
+    const result = applyCoercion("", { from: "string" }, "float64");
+    expect(result.success).toBe(false);
+  });
+
+  it("fails coercing non-numeric string to number", () => {
+    const result = applyCoercion("abc", { from: "string" }, "number");
+    expect(result.success).toBe(false);
+  });
+
+  it("successfully coerces valid float string", () => {
+    const result = applyCoercion("3.14", { from: "string" }, "number");
+    expect(result).toEqual({ success: true, value: 3.14 });
+  });
+
+  it("coerces string to int subtypes", () => {
+    for (const kind of [
+      "int8", "int16", "int32", "int64",
+      "uint8", "uint16", "uint32", "uint64",
+    ]) {
+      const result = applyCoercion("42", { from: "string" }, kind);
+      expect(result).toEqual({ success: true, value: 42 });
+    }
+  });
+
+  it("coerces string to float32/float64", () => {
+    for (const kind of ["float32", "float64"]) {
+      const result = applyCoercion("1.5", { from: "string" }, kind);
+      expect(result).toEqual({ success: true, value: 1.5 });
+    }
+  });
+
+  it("does not coerce when input is not a string", () => {
+    const result = applyCoercion(42, { from: "string" }, "int");
+    expect(result).toEqual({ success: true, value: 42 });
+  });
+
+  it("does not apply trim/lower/upper when input is not a string", () => {
+    const result = applyCoercion(42, { trim: true, lower: true, upper: true }, "number");
+    expect(result).toEqual({ success: true, value: 42 });
+  });
+});

package/tests/unit/collections.test.ts

@@ -0,0 +1,99 @@
+import { describe, it, expect } from "vitest";
+import { array, tuple, record, string, int, bool, any } from "../../src/index.js";
+
+describe("ArraySchema", () => {
+  it("accepts valid arrays", () => {
+    const s = array(int());
+    expect(s.parse([1, 2, 3])).toEqual([1, 2, 3]);
+  });
+
+  it("rejects non-arrays", () => {
+    const s = array(int());
+    expect(s.safeParse("not an array").success).toBe(false);
+  });
+
+  it("validates array items", () => {
+    const s = array(int());
+    const result = s.safeParse([1, "two", 3]);
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.issues[0].path).toEqual([1]);
+    }
+  });
+
+  it("validates minItems", () => {
+    const s = array(int()).minItems(2);
+    expect(s.parse([1, 2])).toEqual([1, 2]);
+    expect(s.safeParse([1]).success).toBe(false);
+  });
+
+  it("validates maxItems", () => {
+    const s = array(int()).maxItems(2);
+    expect(s.parse([1, 2])).toEqual([1, 2]);
+    expect(s.safeParse([1, 2, 3]).success).toBe(false);
+  });
+});
+
+describe("TupleSchema", () => {
+  it("accepts valid tuples", () => {
+    const s = tuple([string(), int(), bool()]);
+    expect(s.parse(["hello", 42, true])).toEqual(["hello", 42, true]);
+  });
+
+  it("rejects wrong length", () => {
+    const s = tuple([string(), int()]);
+    expect(s.safeParse(["hello"]).success).toBe(false);
+    expect(s.safeParse(["hello", 42, true]).success).toBe(false);
+  });
+
+  it("validates element types", () => {
+    const s = tuple([string(), int()]);
+    const result = s.safeParse([42, "hello"]);
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.issues[0].path).toEqual([0]);
+    }
+  });
+});
+
+describe("RecordSchema", () => {
+  it("accepts valid records", () => {
+    const s = record(int());
+    expect(s.parse({ a: 1, b: 2 })).toEqual({ a: 1, b: 2 });
+  });
+
+  it("rejects non-objects", () => {
+    const s = record(int());
+    expect(s.safeParse("not object").success).toBe(false);
+    expect(s.safeParse(null).success).toBe(false);
+    expect(s.safeParse([]).success).toBe(false);
+  });
+
+  it("validates record values", () => {
+    const s = record(int());
+    const result = s.safeParse({ a: 1, b: "two" });
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.issues[0].path).toEqual(["b"]);
+    }
+  });
+
+  it("preserves __proto__ as data in records", () => {
+    const s = record(any());
+    const input = JSON.parse(
+      '{"safe":1,"__proto__":{"polluted":"yes"}}'
+    ) as Record<
+      string,
+      unknown
+    >;
+
+    const result = s.parse(input);
+
+    expect(result.safe).toBe(1);
+    expect(Object.getPrototypeOf(result)).toBe(Object.prototype);
+    expect(Object.prototype.hasOwnProperty.call(result, "__proto__")).toBe(true);
+    expect(
+      Object.getOwnPropertyDescriptor(result, "__proto__")?.value
+    ).toEqual({ polluted: "yes" });
+  });
+});

package/tests/unit/composition.test.ts

@@ -0,0 +1,80 @@
+import { describe, it, expect } from "vitest";
+import {
+  union,
+  intersection,
+  optional,
+  nullable,
+  string,
+  int,
+  object,
+  literal,
+} from "../../src/index.js";
+
+describe("UnionSchema", () => {
+  it("accepts values matching any variant", () => {
+    const s = union([string(), int()]);
+    expect(s.parse("hello")).toBe("hello");
+    expect(s.parse(42)).toBe(42);
+  });
+
+  it("rejects values matching no variant", () => {
+    const s = union([string(), int()]);
+    const result = s.safeParse(true);
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.issues[0].code).toBe("invalid_union");
+    }
+  });
+
+  it("returns first matching variant result", () => {
+    const s = union([literal("a"), string()]);
+    expect(s.parse("a")).toBe("a");
+    expect(s.parse("b")).toBe("b");
+  });
+});
+
+describe("IntersectionSchema", () => {
+  it("validates against all schemas", () => {
+    const s = intersection([
+      object({ name: string() }).unknownKeys("strip"),
+      object({ age: int() }).unknownKeys("strip"),
+    ]);
+    const result = s.parse({ name: "Alice", age: 30 });
+    expect(result).toEqual({ name: "Alice", age: 30 });
+  });
+
+  it("fails if any schema fails", () => {
+    const s = intersection([
+      object({ name: string() }).unknownKeys("strip"),
+      object({ age: int() }).unknownKeys("strip"),
+    ]);
+    const result = s.safeParse({ name: "Alice" });
+    expect(result.success).toBe(false);
+  });
+});
+
+describe("OptionalSchema", () => {
+  it("accepts undefined", () => {
+    const s = optional(string());
+    expect(s.parse(undefined)).toBe(undefined);
+  });
+
+  it("validates when present", () => {
+    const s = optional(string());
+    expect(s.parse("hello")).toBe("hello");
+    expect(s.safeParse(42).success).toBe(false);
+  });
+});
+
+describe("NullableSchema", () => {
+  it("accepts null", () => {
+    const s = nullable(string());
+    expect(s.parse(null)).toBe(null);
+  });
+
+  it("validates when not null", () => {
+    const s = nullable(string());
+    expect(s.parse("hello")).toBe("hello");
+    expect(s.safeParse(42).success).toBe(false);
+  });
+});

package/tests/unit/date-format.test.ts

@@ -0,0 +1,18 @@
+import { describe, it, expect } from "vitest";
+import { string } from "../../src/index.js";
+
+const date = () => string().format("date");
+
+describe("date format validation", () => {
+  it("accepts valid ISO dates including early years (0001-0099)", () => {
+    for (const d of ["0001-01-01", "0050-01-01", "0099-12-31", "2021-06-15", "9999-12-31"]) {
+      expect(date().safeParse(d).success).toBe(true);
+    }
+  });
+
+  it("rejects impossible calendar dates", () => {
+    for (const d of ["2021-02-30", "2021-04-31", "2021-13-01", "2021-00-10"]) {
+      expect(date().safeParse(d).success).toBe(false);
+    }
+  });
+});

package/tests/unit/default-mutation.test.ts

@@ -0,0 +1,32 @@
+import { describe, it, expect } from "vitest";
+import { any, unknown, object } from "../../src/index.js";
+
+// Repro for AVV-007: mutable default values shared between validations.
+// Pass-through schemas (any/unknown) return the default value by reference,
+// so mutating one parse result corrupts the default for the next parse.
+describe("Mutable default isolation (AVV-007)", () => {
+  it("any() array default is not shared between parses", () => {
+    const s = any().default([] as unknown[]);
+    const a = s.parse(undefined) as unknown[];
+    a.push("mutated");
+    const b = s.parse(undefined) as unknown[];
+    expect(b).toEqual([]);
+  });
+
+  it("unknown() object default is not shared between parses", () => {
+    const s = unknown().default({ tags: [] as string[] });
+    const a = s.parse(undefined) as { tags: string[] };
+    a.tags.push("x");
+    const b = s.parse(undefined) as { tags: string[] };
+    expect(b.tags).toEqual([]);
+  });
+
+  it("object field with any() default is not shared", () => {
+    const s = object({ meta: any().default({ count: 0, items: [] as number[] }) });
+    const a = s.parse({}) as { meta: { count: number; items: number[] } };
+    a.meta.items.push(1);
+    a.meta.count = 99;
+    const b = s.parse({}) as { meta: { count: number; items: number[] } };
+    expect(b.meta).toEqual({ count: 0, items: [] });
+  });
+});