@willaimg/yatsp 4.3.6

package/src/v4/mini/tests/number.test.ts

@@ -0,0 +1,109 @@
+import { expect, expectTypeOf, test } from "vitest";
+import * as z from "yatsp/mini";
+
+test("z.number", () => {
+  const a = z.number();
+  expect(z.parse(a, 123)).toEqual(123);
+  expect(z.parse(a, 123.45)).toEqual(123.45);
+  expect(() => z.parse(a, "123")).toThrow();
+  expect(() => z.parse(a, false)).toThrow();
+
+  type a = z.infer<typeof a>;
+  expectTypeOf<a>().toEqualTypeOf<number>();
+});
+
+test("z.number async", async () => {
+  const a = z.number().check(z.refine(async (_) => _ > 0));
+  await expect(z.parseAsync(a, 123)).resolves.toEqual(123);
+  await expect(() => z.parseAsync(a, -123)).rejects.toThrow();
+  await expect(() => z.parseAsync(a, "123")).rejects.toThrow();
+});
+
+test("z.int", () => {
+  const a = z.int();
+  expect(z.parse(a, 123)).toEqual(123);
+  expect(() => z.parse(a, 123.45)).toThrow();
+  expect(() => z.parse(a, "123")).toThrow();
+  expect(() => z.parse(a, false)).toThrow();
+});
+
+test("z.float32", () => {
+  const a = z.float32();
+  expect(z.parse(a, 123.45)).toEqual(123.45);
+  expect(() => z.parse(a, "123.45")).toThrow();
+  expect(() => z.parse(a, false)).toThrow();
+  // -3.4028234663852886e38, 3.4028234663852886e38;
+  expect(() => z.parse(a, 3.4028234663852886e38 * 2)).toThrow(); // Exceeds max
+  expect(() => z.parse(a, -3.4028234663852886e38 * 2)).toThrow(); // Exceeds min
+});
+
+test("z.float64", () => {
+  const a = z.float64();
+  expect(z.parse(a, 123.45)).toEqual(123.45);
+  expect(() => z.parse(a, "123.45")).toThrow();
+  expect(() => z.parse(a, false)).toThrow();
+  expect(() => z.parse(a, 1.7976931348623157e308 * 2)).toThrow(); // Exceeds max
+  expect(() => z.parse(a, -1.7976931348623157e308 * 2)).toThrow(); // Exceeds min
+});
+
+test("z.int32", () => {
+  const a = z.int32();
+  expect(z.parse(a, 123)).toEqual(123);
+  expect(() => z.parse(a, 123.45)).toThrow();
+  expect(() => z.parse(a, "123")).toThrow();
+  expect(() => z.parse(a, false)).toThrow();
+  expect(() => z.parse(a, 2147483648)).toThrow(); // Exceeds max
+  expect(() => z.parse(a, -2147483649)).toThrow(); // Exceeds min
+});
+
+test("z.uint32", () => {
+  const a = z.uint32();
+  expect(z.parse(a, 123)).toEqual(123);
+  expect(() => z.parse(a, -123)).toThrow();
+  expect(() => z.parse(a, 123.45)).toThrow();
+  expect(() => z.parse(a, "123")).toThrow();
+  expect(() => z.parse(a, false)).toThrow();
+  expect(() => z.parse(a, 4294967296)).toThrow(); // Exceeds max
+  expect(() => z.parse(a, -1)).toThrow(); // Below min
+});
+
+test("z.int64", () => {
+  const a = z.int64();
+  expect(z.parse(a, BigInt(123))).toEqual(BigInt(123));
+  expect(() => z.parse(a, 123)).toThrow();
+  expect(() => z.parse(a, 123.45)).toThrow();
+  expect(() => z.parse(a, "123")).toThrow();
+  expect(() => z.parse(a, false)).toThrow();
+  expect(() => z.parse(a, BigInt("9223372036854775808"))).toThrow();
+  expect(() => z.parse(a, BigInt("-9223372036854775809"))).toThrow();
+  // expect(() => z.parse(a, BigInt("9223372036854775808"))).toThrow(); // Exceeds max
+  // expect(() => z.parse(a, BigInt("-9223372036854775809"))).toThrow(); // Exceeds min
+});
+
+test("z.uint64", () => {
+  const a = z.uint64();
+  expect(z.parse(a, BigInt(123))).toEqual(BigInt(123));
+  expect(() => z.parse(a, 123)).toThrow();
+  expect(() => z.parse(a, -123)).toThrow();
+  expect(() => z.parse(a, 123.45)).toThrow();
+  expect(() => z.parse(a, "123")).toThrow();
+  expect(() => z.parse(a, false)).toThrow();
+  expect(() => z.parse(a, BigInt("18446744073709551616"))).toThrow(); // Exceeds max
+  expect(() => z.parse(a, BigInt("-1"))).toThrow(); // Below min
+  // expect(() => z.parse(a, BigInt("18446744073709551616"))).toThrow(); // Exceeds max
+  // expect(() => z.parse(a, BigInt("-1"))).toThrow(); // Below min
+});
+
+test("number and bigint formats are distinct at the type level", () => {
+  expectTypeOf(z.int()._yatsp.def.format).toEqualTypeOf<"safeint">();
+  expectTypeOf(z.uint32()._yatsp.def.format).toEqualTypeOf<"uint32">();
+  expectTypeOf(z.int64()._yatsp.def.format).toEqualTypeOf<"int64">();
+
+  z.int32() satisfies z.YatspMiniInt32;
+  z.uint64() satisfies z.YatspMiniUInt64;
+
+  // @ts-expect-error a float64 schema is not a YatspMiniFloat32
+  z.float64() satisfies z.YatspMiniFloat32;
+  // @ts-expect-error a uint64 schema is not a YatspMiniInt64
+  z.uint64() satisfies z.YatspMiniInt64;
+});

