create-croissant 0.1.30 → 0.1.32

package/template/apps/platform/node_modules/zod/src/v4/classic/tests/transform.test.ts

@@ -1,250 +0,0 @@
-import { expect, expectTypeOf, test } from "vitest";
-import * as z from "zod/v4";
-
-test("transform ctx.addIssue with parse", () => {
-  const strs = ["foo", "bar"];
-  const schema = z.string().transform((data, ctx) => {
-    const i = strs.indexOf(data);
-    if (i === -1) {
-      ctx.addIssue({
-        input: data,
-        code: "custom",
-        message: `${data} is not one of our allowed strings`,
-      });
-    }
-    return data.length;
-  });
-  const result = schema.safeParse("asdf");
-  expect(result.success).toEqual(false);
-  expect(result.error!).toMatchInlineSnapshot(`
-    [ZodError: [
-      {
-        "code": "custom",
-        "message": "asdf is not one of our allowed strings",
-        "path": []
-      }
-    ]]
-  `);
-});
-
-test("transform ctx.addIssue with parseAsync", async () => {
-  const strs = ["foo", "bar"];
-
-  const result = await z
-    .string()
-    .transform(async (data, ctx) => {
-      const i = strs.indexOf(data);
-      if (i === -1) {
-        ctx.addIssue({
-          input: data,
-          code: "custom",
-          message: `${data} is not one of our allowed strings`,
-        });
-      }
-      return data.length;
-    })
-    .safeParseAsync("asdf");
-
-  expect(result).toMatchInlineSnapshot(`
-    {
-      "error": [ZodError: [
-      {
-        "code": "custom",
-        "message": "asdf is not one of our allowed strings",
-        "path": []
-      }
-    ]],
-      "success": false,
-    }
-  `);
-});
-
-test("z.NEVER in transform", () => {
-  const foo = z
-    .number()
-    .optional()
-    .transform((val, ctx) => {
-      if (!val) {
-        ctx.addIssue({
-          input: val,
-          code: z.ZodIssueCode.custom,
-          message: "bad",
-        });
-        return z.NEVER;
-      }
-      return val;
-    });
-  type foo = z.infer<typeof foo>;
-  expectTypeOf<foo>().toEqualTypeOf<number>();
-  const arg = foo.safeParse(undefined);
-  if (!arg.success) {
-    expect(arg.error.issues[0].message).toEqual("bad");
-  }
-});
-
-test("basic transformations", () => {
-  const r1 = z
-    .string()
-    .transform((data) => data.length)
-    .parse("asdf");
-  expect(r1).toEqual(4);
-});
-
-test("coercion", () => {
-  const numToString = z.number().transform((n) => String(n));
-  const data = z
-    .object({
-      id: numToString,
-    })
-    .parse({ id: 5 });
-
-  expect(data).toEqual({ id: "5" });
-});
-
-test("async coercion", async () => {
-  const numToString = z.number().transform(async (n) => String(n));
-  const data = await z
-    .object({
-      id: numToString,
-    })
-    .parseAsync({ id: 5 });
-
-  expect(data).toEqual({ id: "5" });
-});
-
-test("sync coercion async error", async () => {
-  const asyncNumberToString = z.number().transform(async (n) => String(n));
-  expect(() =>
-    z
-      .object({
-        id: asyncNumberToString,
-      })
-      .parse({ id: 5 })
-  ).toThrow();
-  // expect(data).toEqual({ id: '5' });
-});
-
-test("default", () => {
-  const data = z.string().default("asdf").parse(undefined); // => "asdf"
-  expect(data).toEqual("asdf");
-});
-
-test("dynamic default", () => {
-  const data = z
-    .string()
-    .default(() => "string")
-    .parse(undefined); // => "asdf"
-  expect(data).toEqual("string");
-});
-
-test("default when property is null or undefined", () => {
-  const data = z
-    .object({
-      foo: z.boolean().nullable().default(true),
-      bar: z.boolean().default(true),
-    })
-    .parse({ foo: null });
-
-  expect(data).toEqual({ foo: null, bar: true });
-});
-
-test("default with falsy values", () => {
-  const schema = z.object({
-    emptyStr: z.string().default("def"),
-    zero: z.number().default(5),
-    falseBoolean: z.boolean().default(true),
-  });
-  const input = { emptyStr: "", zero: 0, falseBoolean: true };
-  const output = schema.parse(input);
-  // defaults are not supposed to be used
-  expect(output).toEqual(input);
-});
-
-test("object typing", () => {
-  const stringToNumber = z.string().transform((arg) => Number.parseFloat(arg));
-
-  const t1 = z.object({
-    stringToNumber,
-  });
-
-  type t1 = z.input<typeof t1>;
-  type t2 = z.output<typeof t1>;
-
-  expectTypeOf<t1>().toEqualTypeOf<{ stringToNumber: string }>();
-  expectTypeOf<t2>().toEqualTypeOf<{ stringToNumber: number }>();
-});
-
-test("transform method overloads", () => {
-  const t1 = z.string().transform((val) => val.toUpperCase());
-  expect(t1.parse("asdf")).toEqual("ASDF");
-
-  const t2 = z.string().transform((val) => val.length);
-  expect(t2.parse("asdf")).toEqual(4);
-});
-
-test("multiple transformers", () => {
-  const stringToNumber = z.string().transform((arg) => Number.parseFloat(arg));
-
-  const doubler = stringToNumber.transform((val) => {
-    return val * 2;
-  });
-  expect(doubler.parse("5")).toEqual(10);
-});
-
-test("short circuit on dirty", () => {
-  const schema = z
-    .string()
-    .refine(() => false)
-    .transform((val) => val.toUpperCase());
-  const result = schema.safeParse("asdf");
-  expect(result.success).toEqual(false);
-
-  expect(result.error).toMatchInlineSnapshot(`
-    [ZodError: [
-      {
-        "code": "custom",
-        "path": [],
-        "message": "Invalid input"
-      }
-    ]]
-  `);
-
-  const result2 = schema.safeParse(1234);
-  expect(result2.success).toEqual(false);
-  if (!result2.success) {
-    expect(result2.error.issues[0].code).toEqual(z.ZodIssueCode.invalid_type);
-  }
-});
-
-test("async short circuit on dirty", async () => {
-  const schema = z
-    .string()
-    .refine(() => false)
-    .transform((val) => val.toUpperCase());
-  const result = await schema.spa("asdf");
-  expect(result.success).toEqual(false);
-
-  expect(result.error).toMatchInlineSnapshot(`
-    [ZodError: [
-      {
-        "code": "custom",
-        "path": [],
-        "message": "Invalid input"
-      }
-    ]]
-  `);
-
-  const result2 = await schema.spa(1234);
-  expect(result2.success).toEqual(false);
-
-  expect(result2.error).toMatchInlineSnapshot(`
-    [ZodError: [
-      {
-        "expected": "string",
-        "code": "invalid_type",
-        "path": [],
-        "message": "Invalid input: expected string, received number"
-      }
-    ]]
-  `);
-});

