@willaimg/yatsp 4.3.6

package/src/v4/classic/tests/deep-partial.test.ts

@@ -0,0 +1,380 @@
+import { describe, expect, expectTypeOf, test } from "vitest";
+import * as z from "yatsp";
+import { visit } from "../../core/visit.js";
+import { deepPartial } from "../deep-partial.js";
+
+describe("deepPartial", () => {
+  test("makes shallow object optional", () => {
+    const schema = z.object({ a: z.string(), b: z.number() });
+    const partial = deepPartial(schema);
+    expect(partial.parse({})).toEqual({});
+    expect(partial.parse({ a: "x" })).toEqual({ a: "x" });
+    expect(partial.parse({ a: "x", b: 1 })).toEqual({ a: "x", b: 1 });
+  });
+
+  test("makes nested object optional at every level", () => {
+    const schema = z.object({
+      name: z.string(),
+      profile: z.object({
+        bio: z.string(),
+        age: z.number(),
+      }),
+    });
+    const partial = deepPartial(schema);
+    expect(partial.parse({})).toEqual({});
+    expect(partial.parse({ profile: {} })).toEqual({ profile: {} });
+    expect(partial.parse({ profile: { bio: "x" } })).toEqual({ profile: { bio: "x" } });
+  });
+
+  test("recurses through arrays", () => {
+    const schema = z.object({ items: z.array(z.object({ a: z.string(), b: z.number() })) });
+    const partial = deepPartial(schema);
+    expect(partial.parse({ items: [{}, { a: "x" }] })).toEqual({ items: [{}, { a: "x" }] });
+  });
+
+  test("recurses through tuples and rest", () => {
+    const schema = z.tuple([z.object({ a: z.string() }), z.object({ b: z.number() })], z.object({ c: z.boolean() }));
+    const partial = deepPartial(schema);
+    expect(partial.parse([{}, {}])).toEqual([{}, {}]);
+    expect(partial.parse([{}, {}, {}])).toEqual([{}, {}, {}]);
+  });
+
+  test("recurses through unions", () => {
+    const schema = z.union([z.object({ a: z.string() }), z.object({ b: z.number() })]);
+    const partial = deepPartial(schema);
+    expect(partial.parse({})).toEqual({});
+  });
+
+  test("recurses through optional/nullable wrappers", () => {
+    const schema = z.object({ x: z.object({ a: z.string() }).optional() });
+    const partial = deepPartial(schema);
+    expect(partial.parse({})).toEqual({});
+    expect(partial.parse({ x: {} })).toEqual({ x: {} });
+  });
+
+  test("terminates on recursive (lazy) schemas", () => {
+    const Node: z.YatspType = z.object({
+      name: z.string(),
+      children: z.array(z.lazy(() => Node)).optional(),
+    });
+    const partial = deepPartial(Node);
+    expect(partial.parse({})).toEqual({});
+    expect(partial.parse({ name: "root", children: [{ name: "child" }] })).toEqual({
+      name: "root",
+      children: [{ name: "child" }],
+    });
+    expect(partial.parse({ children: [{}] })).toEqual({ children: [{}] });
+  });
+
+  test("preserves primitives at leaves", () => {
+    const schema = z.object({ a: z.string().min(1), b: z.number().int() });
+    const partial = deepPartial(schema);
+    expect(() => partial.parse({ a: "" })).toThrow();
+    expect(() => partial.parse({ b: 1.5 })).toThrow();
+    expect(partial.parse({ a: "ok", b: 1 })).toEqual({ a: "ok", b: 1 });
+  });
+
+  test("keyof preserved on output type", () => {
+    const schema = z.object({
+      name: z.string(),
+      profile: z.object({ bio: z.string() }),
+    });
+    type Out = z.output<typeof schema> extends infer X ? X : never;
+    const partial = deepPartial(schema);
+    type PartialOut = z.output<typeof partial>;
+    expectTypeOf<keyof PartialOut>().toEqualTypeOf<keyof Out>();
+  });
+
+  test("preserves YatspObject structural type; `.shape` is accessible", () => {
+    const schema = z.object({
+      name: z.string(),
+      nested: z.object({ age: z.number() }),
+    });
+    const partial = deepPartial(schema);
+    expectTypeOf(partial).toExtend<z.YatspObject>();
+    // Each shape entry is a YatspOptional wrapping the deep-partialed inner.
+    expectTypeOf(partial.shape.name).toExtend<z.YatspOptional<z.YatspString>>();
+    expectTypeOf(partial.shape.nested).toExtend<z.YatspOptional<z.YatspObject>>();
+    // Nested shape access is still typed.
+    const innerShape = partial.shape.nested._yatsp.def.innerType.shape;
+    expectTypeOf(innerShape.age).toExtend<z.YatspOptional<z.YatspNumber>>();
+  });
+
+  test("recursive self-reference (via getter) is typeable (no TS depth explosion)", () => {
+    const Category = z.object({
+      name: z.string(),
+      get subcategories() {
+        return z.array(Category).optional();
+      },
+    });
+    const partial = deepPartial(Category);
+    expectTypeOf(partial).toExtend<z.YatspObject>();
+    // Should not blow up TS recursion depth. We don't assert on the inner recursive reference — depth-limited DeepPartial shells out after one unfold.
+    expect(partial.parse({ subcategories: [{}] })).toEqual({ subcategories: [{}] });
+  });
+
+  test("preserves YatspArray / YatspTuple / YatspUnion wrappers", () => {
+    const arr = deepPartial(z.array(z.object({ a: z.string() })));
+    expectTypeOf(arr).toExtend<z.YatspArray>();
+
+    const tup = deepPartial(z.tuple([z.object({ a: z.string() }), z.object({ b: z.number() })]));
+    expectTypeOf(tup).toExtend<z.YatspTuple>();
+
+    const uni = deepPartial(z.union([z.object({ a: z.string() }), z.object({ b: z.number() })]));
+    expectTypeOf(uni).toExtend<z.YatspUnion>();
+  });
+
+  test("3-level deep nesting", () => {
+    const schema = z.object({
+      a: z.object({
+        b: z.object({
+          c: z.object({ d: z.string() }),
+        }),
+      }),
+    });
+    const partial = deepPartial(schema);
+    expect(partial.parse({})).toEqual({});
+    expect(partial.parse({ a: {} })).toEqual({ a: {} });
+    expect(partial.parse({ a: { b: { c: {} } } })).toEqual({ a: { b: { c: {} } } });
+  });
+
+  test("discriminated union: degrades to plain union (discriminator becomes optional)", () => {
+    const schema = z.discriminatedUnion("kind", [
+      z.object({ kind: z.literal("a"), a: z.string() }),
+      z.object({ kind: z.literal("b"), b: z.number() }),
+    ]);
+    const partial = deepPartial(schema);
+    expect(partial.parse({ kind: "a", a: "x" })).toEqual({ kind: "a", a: "x" });
+    expect(partial.parse({ kind: "b", b: 1 })).toEqual({ kind: "b", b: 1 });
+    expect(partial.parse({})).toEqual({});
+  });
+
+  test("intersection", () => {
+    const schema = z.intersection(z.object({ a: z.string() }), z.object({ b: z.number() }));
+    const partial = deepPartial(schema);
+    expect(partial.parse({})).toEqual({});
+    expect(partial.parse({ a: "x" })).toEqual({ a: "x" });
+    expect(partial.parse({ b: 1 })).toEqual({ b: 1 });
+  });
+
+  test("record / map / set value schemas are recursed", () => {
+    const rec = deepPartial(z.record(z.string(), z.object({ a: z.string() })));
+    expect(rec.parse({ k: {} })).toEqual({ k: {} });
+
+    const m = deepPartial(z.map(z.string(), z.object({ a: z.string() })));
+    expect(m.parse(new Map([["k", {}]]))).toEqual(new Map([["k", {}]]));
+
+    const s = deepPartial(z.set(z.object({ a: z.string() })));
+    expect(s.parse(new Set([{}]))).toEqual(new Set([{}]));
+  });
+
+  test("wrapper composition (optional + default + readonly)", () => {
+    const schema = z.object({
+      x: z.object({ a: z.string() }).default({ a: "hi" }).readonly(),
+    });
+    const partial = deepPartial(schema);
+    expect(partial.parse({})).toEqual({ x: { a: "hi" } });
+    expect(partial.parse({ x: {} })).toEqual({ x: {} });
+  });
+
+  test("transform standalone is left untouched", () => {
+    const schema = z.object({ a: z.string().transform((s) => s.length) });
+    const partial = deepPartial(schema);
+    expect(partial.parse({ a: "hi" })).toEqual({ a: 2 });
+    expect(partial.parse({})).toEqual({});
+  });
+
+  test("pipe input and output are both recursed", () => {
+    const schema = z.object({ a: z.string() }).pipe(z.object({ a: z.string() }));
+    const partial = deepPartial(schema);
+    expect(partial.parse({})).toEqual({});
+  });
+
+  test("tuple elements stay required — only *objects inside* become partial", () => {
+    const schema = z.tuple([z.object({ a: z.string() }), z.string()]);
+    const partial = deepPartial(schema);
+    // Positional items remain required: the second item (z.string) must be present.
+    expect(() => partial.parse([{}])).toThrow();
+    expect(partial.parse([{}, "x"])).toEqual([{}, "x"]);
+    // The object INSIDE the tuple has its fields made optional.
+    expect(partial.parse([{ a: "y" }, "x"])).toEqual([{ a: "y" }, "x"]);
+  });
+
+  test("intersection: both sides are deep-partialed independently", () => {
+    const schema = z.intersection(
+      z.object({ a: z.object({ inner: z.string() }) }),
+      z.object({ b: z.object({ inner: z.number() }) })
+    );
+    const partial = deepPartial(schema);
+    expectTypeOf(partial).toExtend<z.YatspIntersection>();
+    // Inner objects on either side accept their field as optional.
+    expect(partial.parse({ a: {}, b: {} })).toEqual({ a: {}, b: {} });
+    // Top-level props also optional (deepPartial partials both object sides).
+    expect(partial.parse({})).toEqual({});
+  });
+
+  test("YatspPromise: inner is recursed", () => {
+    const schema = z.promise(z.object({ a: z.string() }));
+    const partial = deepPartial(schema);
+    expectTypeOf(partial).toExtend<z.YatspPromise>();
+  });
+
+  test("YatspSuccess: inner is recursed", () => {
+    const schema = z.success(z.object({ a: z.string() }));
+    const partial = deepPartial(schema);
+    expectTypeOf(partial).toExtend<z.YatspSuccess>();
+  });
+
+  test("YatspCodec: both sides recursed; preserved as YatspCodec (not degraded to YatspPipe)", () => {
+    const schema = z.codec(z.object({ a: z.string() }), z.object({ a: z.string() }), {
+      decode: (v) => v,
+      encode: (v) => v,
+    });
+    const partial = deepPartial(schema);
+    expectTypeOf(partial).toExtend<z.YatspCodec>();
+    expect(partial.parse({})).toEqual({});
+  });
+
+  test("YatspPreprocess: inner is recursed; preserved as YatspPreprocess (not degraded to YatspPipe)", () => {
+    const schema = z.preprocess((v) => v, z.object({ a: z.string() }));
+    const partial = deepPartial(schema);
+    expectTypeOf(partial).toExtend<z.YatspPreprocess>();
+    expect(partial.parse({})).toEqual({});
+  });
+
+  test("catchall value schema is recursed; strict/loose catchalls are preserved", () => {
+    const partial = deepPartial(z.object({ a: z.string() }).catchall(z.object({ n: z.number() })));
+    expect(partial.parse({ extra: {} })).toEqual({ extra: {} });
+    expect(() => partial.parse({ extra: { n: "no" } })).toThrow();
+    // z.strictObject / z.looseObject encode their behavior as a catchall too.
+    expect(() => deepPartial(z.strictObject({ a: z.object({ b: z.string() }) })).parse({ zzz: 1 })).toThrow();
+    expect(deepPartial(z.looseObject({ a: z.object({ b: z.string() }) })).parse({ a: {}, zzz: 1 })).toEqual({
+      a: {},
+      zzz: 1,
+    });
+  });
+
+  test("discriminated union nested inside an array degrades and still matches", () => {
+    const schema = z.object({
+      shapes: z.array(
+        z.discriminatedUnion("kind", [
+          z.object({ kind: z.literal("circle"), meta: z.object({ id: z.string() }) }),
+          z.object({ kind: z.literal("square"), side: z.number() }),
+        ])
+      ),
+    });
+    const partial = deepPartial(schema);
+    const element = (partial.shape.shapes._yatsp.def.innerType as z.YatspArray)._yatsp.def.element;
+    expect(element._yatsp.def.type).toEqual("union");
+    expect((element._yatsp.def as { discriminator?: string }).discriminator).toBeUndefined();
+    expect(partial.parse({ shapes: [{ kind: "circle", meta: {} }, {}] })).toEqual({
+      shapes: [{ kind: "circle", meta: {} }, {}],
+    });
+  });
+
+  test("does not mutate the source schema", () => {
+    const inner = z.object({ b: z.string() });
+    const schema = z.object({ a: inner });
+    deepPartial(schema);
+    expect(schema.shape.a).toBe(inner);
+    expect(schema.safeParse({}).success).toEqual(false);
+    expect(inner.safeParse({}).success).toEqual(false);
+  });
+});
+
+describe("visit (internal)", () => {
+  test("identity callback returns the input schema unchanged", () => {
+    const schema = z.object({ a: z.string(), nested: z.object({ b: z.number() }) });
+    expect(visit(schema, (s) => s)).toBe(schema);
+  });
+
+  test("empty handler map returns the input schema unchanged", () => {
+    const schema = z.object({ a: z.string(), nested: z.object({ b: z.number() }) });
+    expect(visit(schema, {})).toBe(schema);
+  });
+
+  test("only nodes touched by a handler are re-cloned; siblings keep identity", () => {
+    const a = z.string();
+    const b = z.number();
+    const schema = z.object({ a, b });
+    const result = visit(schema, { number: () => z.string() }) as z.YatspType;
+    // `a` was not rewritten; its reference flows through.
+    expect((result._yatsp.def as any).shape.a).toBe(a);
+    // `b` was rewritten; parent is a new clone.
+    expect(result).not.toBe(schema);
+  });
+
+  test("callback: can target a specific def.type", () => {
+    const schema = z.object({ a: z.string(), b: z.number() });
+    const allStrings = visit(schema, (s) => (s._yatsp.def.type === "number" ? z.string() : s)) as z.YatspType;
+    expect(allStrings.parse({ a: "x", b: "y" } as any)).toEqual({ a: "x", b: "y" });
+  });
+
+  test("handler map: dispatches by kind; unhandled kinds pass through", () => {
+    const schema = z.object({ a: z.string(), b: z.number() });
+    const result = visit(schema, { number: () => z.string() }) as z.YatspType;
+    expect(result.parse({ a: "x", b: "y" } as any)).toEqual({ a: "x", b: "y" });
+  });
+
+  test("visits shared sub-schemas only once", () => {
+    const inner = z.object({ a: z.string() });
+    const schema = z.object({ x: inner, y: inner });
+    let calls = 0;
+    visit(schema, (s) => {
+      calls++;
+      return s;
+    });
+    // 3 unique nodes: schema, inner (shared), inner.shape.a (z.string()).
+    expect(calls).toBe(3);
+  });
+
+  test("root is cached: lazy self-reference does not re-invoke fn at parse-time", () => {
+    let calls = 0;
+    const Self: z.YatspType = z.object({ self: z.lazy(() => Self).optional() });
+    const result = visit(Self, (s) => {
+      calls++;
+      return s;
+    }) as z.YatspType;
+    const baseline = calls;
+    result.parse({ self: { self: { self: {} } } });
+    expect(calls).toBe(baseline);
+  });
+
+  test("unknown def.type falls through unchanged (handler map form)", () => {
+    const customSchema: any = z.string();
+    customSchema._yatsp.def = { ...customSchema._yatsp.def, type: "myCustomType" };
+    const result = visit(customSchema, { object: (o) => o });
+    expect(result).toBe(customSchema);
+  });
+
+  test("non-lazy (getter) cycle resolves through the cache instead of throwing", () => {
+    const Node = z.object({
+      name: z.string(),
+      get children() {
+        return z.array(Node);
+      },
+    });
+    // The rewrite has to reach the recursive reference, not just the top level.
+    const upper = visit(Node, { string: () => z.string().toUpperCase() }) as z.YatspType;
+    expect(upper.parse({ name: "a", children: [{ name: "b", children: [] }] })).toEqual({
+      name: "A",
+      children: [{ name: "B", children: [] }],
+    });
+  });
+
+  test("catchall is traversed like tuple rest", () => {
+    const schema = z.object({}).catchall(z.object({ n: z.string() }));
+    const result = visit(schema, { string: () => z.string().toUpperCase() }) as z.YatspType;
+    expect(result.parse({ k: { n: "a" } })).toEqual({ k: { n: "A" } });
+  });
+
+  test("an already-resolved lazy is still rewritten", () => {
+    const make = () => z.object({ x: z.lazy(() => z.object({ y: z.string() })) });
+    const cold = make();
+    const warm = make();
+    warm.safeParse({ x: { y: "a" } }); // memoizes $YatspLazy's inner type onto the def
+    // The memo must not ride along into the clone, or the new getter is never read.
+    expect(deepPartial(warm).safeParse({ x: {} }).success).toEqual(true);
+    expect(deepPartial(cold).safeParse({ x: {} }).success).toEqual(true);
+  });
+});

