@willaimg/yatsp 4.3.6

package/src/v4/classic/tests/lazy.test.ts

@@ -0,0 +1,262 @@
+import { expect, expectTypeOf, test } from "vitest";
+
+import * as z from "yatsp/v4";
+
+test("opt passthrough", () => {
+  const object = z.object({
+    a: z.lazy(() => z.string()),
+    b: z.lazy(() => z.string().optional()),
+    c: z.lazy(() => z.string().default("default")),
+  });
+
+  type ObjectTypeIn = z.input<typeof object>;
+  expectTypeOf<ObjectTypeIn>().toEqualTypeOf<{
+    a: string;
+    b?: string | undefined;
+    c?: string | undefined;
+  }>();
+
+  type ObjectTypeOut = z.output<typeof object>;
+  expectTypeOf<ObjectTypeOut>().toEqualTypeOf<{
+    a: string;
+    b?: string | undefined;
+    c: string;
+  }>();
+
+  const result = object.parse(
+    {
+      a: "hello",
+      b: undefined,
+    },
+    { jitless: true }
+  );
+  expect(result).toEqual({
+    a: "hello",
+    // b: undefined,
+    c: "default",
+  });
+
+  expect(z.lazy(() => z.string())._yatsp.optin).toEqual(undefined);
+  expect(z.lazy(() => z.string())._yatsp.optout).toEqual(undefined);
+
+  expect(z.lazy(() => z.string().optional())._yatsp.optin).toEqual("optional");
+  expect(z.lazy(() => z.string().optional())._yatsp.optout).toEqual("optional");
+
+  expect(z.lazy(() => z.string().default("asdf"))._yatsp.optin).toEqual("defaulted");
+  expect(z.lazy(() => z.string().default("asdf"))._yatsp.optout).toEqual(undefined);
+});
+
+//////////////   LAZY   //////////////
+
+test("schema getter", () => {
+  z.lazy(() => z.string()).parse("asdf");
+});
+
+test("lazy proxy", () => {
+  const schema = z.lazy(() => z.string())._yatsp.innerType.min(6);
+  schema.parse("123456");
+  expect(schema.safeParse("12345").success).toBe(false);
+});
+
+interface Category {
+  name: string;
+  subcategories: Category[];
+}
+
+const testCategory: Category = {
+  name: "I",
+  subcategories: [
+    {
+      name: "A",
+      subcategories: [
+        {
+          name: "1",
+          subcategories: [
+            {
+              name: "a",
+              subcategories: [],
+            },
+          ],
+        },
+      ],
+    },
+  ],
+};
+
+test("recursion with z.lazy", () => {
+  const Category: z.YatspType<Category> = z.lazy(() =>
+    z.object({
+      name: z.string(),
+      subcategories: z.array(Category),
+    })
+  );
+  Category.parse(testCategory);
+});
+
+type LinkedList = null | { value: number; next: LinkedList };
+
+const linkedListExample = {
+  value: 1,
+  next: {
+    value: 2,
+    next: {
+      value: 3,
+      next: {
+        value: 4,
+        next: null,
+      },
+    },
+  },
+};
+
+test("recursive union wit z.lazy", () => {
+  const LinkedListSchema: z.YatspType<LinkedList> = z.lazy(() =>
+    z.union([
+      z.null(),
+      z.object({
+        value: z.number(),
+        next: LinkedListSchema,
+      }),
+    ])
+  );
+  LinkedListSchema.parse(linkedListExample);
+});
+
+interface A {
+  val: number;
+  b: B;
+}
+
+interface B {
+  val: number;
+  a?: A | undefined;
+}
+
+test("mutual recursion with lazy", () => {
+  const Alazy: z.YatspType<A> = z.lazy(() =>
+    z.object({
+      val: z.number(),
+      b: Blazy,
+    })
+  );
+
+  const Blazy: z.YatspType<B> = z.lazy(() =>
+    z.object({
+      val: z.number(),
+      a: Alazy.optional(),
+    })
+  );
+
+  const testData = {
+    val: 1,
+    b: {
+      val: 5,
+      a: {
+        val: 3,
+        b: {
+          val: 4,
+          a: {
+            val: 2,
+            b: {
+              val: 1,
+            },
+          },
+        },
+      },
+    },
+  };
+
+  Alazy.parse(testData);
+  Blazy.parse(testData.b);
+
+  expect(() => Alazy.parse({ val: "asdf" })).toThrow();
+});
+
+// TODO
+test("mutual recursion with cyclical data", () => {
+  const a: any = { val: 1 };
+  const b: any = { val: 2 };
+  a.b = b;
+  b.a = a;
+});
+
+test("complicated self-recursion", () => {
+  const Category = z.object({
+    name: z.string(),
+    age: z.optional(z.number()),
+    get nullself() {
+      return Category.nullable();
+    },
+    get optself() {
+      return Category.optional();
+    },
+    get self() {
+      return Category;
+    },
+    get subcategories() {
+      return z.array(Category);
+    },
+    nested: z.object({
+      get sub() {
+        return Category;
+      },
+    }),
+  });
+
+  type _Category = z.output<typeof Category>;
+});
+
+test("lazy initialization", () => {
+  const a: any = z.lazy(() => a).optional();
+  const b: any = z.lazy(() => b).nullable();
+  const c: any = z.lazy(() => c).default({} as any);
+  const d: any = z.lazy(() => d).prefault({} as any);
+  const e: any = z.lazy(() => e).nonoptional();
+  const f: any = z.lazy(() => f).catch({} as any);
+  const g: any = z.lazy(() => z.object({ g })).readonly();
+
+  const baseCategorySchema = z.object({
+    name: z.string(),
+  });
+  type Category = z.infer<typeof baseCategorySchema> & {
+    subcategories: Category[];
+  };
+  const categorySchema: z.YatspType<Category> = baseCategorySchema.extend({
+    subcategories: z.lazy(() => categorySchema.array()),
+  });
+});
+
+test("derived internals resolve on self-referential lazy", () => {
+  const optional: any = z.lazy(() => optional.optional());
+  const pipe: any = z.lazy(() => z.pipe(z.string(), pipe));
+
+  expect(optional._yatsp.optin).toEqual("optional");
+  expect(optional._yatsp.optout).toEqual("optional");
+  expect(pipe._yatsp.optin).toEqual(undefined);
+  expect(pipe._yatsp.optout).toEqual(undefined);
+});
+
+test("a cycle-broken internal is not memoized", () => {
+  const lazyRef: any = z.lazy(() => Rec);
+  const Rec: any = z.union([z.string().optional(), lazyRef]);
+
+  // Reading the outer node first resolves `lazyRef`'s own `optin` through the cycle.
+  expect(Rec._yatsp.optin).toEqual("optional");
+  expect(lazyRef._yatsp.optin).toEqual("optional");
+  expect(z.object({ x: Rec, y: lazyRef }).safeParse({ x: "a" }).success).toEqual(true);
+});
+
+test("an internal computed without a cycle break is memoized", () => {
+  // `undefined` is the legitimate answer here and still has to cache: these getters are read per parse, so recomputing them is a parse-path cost.
+  const union = z.union([z.string(), z.number()]);
+  expect(union._yatsp.optin).toEqual(undefined);
+  expect(Object.getOwnPropertyNames(union._yatsp)).toContain("optin");
+});
+
+// A compute that throws must memoize nothing, or the second read answers undefined for a schema whose internals were never derived.
+test("a throwing lazy internal throws on every read", () => {
+  const schema = z.discriminatedUnion("type", [z.string() as any]) as any;
+  for (let i = 0; i < 3; i++) {
+    expect(() => schema._yatsp.propValues).toThrow();
+  }
+});