package/src/v4/mini/tests/object.test.ts

@@ -0,0 +1,292 @@
+import { expect, expectTypeOf, test } from "vitest";
+import * as z from "yatsp/mini";
+
+test("z.object", () => {
+  const a = z.object({
+    name: z.string(),
+    age: z.number(),
+    points: z.optional(z.number()),
+    "test?": z.boolean(),
+  });
+
+  a._yatsp.def.shape["test?"];
+  a._yatsp.def.shape.points._yatsp.optin;
+
+  type a = z.output<typeof a>;
+
+  expectTypeOf<a>().toEqualTypeOf<{
+    name: string;
+    age: number;
+    points?: number | undefined;
+    "test?": boolean;
+  }>();
+  expect(z.parse(a, { name: "john", age: 30, "test?": true })).toEqual({
+    name: "john",
+    age: 30,
+    "test?": true,
+  });
+  // "test?" is required in YatspObject
+  expect(() => z.parse(a, { name: "john", age: "30" })).toThrow();
+  expect(() => z.parse(a, "hello")).toThrow();
+
+  // null prototype
+  const schema = z.object({ a: z.string() });
+  const obj = Object.create(null);
+  obj.a = "foo";
+  expect(schema.parse(obj)).toEqual({ a: "foo" });
+});
+
+test("z.object().check()", () => {
+  const a = z.object({
+    name: z.string(),
+    age: z.number(),
+    points: z.optional(z.number()),
+    "test?": z.boolean(),
+  });
+
+  type a = z.output<typeof a>;
+
+  a.check(({ value }) => {
+    expectTypeOf(value).toEqualTypeOf<a>();
+  });
+});
+
+test("z.strictObject", () => {
+  const a = z.strictObject({
+    name: z.string(),
+  });
+  expect(z.parse(a, { name: "john" })).toEqual({ name: "john" });
+  expect(() => z.parse(a, { name: "john", age: 30 })).toThrow();
+  expect(() => z.parse(a, "hello")).toThrow();
+});
+
+test("z.looseObject", () => {
+  const a = z.looseObject({
+    name: z.string(),
+    age: z.number(),
+  });
+  expect(z.parse(a, { name: "john", age: 30 })).toEqual({
+    name: "john",
+    age: 30,
+  });
+  expect(z.parse(a, { name: "john", age: 30, extra: true })).toEqual({
+    name: "john",
+    age: 30,
+    extra: true,
+  });
+  expect(() => z.parse(a, "hello")).toThrow();
+});
+
+const userSchema = z.object({
+  name: z.string(),
+  age: z.number(),
+  email: z.optional(z.string()),
+});
+
+test("z.keyof", () => {
+  // z.keyof returns an enum schema of the keys of an object schema
+  const userKeysSchema = z.keyof(userSchema);
+  type UserKeys = z.infer<typeof userKeysSchema>;
+  expectTypeOf<UserKeys>().toEqualTypeOf<"name" | "age" | "email">();
+  expect(userKeysSchema).toBeDefined();
+  expect(userKeysSchema._yatsp.def.type).toBe("enum");
+  expect(userKeysSchema._yatsp.def.entries).toEqual({
+    name: "name",
+    age: "age",
+    email: "email",
+  });
+  expect(z.safeParse(userKeysSchema, "name").success).toBe(true);
+  expect(z.safeParse(userKeysSchema, "age").success).toBe(true);
+  expect(z.safeParse(userKeysSchema, "email").success).toBe(true);
+  expect(z.safeParse(userKeysSchema, "isAdmin").success).toBe(false);
+});
+
+test("z.extend", () => {
+  const extendedSchema = z.extend(userSchema, {
+    isAdmin: z.boolean(),
+  });
+  type ExtendedUser = z.infer<typeof extendedSchema>;
+  expectTypeOf<ExtendedUser>().toEqualTypeOf<{
+    name: string;
+    age: number;
+    email?: string | undefined;
+    isAdmin: boolean;
+  }>();
+  expect(extendedSchema).toBeDefined();
+  expect(z.safeParse(extendedSchema, { name: "John", age: 30, isAdmin: true }).success).toBe(true);
+});
+
+test("z.merge", () => {
+  const mergedSchema = z.merge(userSchema, z.object({ isAdmin: z.boolean() }));
+  type MergedUser = z.infer<typeof mergedSchema>;
+  expectTypeOf<MergedUser>().toEqualTypeOf<{
+    name: string;
+    age: number;
+    email?: string | undefined;
+    isAdmin: boolean;
+  }>();
+  expect(z.safeParse(mergedSchema, { name: "John", age: 30, isAdmin: true }).success).toBe(true);
+
+  // the second schema's catchall wins, matching classic
+  const strict = z.merge(userSchema, z.strictObject({ isAdmin: z.boolean() }));
+  expect(z.safeParse(strict, { name: "John", age: 30, isAdmin: true, extra: 1 }).success).toBe(false);
+
+  expect(() =>
+    // @ts-expect-error second argument is a schema, not a shape
+    z.merge(userSchema, { isAdmin: z.boolean() })
+  ).toThrow("Invalid input to merge");
+});
+
+test("z.safeExtend", () => {
+  const extended = z.safeExtend(userSchema, { name: z.string() });
+  expect(z.safeParse(extended, { name: "John", age: 30 }).success).toBe(true);
+  type Extended = z.infer<typeof extended>;
+  expectTypeOf<Extended>().toEqualTypeOf<{ name: string; age: number; email?: string | undefined }>();
+  // @ts-expect-error
+  z.safeExtend(userSchema, { name: z.number() });
+});
+
+test("z.pick", () => {
+  const pickedSchema = z.pick(userSchema, { name: true, email: true });
+  type PickedUser = z.infer<typeof pickedSchema>;
+  expectTypeOf<PickedUser>().toEqualTypeOf<{ name: string; email?: string | undefined }>();
+  expect(pickedSchema).toBeDefined();
+  expect(z.safeParse(pickedSchema, { name: "John", email: "john@example.com" }).success).toBe(true);
+});
+
+test("z.omit", () => {
+  const omittedSchema = z.omit(userSchema, { age: true });
+  type OmittedUser = z.infer<typeof omittedSchema>;
+  expectTypeOf<OmittedUser>().toEqualTypeOf<{
+    name: string;
+    email?: string | undefined;
+  }>();
+  expect(omittedSchema).toBeDefined();
+  expect(Reflect.ownKeys(omittedSchema._yatsp.def.shape)).toEqual(["name", "email"]);
+  expect(z.safeParse(omittedSchema, { name: "John", email: "john@example.com" }).success).toBe(true);
+});
+
+test("z.partial", () => {
+  const partialSchema = z.partial(userSchema);
+  type PartialUser = z.infer<typeof partialSchema>;
+  expectTypeOf<PartialUser>().toEqualTypeOf<{
+    name?: string | undefined;
+    age?: number | undefined;
+    email?: string | undefined;
+  }>();
+  expect(z.safeParse(partialSchema, { name: "John" }).success).toBe(true);
+});
+
+test("z.partial with mask", () => {
+  const partialSchemaWithMask = z.partial(userSchema, { name: true });
+  type PartialUserWithMask = z.infer<typeof partialSchemaWithMask>;
+  expectTypeOf<PartialUserWithMask>().toEqualTypeOf<{
+    name?: string | undefined;
+    age: number;
+    email?: string | undefined;
+  }>();
+  expect(z.safeParse(partialSchemaWithMask, { age: 30 }).success).toBe(true);
+  expect(z.safeParse(partialSchemaWithMask, { name: "John" }).success).toBe(false);
+});
+
+test("z.exactPartial", () => {
+  const partialSchema = z.exactPartial(userSchema);
+  type PartialUser = z.infer<typeof partialSchema>;
+  expectTypeOf<PartialUser>().toEqualTypeOf<{
+    name?: string;
+    age?: number;
+    email?: string | undefined;
+  }>();
+  expect(z.safeParse(partialSchema, { name: "John" }).success).toBe(true);
+  expect(z.safeParse(partialSchema, {}).success).toBe(true);
+  expect(z.safeParse(partialSchema, { name: undefined }).success).toBe(false);
+  expect(z.safeParse(partialSchema, { email: undefined }).success).toBe(true);
+});
+
+test("z.exactPartial with mask", () => {
+  const partialSchemaWithMask = z.exactPartial(userSchema, { name: true });
+  type PartialUserWithMask = z.infer<typeof partialSchemaWithMask>;
+  expectTypeOf<PartialUserWithMask>().toEqualTypeOf<{
+    name?: string;
+    age: number;
+    email?: string | undefined;
+  }>();
+  expect(z.safeParse(partialSchemaWithMask, { age: 30 }).success).toBe(true);
+  expect(z.safeParse(partialSchemaWithMask, { age: 30, name: undefined }).success).toBe(false);
+});
+
+test("z.required", () => {
+  const requiredSchema = z.required(userSchema);
+  type RequiredUser = z.infer<typeof requiredSchema>;
+  expectTypeOf<RequiredUser>().toEqualTypeOf<{ name: string; age: number; email: string }>();
+  expect(requiredSchema.shape.email).toBeInstanceOf(z.YatspMiniNonOptional);
+  expect(z.safeParse(requiredSchema, { name: "John", age: 30 }).success).toBe(false);
+  expect(z.safeParse(requiredSchema, { name: "John", age: 30, email: "john@example.com" }).success).toBe(true);
+});
+
+test("z.required with mask", () => {
+  const schema = z.object({ name: z.optional(z.string()), age: z.optional(z.number()) });
+  const requiredSchemaWithMask = z.required(schema, { name: true });
+  type RequiredWithMask = z.infer<typeof requiredSchemaWithMask>;
+  expectTypeOf<RequiredWithMask>().toEqualTypeOf<{ name: string; age?: number | undefined }>();
+  expect(requiredSchemaWithMask.shape.name).toBeInstanceOf(z.YatspMiniNonOptional);
+  expect(requiredSchemaWithMask.shape.age).toBeInstanceOf(z.YatspMiniOptional);
+});
+
+test("z.pick/omit/partial/required - do not allow unknown keys", () => {
+  const schema = z.object({
+    name: z.string(),
+    age: z.number(),
+  });
+
+  // Mixed valid + invalid keys - throws at parse time (lazy evaluation)
+  // @ts-expect-error
+  expect(() => z.parse(z.pick(schema, { name: true, asdf: true }), {})).toThrow();
+  // @ts-expect-error
+  expect(() => z.parse(z.omit(schema, { name: true, asdf: true }), {})).toThrow();
+  // @ts-expect-error
+  expect(() => z.parse(z.partial(schema, { name: true, asdf: true }), {})).toThrow();
+  // @ts-expect-error
+  expect(() => z.parse(z.required(schema, { name: true, asdf: true }), {})).toThrow();
+
+  // Only invalid keys
+  // @ts-expect-error
+  expect(() => z.parse(z.pick(schema, { $unknown: true }), {})).toThrow();
+  // @ts-expect-error
+  expect(() => z.parse(z.omit(schema, { $unknown: true }), {})).toThrow();
+  // @ts-expect-error
+  expect(() => z.parse(z.partial(schema, { $unknown: true }), {})).toThrow();
+  // @ts-expect-error
+  expect(() => z.parse(z.required(schema, { $unknown: true }), {})).toThrow();
+});
+
+test("z.catchall", () => {
+  // z.catchall()
+  const schema = z.catchall(
+    z.object({
+      name: z.string(),
+      // age: z.number(),
+    }),
+    z.string()
+  );
+
+  type schemaIn = z.input<typeof schema>;
+  type schemaOut = z.output<typeof schema>;
+  expectTypeOf<schemaIn>().toEqualTypeOf<{
+    name: string;
+    [key: string]: string;
+  }>();
+
+  expectTypeOf<schemaOut>().toEqualTypeOf<{
+    name: string;
+    [key: string]: string;
+  }>();
+
+  schema.parse({
+    name: "john",
+    age: "30",
+    extra: "extra value",
+  });
+
+  expect(() => schema.parse({ name: "john", age: 30 })).toThrow();
+});

package/src/v4/mini/tests/prototypes.test.ts

@@ -0,0 +1,43 @@
+import { expect, test } from "vitest";
+import * as z from "yatsp/mini";
+
+declare module "yatsp/v4/core" {
+  interface $YatspType {
+    /** @deprecated */
+    _core(): string;
+  }
+}
+
+test("prototype extension", () => {
+  z.core.$YatspType.prototype._core = function () {
+    return "_core";
+  };
+
+  // should pass
+  const result = z.string()._core();
+  expect(result).toBe("_core");
+  // expectTypeOf<typeof result>().toEqualTypeOf<string>();
+
+  // clean up
+  z.YatspMiniType.prototype._core = undefined;
+});
+
+declare module "yatsp/v4/mini" {
+  interface YatspMiniType {
+    /** @deprecated */
+    _mini(): string;
+  }
+}
+
+test("prototype extension", () => {
+  z.YatspMiniType.prototype._mini = function () {
+    return "_mini";
+  };
+
+  // should pass
+  const result = z.string()._mini();
+  expect(result).toBe("_mini");
+
+  // clean up
+  z.YatspMiniType.prototype._mini = undefined;
+});