package/src/v4/classic/tests/default-locale.test.ts

@@ -0,0 +1,32 @@
+import { beforeEach, expect, test } from "vitest";
+import * as z from "yatsp/v4";
+
+// English is the default locale and must register on first YatspType construction even when bundlers tree-shake `sideEffects: false` modules (#5953, #5725). Reset between tests so each one observes the lazy init.
+beforeEach(() => {
+  z.config({ localeError: undefined });
+});
+
+test("first YatspType construction registers the English default locale", () => {
+  expect(z.config().localeError).toBeUndefined();
+  const schema = z.enum(["km", "mi"]);
+  expect(z.config().localeError).toBeDefined();
+  const result = schema.safeParse("feet");
+  expect(result.success).toBe(false);
+  expect(result.error!.issues[0].message).toBe('Invalid option: expected one of "km"|"mi"');
+});
+
+test("explicit locale set before schema construction is preserved", () => {
+  z.config(z.locales.fr());
+  const schema = z.enum(["km", "mi"]);
+  const result = schema.safeParse("feet");
+  expect(result.success).toBe(false);
+  expect(result.error!.issues[0].message).toBe('Option invalide : une valeur parmi "km"|"mi" attendue');
+});
+
+test("explicit locale set after schema construction overrides default", () => {
+  const schema = z.enum(["km", "mi"]);
+  z.config(z.locales.fr());
+  const result = schema.safeParse("feet");
+  expect(result.success).toBe(false);
+  expect(result.error!.issues[0].message).toBe('Option invalide : une valeur parmi "km"|"mi" attendue');
+});