package/template/apps/platform/node_modules/zod/src/v4/classic/tests/tuple.test.ts

@@ -1,163 +0,0 @@
-import { expect, expectTypeOf, test } from "vitest";
-import * as z from "zod/v4";
-
-test("successful validation", () => {
-  const testTuple = z.tuple([z.string(), z.number()]);
-  expectTypeOf<typeof testTuple._output>().toEqualTypeOf<[string, number]>();
-
-  const val = testTuple.parse(["asdf", 1234]);
-  expect(val).toEqual(val);
-
-  const r1 = testTuple.safeParse(["asdf", "asdf"]);
-  expect(r1.success).toEqual(false);
-  expect(r1.error!).toMatchInlineSnapshot(`
-    [ZodError: [
-      {
-        "expected": "number",
-        "code": "invalid_type",
-        "path": [
-          1
-        ],
-        "message": "Invalid input: expected number, received string"
-      }
-    ]]
-  `);
-
-  const r2 = testTuple.safeParse(["asdf", 1234, true]);
-  expect(r2.success).toEqual(false);
-  expect(r2.error!).toMatchInlineSnapshot(`
-    [ZodError: [
-      {
-        "origin": "array",
-        "code": "too_big",
-        "maximum": 2,
-        "path": [],
-        "message": "Too big: expected array to have <2 items"
-      }
-    ]]
-  `);
-
-  const r3 = testTuple.safeParse({});
-  expect(r3.success).toEqual(false);
-  expect(r3.error!).toMatchInlineSnapshot(`
-    [ZodError: [
-      {
-        "expected": "tuple",
-        "code": "invalid_type",
-        "path": [],
-        "message": "Invalid input: expected tuple, received object"
-      }
-    ]]
-  `);
-});
-
-test("async validation", async () => {
-  const testTuple = z
-    .tuple([z.string().refine(async () => true), z.number().refine(async () => true)])
-    .refine(async () => true);
-  expectTypeOf<typeof testTuple._output>().toEqualTypeOf<[string, number]>();
-
-  const val = await testTuple.parseAsync(["asdf", 1234]);
-  expect(val).toEqual(val);
-
-  const r1 = await testTuple.safeParseAsync(["asdf", "asdf"]);
-  expect(r1.success).toEqual(false);
-  expect(r1.error!).toMatchInlineSnapshot(`
-    [ZodError: [
-      {
-        "expected": "number",
-        "code": "invalid_type",
-        "path": [
-          1
-        ],
-        "message": "Invalid input: expected number, received string"
-      }
-    ]]
-  `);
-
-  const r2 = await testTuple.safeParseAsync(["asdf", 1234, true]);
-  expect(r2.success).toEqual(false);
-  expect(r2.error!).toMatchInlineSnapshot(`
-    [ZodError: [
-      {
-        "origin": "array",
-        "code": "too_big",
-        "maximum": 2,
-        "path": [],
-        "message": "Too big: expected array to have <2 items"
-      }
-    ]]
-  `);
-
-  const r3 = await testTuple.safeParseAsync({});
-  expect(r3.success).toEqual(false);
-  expect(r3.error!).toMatchInlineSnapshot(`
-    [ZodError: [
-      {
-        "expected": "tuple",
-        "code": "invalid_type",
-        "path": [],
-        "message": "Invalid input: expected tuple, received object"
-      }
-    ]]
-  `);
-});
-
-test("tuple with optional elements", () => {
-  const myTuple = z.tuple([z.string(), z.number().optional(), z.string().optional()]).rest(z.boolean());
-  expectTypeOf<typeof myTuple._output>().toEqualTypeOf<[string, number?, string?, ...boolean[]]>();
-
-  const goodData = [["asdf"], ["asdf", 1234], ["asdf", 1234, "asdf"], ["asdf", 1234, "asdf", true, false, true]];
-  for (const data of goodData) {
-    expect(myTuple.parse(data)).toEqual(data);
-  }
-
-  const badData = [
-    ["asdf", "asdf"],
-    ["asdf", 1234, "asdf", "asdf"],
-    ["asdf", 1234, "asdf", true, false, "asdf"],
-  ];
-  for (const data of badData) {
-    expect(() => myTuple.parse(data)).toThrow();
-  }
-});
-
-test("tuple with optional elements followed by required", () => {
-  const myTuple = z.tuple([z.string(), z.number().optional(), z.string()]).rest(z.boolean());
-  expectTypeOf<typeof myTuple._output>().toEqualTypeOf<[string, number | undefined, string, ...boolean[]]>();
-
-  const goodData = [
-    ["asdf", 1234, "asdf"],
-    ["asdf", 1234, "asdf", true, false, true],
-  ];
-  for (const data of goodData) {
-    expect(myTuple.parse(data)).toEqual(data);
-  }
-
-  const badData = [
-    ["asdf"],
-    ["asdf", 1234],
-    ["asdf", 1234, "asdf", "asdf"],
-    ["asdf", 1234, "asdf", true, false, "asdf"],
-  ];
-  for (const data of badData) {
-    expect(() => myTuple.parse(data)).toThrow();
-  }
-});
-
-test("tuple with rest schema", () => {
-  const myTuple = z.tuple([z.string(), z.number()]).rest(z.boolean());
-  expect(myTuple.parse(["asdf", 1234, true, false, true])).toEqual(["asdf", 1234, true, false, true]);
-
-  expect(myTuple.parse(["asdf", 1234])).toEqual(["asdf", 1234]);
-
-  expect(() => myTuple.parse(["asdf", 1234, "asdf"])).toThrow();
-  type t1 = z.output<typeof myTuple>;
-
-  expectTypeOf<t1>().toEqualTypeOf<[string, number, ...boolean[]]>();
-});
-
-test("sparse array input", () => {
-  const schema = z.tuple([z.string(), z.number()]);
-  expect(() => schema.parse(new Array(2))).toThrow();
-});

