@vitos-pizza/vitos-pizza 0.2.0 → 0.3.1

package/packages/permission-system/node_modules/zod/src/v4/classic/tests/catch.test.ts

@@ -1,252 +0,0 @@
-import { expect, expectTypeOf, test } from "vitest";
-import { z } from "zod/v4";
-import type { util } from "zod/v4/core";
-
-test("basic catch", () => {
-  expect(z.string().catch("default").parse(undefined)).toBe("default");
-});
-
-test("catch fn does not run when parsing succeeds", () => {
-  let isCalled = false;
-  const cb = () => {
-    isCalled = true;
-    return "asdf";
-  };
-  expect(z.string().catch(cb).parse("test")).toBe("test");
-  expect(isCalled).toEqual(false);
-});
-
-test("basic catch async", async () => {
-  const result = await z.string().catch("default").parseAsync(1243);
-  expect(result).toBe("default");
-});
-
-test("catch replace wrong types", () => {
-  expect(z.string().catch("default").parse(true)).toBe("default");
-  expect(z.string().catch("default").parse(true)).toBe("default");
-  expect(z.string().catch("default").parse(15)).toBe("default");
-  expect(z.string().catch("default").parse([])).toBe("default");
-  expect(z.string().catch("default").parse(new Map())).toBe("default");
-  expect(z.string().catch("default").parse(new Set())).toBe("default");
-  expect(z.string().catch("default").parse({})).toBe("default");
-});
-
-test("catch with transform", () => {
-  const stringWithDefault = z
-    .string()
-    .transform((val) => val.toUpperCase())
-    .catch("default");
-
-  expect(stringWithDefault.parse(undefined)).toBe("default");
-  expect(stringWithDefault.parse(15)).toBe("default");
-  expect(stringWithDefault).toBeInstanceOf(z.ZodCatch);
-  expect(stringWithDefault.unwrap()).toBeInstanceOf(z.ZodPipe);
-  expect(stringWithDefault.unwrap().in).toBeInstanceOf(z.ZodString);
-  expect(stringWithDefault.unwrap().out).toBeInstanceOf(z.ZodTransform);
-
-  type inp = z.input<typeof stringWithDefault>;
-  expectTypeOf<inp>().toEqualTypeOf<string | util.Whatever>();
-  type out = z.output<typeof stringWithDefault>;
-  expectTypeOf<out>().toEqualTypeOf<string>();
-});
-
-test("catch on existing optional", () => {
-  const stringWithDefault = z.string().optional().catch("asdf");
-  expect(stringWithDefault.parse(undefined)).toBe(undefined);
-  expect(stringWithDefault.parse(15)).toBe("asdf");
-  expect(stringWithDefault).toBeInstanceOf(z.ZodCatch);
-  expect(stringWithDefault.unwrap()).toBeInstanceOf(z.ZodOptional);
-  expect(stringWithDefault.unwrap().unwrap()).toBeInstanceOf(z.ZodString);
-
-  type inp = z.input<typeof stringWithDefault>;
-  expectTypeOf<inp>().toEqualTypeOf<string | undefined | util.Whatever>();
-  type out = z.output<typeof stringWithDefault>;
-  expectTypeOf<out>().toEqualTypeOf<string | undefined>();
-});
-
-test("optional on catch", () => {
-  const stringWithDefault = z.string().catch("asdf").optional();
-
-  type inp = z.input<typeof stringWithDefault>;
-  expectTypeOf<inp>().toEqualTypeOf<string | util.Whatever>();
-  type out = z.output<typeof stringWithDefault>;
-  expectTypeOf<out>().toEqualTypeOf<string | undefined>();
-});
-
-test("complex chain example", () => {
-  const complex = z
-    .string()
-    .catch("asdf")
-    .transform((val) => `${val}!`)
-    .transform((val) => val.toUpperCase())
-    .catch("qwer")
-    .unwrap()
-    .optional()
-    .catch("asdfasdf");
-
-  expect(complex.parse("qwer")).toBe("QWER!");
-  expect(complex.parse(15)).toBe("ASDF!");
-  expect(complex.parse(true)).toBe("ASDF!");
-});
-
-test("removeCatch", () => {
-  const stringWithRemovedDefault = z.string().catch("asdf").unwrap();
-
-  type out = z.output<typeof stringWithRemovedDefault>;
-  expectTypeOf<out>().toEqualTypeOf<string>();
-});
-
-test("nested", () => {
-  const inner = z.string().catch("asdf");
-  const outer = z.object({ inner }).catch({
-    inner: "asdf",
-  });
-  type input = z.input<typeof outer>;
-  expectTypeOf<input>().toEqualTypeOf<{ inner: string | util.Whatever } | util.Whatever>();
-  type out = z.output<typeof outer>;
-
-  expectTypeOf<out>().toEqualTypeOf<{ inner: string }>();
-  expect(outer.parse(undefined)).toEqual({ inner: "asdf" });
-  expect(outer.parse({})).toEqual({ inner: "asdf" });
-  expect(outer.parse({ inner: undefined })).toEqual({ inner: "asdf" });
-});
-
-test("chained catch", () => {
-  const stringWithDefault = z.string().catch("inner").catch("outer");
-  const result = stringWithDefault.parse(undefined);
-  expect(result).toEqual("inner");
-  const resultDiff = stringWithDefault.parse(5);
-  expect(resultDiff).toEqual("inner");
-});
-
-test("native enum", () => {
-  enum Fruits {
-    apple = "apple",
-    orange = "orange",
-  }
-
-  const schema = z.object({
-    fruit: z.nativeEnum(Fruits).catch(Fruits.apple),
-  });
-
-  expect(schema.parse({})).toEqual({ fruit: Fruits.apple });
-  expect(schema.parse({ fruit: 15 })).toEqual({ fruit: Fruits.apple });
-});
-
-test("enum", () => {
-  const schema = z.object({
-    fruit: z.enum(["apple", "orange"]).catch("apple"),
-  });
-
-  expect(schema.parse({})).toEqual({ fruit: "apple" });
-  expect(schema.parse({ fruit: true })).toEqual({ fruit: "apple" });
-  expect(schema.parse({ fruit: 15 })).toEqual({ fruit: "apple" });
-});
-
-test("reported issues with nested usage", () => {
-  const schema = z.object({
-    string: z.string(),
-    obj: z.object({
-      sub: z.object({
-        lit: z.literal("a"),
-        subCatch: z.number().catch(23),
-      }),
-      midCatch: z.number().catch(42),
-    }),
-    number: z.number().catch(0),
-    bool: z.boolean(),
-  });
-
-  try {
-    schema.parse({
-      string: {},
-      obj: {
-        sub: {
-          lit: "b",
-          subCatch: "24",
-        },
-        midCatch: 444,
-      },
-      number: "",
-      bool: "yes",
-    });
-  } catch (error) {
-    const issues = (error as z.ZodError).issues;
-
-    expect(issues.length).toEqual(3);
-    expect(issues).toMatchInlineSnapshot(`
-      [
-        {
-          "code": "invalid_type",
-          "expected": "string",
-          "message": "Invalid input: expected string, received object",
-          "path": [
-            "string",
-          ],
-        },
-        {
-          "code": "invalid_value",
-          "message": "Invalid input: expected "a"",
-          "path": [
-            "obj",
-            "sub",
-            "lit",
-          ],
-          "values": [
-            "a",
-          ],
-        },
-        {
-          "code": "invalid_type",
-          "expected": "boolean",
-          "message": "Invalid input: expected boolean, received string",
-          "path": [
-            "bool",
-          ],
-        },
-      ]
-    `);
-    // expect(issues[0].message).toMatch("string");
-    // expect(issues[1].message).toMatch("literal");
-    // expect(issues[2].message).toMatch("boolean");
-  }
-});
-
-test("catch error", () => {
-  const schema = z.object({
-    age: z.number(),
-    name: z.string().catch((ctx) => {
-      ctx.issues;
-      // issues = ctx.issues;
-
-      return "John Doe";
-    }),
-  });
-
-  const result = schema.safeParse({
-    age: null,
-    name: null,
-  });
-
-  expect(result.success).toEqual(false);
-  expect(result.error!).toMatchInlineSnapshot(`
-    [ZodError: [
-      {
-        "expected": "number",
-        "code": "invalid_type",
-        "path": [
-          "age"
-        ],
-        "message": "Invalid input: expected number, received null"
-      }
-    ]]
-  `);
-});
-
-test("ctx.input", () => {
-  const schema = z.string().catch((ctx) => {
-    return String(ctx.input);
-  });
-
-  expect(schema.parse(123)).toEqual("123");
-});