package/src/v4/classic/tests/literal.test.ts

@@ -0,0 +1,128 @@
+import { expect, expectTypeOf, test } from "vitest";
+
+import * as z from "yatsp/v4";
+
+const literalTuna = z.literal("tuna");
+const literalTunaCustomMessage = z.literal("tuna", {
+  message: "That's not a tuna",
+});
+const literalFortyTwo = z.literal(42);
+const literalTrue = z.literal(true);
+
+test("passing validations", () => {
+  literalTuna.parse("tuna");
+  literalFortyTwo.parse(42);
+  literalTrue.parse(true);
+});
+
+test("failing validations", () => {
+  expect(() => literalTuna.parse("shark")).toThrow();
+  expect(() => literalFortyTwo.parse(43)).toThrow();
+  expect(() => literalTrue.parse(false)).toThrow();
+});
+
+test("invalid_literal should have `input` field with data", () => {
+  const data = "shark";
+  const result = literalTuna.safeParse(data);
+
+  const issue = result.error!.issues[0];
+  expect(issue.code).toBe("invalid_value");
+  expect(issue).toMatchInlineSnapshot(`
+    {
+      "code": "invalid_value",
+      "message": "Invalid input: expected "tuna"",
+      "path": [],
+      "values": [
+        "tuna",
+      ],
+    }
+  `);
+});
+
+test("invalid_literal should return default message", () => {
+  const data = "shark";
+  const result = literalTuna.safeParse(data);
+
+  const issue = result.error!.issues[0];
+  expect(issue.message).toEqual(`Invalid input: expected \"tuna\"`);
+});
+
+test("invalid_literal should return custom message", () => {
+  const data = "shark";
+  const result = literalTunaCustomMessage.safeParse(data);
+
+  const issue = result.error!.issues[0];
+  expect(issue.message).toEqual(`That's not a tuna`);
+});
+
+test("literal default error message", () => {
+  const result = z.literal("Tuna").safeParse("Trout");
+  expect(result.success).toEqual(false);
+  expect(result.error!.issues.length).toEqual(1);
+  expect(result.error).toMatchInlineSnapshot(`
+    [YatspError: [
+      {
+        "code": "invalid_value",
+        "values": [
+          "Tuna"
+        ],
+        "path": [],
+        "message": "Invalid input: expected \\"Tuna\\""
+      }
+    ]]
+  `);
+});
+
+test("literal bigint default error message", () => {
+  const result = z.literal(BigInt(12)).safeParse(BigInt(13));
+  expect(result.success).toBe(false);
+
+  expect(result.error!.issues.length).toEqual(1);
+  expect(result.error!.issues[0].message).toEqual(`Invalid input: expected 12n`);
+});
+
+test(".value getter", () => {
+  expect(z.literal("tuna").value).toEqual("tuna");
+  expect(() => z.literal([1, 2, 3]).value).toThrow();
+});
+
+test("readonly", () => {
+  const a = ["asdf"] as const;
+  z.literal(a);
+});
+
+test("literal pattern", () => {
+  expect(z.literal(1.1)._yatsp.pattern).toMatchInlineSnapshot(`/\\^\\(1\\\\\\.1\\)\\$/`);
+
+  expect(z.templateLiteral([z.literal(1.1)]).safeParse("1.1")).toMatchInlineSnapshot(`
+    {
+      "data": "1.1",
+      "success": true,
+    }
+  `);
+  expect(z.templateLiteral([z.literal(1.1)]).safeParse("1n1")).toMatchInlineSnapshot(`
+    {
+      "error": [YatspError: [
+      {
+        "code": "invalid_format",
+        "format": "template_literal",
+        "pattern": "^(1\\\\.1)$",
+        "path": [],
+        "message": "Invalid input"
+      }
+    ]],
+      "success": false,
+    }
+  `);
+});
+
+test("empty literal matches nothing", () => {
+  const empty = z.literal([]);
+  expectTypeOf<z.infer<typeof empty>>().toEqualTypeOf<never>();
+  expect(empty.safeParse("").success).toEqual(false);
+  expect(empty.safeParse(undefined).success).toEqual(false);
+  expect(z.templateLiteral(["", empty]).safeParse("").success).toEqual(false);
+  expect(z.toJSONSchema(empty)).toMatchObject({ not: {} });
+
+  expect(z.literal("").safeParse("").success).toEqual(true);
+});