package/template/apps/platform/node_modules/zod/src/v4/classic/tests/union.test.ts

@@ -1,94 +0,0 @@
-import { expect, expectTypeOf, test } from "vitest";
-
-import * as z from "zod/v4";
-
-test("function parsing", () => {
-  const schema = z.union([z.string().refine(() => false), z.number().refine(() => false)]);
-  const result = schema.safeParse("asdf");
-  expect(result.success).toEqual(false);
-});
-
-test("union 2", () => {
-  const result = z.union([z.number(), z.string().refine(() => false)]).safeParse("a");
-  expect(result.success).toEqual(false);
-});
-
-test("return valid over invalid", () => {
-  const schema = z.union([
-    z.object({
-      email: z.string().email(),
-    }),
-    z.string(),
-  ]);
-  expect(schema.parse("asdf")).toEqual("asdf");
-  expect(schema.parse({ email: "asdlkjf@lkajsdf.com" })).toEqual({
-    email: "asdlkjf@lkajsdf.com",
-  });
-});
-
-test("return errors from both union arms", () => {
-  const result = z.union([z.number(), z.string().refine(() => false)]).safeParse("a");
-  expect(result.success).toEqual(false);
-  if (!result.success) {
-    expect(result.error.issues).toMatchInlineSnapshot(`
-      [
-        {
-          "code": "invalid_union",
-          "errors": [
-            [
-              {
-                "code": "invalid_type",
-                "expected": "number",
-                "message": "Invalid input: expected number, received string",
-                "path": [],
-              },
-            ],
-            [
-              {
-                "code": "custom",
-                "message": "Invalid input",
-                "path": [],
-              },
-            ],
-          ],
-          "message": "Invalid input",
-          "path": [],
-        },
-      ]
-    `);
-  }
-});
-
-test("options getter", async () => {
-  const union = z.union([z.string(), z.number()]);
-  union.options[0].parse("asdf");
-  union.options[1].parse(1234);
-  await union.options[0].parseAsync("asdf");
-  await union.options[1].parseAsync(1234);
-});
-
-test("readonly union", async () => {
-  const options = [z.string(), z.number()] as const;
-  const union = z.union(options);
-  union.parse("asdf");
-  union.parse(12);
-});
-
-test("union inferred types", () => {
-  const test = z.object({}).or(z.array(z.object({})));
-
-  type Test = z.output<typeof test>; // <— any
-  expectTypeOf<Test>().toEqualTypeOf<Record<string, never> | Array<Record<string, never>>>();
-});
-
-test("union values", () => {
-  const schema = z.union([z.literal("a"), z.literal("b"), z.literal("c")]);
-
-  expect(schema._zod.values).toMatchInlineSnapshot(`
-    Set {
-      "a",
-      "b",
-      "c",
-    }
-  `);
-});