package/packages/permission-system/node_modules/zod/src/v4/classic/tests/coalesce.test.ts

@@ -1,20 +0,0 @@
-import { expect, test } from "vitest";
-
-test("coalesce", () => {
-  expect(true).toBe(true);
-});
-
-// test("nonoptional with default", () => {
-//   const schema = z.string().optional().coalesce("hi");
-//   expectTypeOf<typeof schema._input>().toEqualTypeOf<string | undefined>();
-//   expectTypeOf<typeof schema._output>().toEqualTypeOf<string>();
-//   expect(schema.parse(undefined)).toBe("hi");
-// });
-
-// test("nonoptional in object", () => {
-//   const schema = z.object({ hi: z.string().optional().nonoptional("hi") });
-
-//   expectTypeOf<typeof schema._input>().toEqualTypeOf<{ hi: string | undefined }>();
-//   expectTypeOf<typeof schema._output>().toEqualTypeOf<{ hi: string }>();
-//   expect(schema.parse(undefined)).toBe("hi");
-// });

package/packages/permission-system/node_modules/zod/src/v4/classic/tests/coerce.test.ts

@@ -1,160 +0,0 @@
-import { expect, expectTypeOf, test } from "vitest";
-
-import * as z from "zod/v4";
-
-test("string coercion", () => {
-  const schema = z.coerce.string();
-  expect(schema.parse("sup")).toEqual("sup");
-  expect(schema.parse("")).toEqual("");
-  expect(schema.parse(12)).toEqual("12");
-  expect(schema.parse(0)).toEqual("0");
-  expect(schema.parse(-12)).toEqual("-12");
-  expect(schema.parse(3.14)).toEqual("3.14");
-  expect(schema.parse(BigInt(15))).toEqual("15");
-  expect(schema.parse(Number.NaN)).toEqual("NaN");
-  expect(schema.parse(Number.POSITIVE_INFINITY)).toEqual("Infinity");
-  expect(schema.parse(Number.NEGATIVE_INFINITY)).toEqual("-Infinity");
-  expect(schema.parse(true)).toEqual("true");
-  expect(schema.parse(false)).toEqual("false");
-  expect(schema.parse(null)).toEqual("null");
-  expect(schema.parse(undefined)).toEqual("undefined");
-  expect(schema.parse({ hello: "world!" })).toEqual("[object Object]");
-  expect(schema.parse(["item", "another_item"])).toEqual("item,another_item");
-  expect(schema.parse([])).toEqual("");
-  expect(schema.parse(new Date("2022-01-01T00:00:00.000Z"))).toEqual(new Date("2022-01-01T00:00:00.000Z").toString());
-});
-
-test("number coercion", () => {
-  const schema = z.coerce.number();
-  expect(schema.parse("12")).toEqual(12);
-  expect(schema.parse("0")).toEqual(0);
-  expect(schema.parse("-12")).toEqual(-12);
-  expect(schema.parse("3.14")).toEqual(3.14);
-  expect(schema.parse("")).toEqual(0);
-  expect(() => schema.parse("NOT_A_NUMBER")).toThrow(); // z.ZodError
-  expect(schema.parse(12)).toEqual(12);
-  expect(schema.parse(0)).toEqual(0);
-  expect(schema.parse(-12)).toEqual(-12);
-  expect(schema.parse(3.14)).toEqual(3.14);
-  expect(schema.parse(BigInt(15))).toEqual(15);
-  expect(() => schema.parse(Number.NaN)).toThrow(); // z.ZodError
-  // expect(schema.parse(Number.POSITIVE_INFINITY)).toEqual(Number.POSITIVE_INFINITY);
-  // expect(schema.parse(Number.NEGATIVE_INFINITY)).toEqual(Number.NEGATIVE_INFINITY);
-  expect(schema.parse(true)).toEqual(1);
-  expect(schema.parse(false)).toEqual(0);
-  expect(schema.parse(null)).toEqual(0);
-  expect(() => schema.parse(undefined)).toThrow(); // z.ZodError
-  expect(() => schema.parse({ hello: "world!" })).toThrow(); // z.ZodError
-  expect(() => schema.parse(["item", "another_item"])).toThrow(); // z.ZodError
-  expect(schema.parse([])).toEqual(0);
-  expect(schema.parse(new Date(1670139203496))).toEqual(1670139203496);
-});
-
-test("boolean coercion", () => {
-  const schema = z.coerce.boolean();
-  expect(schema.parse("true")).toEqual(true);
-  expect(schema.parse("false")).toEqual(true);
-  expect(schema.parse("0")).toEqual(true);
-  expect(schema.parse("1")).toEqual(true);
-  expect(schema.parse("")).toEqual(false);
-  expect(schema.parse(1)).toEqual(true);
-  expect(schema.parse(0)).toEqual(false);
-  expect(schema.parse(-1)).toEqual(true);
-  expect(schema.parse(3.14)).toEqual(true);
-  expect(schema.parse(BigInt(15))).toEqual(true);
-  expect(schema.parse(Number.NaN)).toEqual(false);
-  expect(schema.parse(Number.POSITIVE_INFINITY)).toEqual(true);
-  expect(schema.parse(Number.NEGATIVE_INFINITY)).toEqual(true);
-  expect(schema.parse(true)).toEqual(true);
-  expect(schema.parse(false)).toEqual(false);
-  expect(schema.parse(null)).toEqual(false);
-  expect(schema.parse(undefined)).toEqual(false);
-  expect(schema.parse({ hello: "world!" })).toEqual(true);
-  expect(schema.parse(["item", "another_item"])).toEqual(true);
-  expect(schema.parse([])).toEqual(true);
-  expect(schema.parse(new Date(1670139203496))).toEqual(true);
-});
-
-test("bigint coercion", () => {
-  const schema = z.coerce.bigint();
-  expect(schema.parse("5")).toEqual(BigInt(5));
-  expect(schema.parse("0")).toEqual(BigInt(0));
-  expect(schema.parse("-5")).toEqual(BigInt(-5));
-  expect(() => schema.parse("3.14")).toThrow(); // not a z.ZodError!
-  expect(schema.parse("")).toEqual(BigInt(0));
-  expect(() => schema.parse("NOT_A_NUMBER")).toThrow(); // not a z.ZodError!
-  expect(schema.parse(5)).toEqual(BigInt(5));
-  expect(schema.parse(0)).toEqual(BigInt(0));
-  expect(schema.parse(-5)).toEqual(BigInt(-5));
-  expect(() => schema.parse(3.14)).toThrow(); // not a z.ZodError!
-  expect(schema.parse(BigInt(5))).toEqual(BigInt(5));
-  expect(() => schema.parse(Number.NaN)).toThrow(); // not a z.ZodError!
-  expect(() => schema.parse(Number.POSITIVE_INFINITY)).toThrow(); // not a z.ZodError!
-  expect(() => schema.parse(Number.NEGATIVE_INFINITY)).toThrow(); // not a z.ZodError!
-  expect(schema.parse(true)).toEqual(BigInt(1));
-  expect(schema.parse(false)).toEqual(BigInt(0));
-  expect(() => schema.parse(null)).toThrow(); // not a z.ZodError!
-  expect(() => schema.parse(undefined)).toThrow(); // not a z.ZodError!
-  expect(() => schema.parse({ hello: "world!" })).toThrow(); // not a z.ZodError!
-  expect(() => schema.parse(["item", "another_item"])).toThrow(); // not a z.ZodError!
-  expect(schema.parse([])).toEqual(BigInt(0));
-  expect(schema.parse(new Date(1670139203496))).toEqual(BigInt(1670139203496));
-});
-
-test("date coercion", () => {
-  const schema = z.coerce.date();
-  expect(schema.parse(new Date().toDateString())).toBeInstanceOf(Date);
-  expect(schema.parse(new Date().toISOString())).toBeInstanceOf(Date);
-  expect(schema.parse(new Date().toUTCString())).toBeInstanceOf(Date);
-  expect(schema.parse("5")).toBeInstanceOf(Date);
-  expect(schema.parse("2000-01-01")).toBeInstanceOf(Date);
-  // expect(schema.parse("0")).toBeInstanceOf(Date);
-  // expect(schema.parse("-5")).toBeInstanceOf(Date);
-  // expect(schema.parse("3.14")).toBeInstanceOf(Date);
-  expect(() => schema.parse("")).toThrow(); // z.ZodError
-  expect(() => schema.parse("NOT_A_DATE")).toThrow(); // z.ZodError
-  expect(schema.parse(5)).toBeInstanceOf(Date);
-  expect(schema.parse(0)).toBeInstanceOf(Date);
-  expect(schema.parse(-5)).toBeInstanceOf(Date);
-  expect(schema.parse(3.14)).toBeInstanceOf(Date);
-  expect(() => schema.parse(BigInt(5))).toThrow(); // not a z.ZodError!
-  expect(() => schema.parse(Number.NaN)).toThrow(); // z.ZodError
-  expect(() => schema.parse(Number.POSITIVE_INFINITY)).toThrow(); // z.ZodError
-  expect(() => schema.parse(Number.NEGATIVE_INFINITY)).toThrow(); // z.ZodError
-  expect(schema.parse(true)).toBeInstanceOf(Date);
-  expect(schema.parse(false)).toBeInstanceOf(Date);
-  expect(schema.parse(null)).toBeInstanceOf(Date);
-  expect(() => schema.parse(undefined)).toThrow(); // z.ZodError
-  expect(() => schema.parse({ hello: "world!" })).toThrow(); // z.ZodError
-  expect(() => schema.parse(["item", "another_item"])).toThrow(); // z.ZodError
-  expect(() => schema.parse([])).toThrow(); // z.ZodError
-  expect(schema.parse(new Date())).toBeInstanceOf(Date);
-});
-
-// test("template literal coercion", () => {
-//   const schema = z.coerce
-//     .templateLiteral()
-//     .interpolated(z.number().finite())
-//     .interpolated(
-//       z.enum(["px", "em", "rem", "vh", "vw", "vmin", "vmax"]).optional()
-//     );
-//   expect(schema.parse(300)).toEqual("300");
-//   expect(schema.parse(BigInt(300))).toEqual("300");
-//   expect(schema.parse("300")).toEqual("300");
-//   expect(schema.parse("300px")).toEqual("300px");
-//   expect(schema.parse("300em")).toEqual("300em");
-//   expect(schema.parse("300rem")).toEqual("300rem");
-//   expect(schema.parse("300vh")).toEqual("300vh");
-//   expect(schema.parse("300vw")).toEqual("300vw");
-//   expect(schema.parse("300vmin")).toEqual("300vmin");
-//   expect(schema.parse("300vmax")).toEqual("300vmax");
-//   expect(schema.parse(["300px"])).toEqual("300px");
-// });
-
-test("override input type", () => {
-  const a = z.coerce.string<any>();
-  type input = z.input<typeof a>;
-  expectTypeOf<input>().toEqualTypeOf<any>();
-  type output = z.infer<typeof a>;
-  expectTypeOf<output>().toEqualTypeOf<string>();
-});