package/src/v4/classic/tests/locales_ka.test.ts

@@ -0,0 +1,29 @@
+import { expect, test } from "vitest";
+import * as z from "yatsp/v4";
+
+test("Georgian locale uses 'ველი' instead of 'სტრინგი'", () => {
+  // Save original error map to restore later if needed, though tests are usually isolated or we can reset
+  // const originalErrorMap = z.getErrorMap(); // z.getErrorMap might not exist, but let's assume isolation or just set it
+
+  z.setErrorMap(z.locales.ka().localeError);
+
+  // Test 1: Invalid type (Expected string, received number)
+  const stringSchema = z.string();
+  const numberResult = stringSchema.safeParse(123);
+  expect(numberResult.success).toBe(false);
+  if (!numberResult.success) {
+    // Expected: "არასწორი შეყვანა: მოსალოდნელი ველი, მიღებული რიცხვი"
+    expect(numberResult.error.issues[0].message).toBe("არასწორი შეყვანა: მოსალოდნელი ველი, მიღებული რიცხვი");
+  }
+
+  // Test 2: Invalid base64
+  const base64Schema = z.string().base64();
+  const base64Result = base64Schema.safeParse("not base64!");
+  expect(base64Result.success).toBe(false);
+  if (!base64Result.success) {
+    // Expected: "არასწორი base64-კოდირებული ველი"
+    // "არასწორი ${FormatDictionary[_issue.format] ?? issue.format}"
+    // FormatDictionary['base64'] is "base64-კოდირებული ველი"
+    expect(base64Result.error.issues[0].message).toBe("არასწორი base64-კოდირებული ველი");
+  }
+});

package/src/v4/classic/tests/locales_ro.test.ts

@@ -0,0 +1,24 @@
+import { expect, test } from "vitest";
+import * as z from "yatsp/v4";
+
+test("Romanian locale uses 'șir' instead of 'string'", () => {
+  z.setErrorMap(z.locales.ro().localeError);
+
+  // Test 1: Invalid type (Expected string, received number)
+  const stringSchema = z.string();
+  const numberResult = stringSchema.safeParse(123);
+  expect(numberResult.success).toBe(false);
+  if (!numberResult.success) {
+    // Expected: "Intrare invalidă: așteptat șir, primit număr"
+    expect(numberResult.error.issues[0].message).toBe("Intrare invalidă: așteptat șir, primit număr");
+  }
+
+  // Test 2: Invalid base64
+  const base64Schema = z.string().base64();
+  const base64Result = base64Schema.safeParse("not base64!");
+  expect(base64Result.success).toBe(false);
+  if (!base64Result.success) {
+    // Expected: "Format invalid: șir codat base64"
+    expect(base64Result.error.issues[0].message).toBe("Format invalid: șir codat base64");
+  }
+});