@psiclawops/hypermem 0.9.0 → 0.9.1

package/node_modules/zod/src/v3/tests/default.test.ts

@@ -1,112 +0,0 @@
-// @ts-ignore TS6133
-import { expect, test } from "vitest";
-
-import { z } from "zod/v3";
-import { util } from "../helpers/util.js";
-
-test("basic defaults", () => {
-  expect(z.string().default("default").parse(undefined)).toBe("default");
-});
-
-test("default with transform", () => {
-  const stringWithDefault = z
-    .string()
-    .transform((val) => val.toUpperCase())
-    .default("default");
-  expect(stringWithDefault.parse(undefined)).toBe("DEFAULT");
-  expect(stringWithDefault).toBeInstanceOf(z.ZodDefault);
-  expect(stringWithDefault._def.innerType).toBeInstanceOf(z.ZodEffects);
-  expect(stringWithDefault._def.innerType._def.schema).toBeInstanceOf(z.ZodSchema);
-
-  type inp = z.input<typeof stringWithDefault>;
-  util.assertEqual<inp, string | undefined>(true);
-  type out = z.output<typeof stringWithDefault>;
-  util.assertEqual<out, string>(true);
-});
-
-test("default on existing optional", () => {
-  const stringWithDefault = z.string().optional().default("asdf");
-  expect(stringWithDefault.parse(undefined)).toBe("asdf");
-  expect(stringWithDefault).toBeInstanceOf(z.ZodDefault);
-  expect(stringWithDefault._def.innerType).toBeInstanceOf(z.ZodOptional);
-  expect(stringWithDefault._def.innerType._def.innerType).toBeInstanceOf(z.ZodString);
-
-  type inp = z.input<typeof stringWithDefault>;
-  util.assertEqual<inp, string | undefined>(true);
-  type out = z.output<typeof stringWithDefault>;
-  util.assertEqual<out, string>(true);
-});
-
-test("optional on default", () => {
-  const stringWithDefault = z.string().default("asdf").optional();
-
-  type inp = z.input<typeof stringWithDefault>;
-  util.assertEqual<inp, string | undefined>(true);
-  type out = z.output<typeof stringWithDefault>;
-  util.assertEqual<out, string | undefined>(true);
-});
-
-test("complex chain example", () => {
-  const complex = z
-    .string()
-    .default("asdf")
-    .transform((val) => val.toUpperCase())
-    .default("qwer")
-    .removeDefault()
-    .optional()
-    .default("asdfasdf");
-
-  expect(complex.parse(undefined)).toBe("ASDFASDF");
-});
-
-test("removeDefault", () => {
-  const stringWithRemovedDefault = z.string().default("asdf").removeDefault();
-
-  type out = z.output<typeof stringWithRemovedDefault>;
-  util.assertEqual<out, string>(true);
-});
-
-test("nested", () => {
-  const inner = z.string().default("asdf");
-  const outer = z.object({ inner }).default({
-    inner: undefined,
-  });
-  type input = z.input<typeof outer>;
-  util.assertEqual<input, { inner?: string | undefined } | undefined>(true);
-  type out = z.output<typeof outer>;
-  util.assertEqual<out, { inner: string }>(true);
-  expect(outer.parse(undefined)).toEqual({ inner: "asdf" });
-  expect(outer.parse({})).toEqual({ inner: "asdf" });
-  expect(outer.parse({ inner: undefined })).toEqual({ inner: "asdf" });
-});
-
-test("chained defaults", () => {
-  const stringWithDefault = z.string().default("inner").default("outer");
-  const result = stringWithDefault.parse(undefined);
-  expect(result).toEqual("outer");
-});
-
-test("factory", () => {
-  expect(z.ZodDefault.create(z.string(), { default: "asdf" }).parse(undefined)).toEqual("asdf");
-});
-
-test("native enum", () => {
-  enum Fruits {
-    apple = "apple",
-    orange = "orange",
-  }
-
-  const schema = z.object({
-    fruit: z.nativeEnum(Fruits).default(Fruits.apple),
-  });
-
-  expect(schema.parse({})).toEqual({ fruit: Fruits.apple });
-});
-
-test("enum", () => {
-  const schema = z.object({
-    fruit: z.enum(["apple", "orange"]).default("apple"),
-  });
-
-  expect(schema.parse({})).toEqual({ fruit: "apple" });
-});

package/node_modules/zod/src/v3/tests/description.test.ts

@@ -1,33 +0,0 @@
-// @ts-ignore TS6133
-import { expect, test } from "vitest";
-
-import * as z from "zod/v3";
-
-const description = "a description";
-
-test("passing `description` to schema should add a description", () => {
-  expect(z.string({ description }).description).toEqual(description);
-  expect(z.number({ description }).description).toEqual(description);
-  expect(z.boolean({ description }).description).toEqual(description);
-});
-
-test("`.describe` should add a description", () => {
-  expect(z.string().describe(description).description).toEqual(description);
-  expect(z.number().describe(description).description).toEqual(description);
-  expect(z.boolean().describe(description).description).toEqual(description);
-});
-
-test("description should carry over to chained schemas", () => {
-  const schema = z.string({ description });
-  expect(schema.description).toEqual(description);
-  expect(schema.optional().description).toEqual(description);
-  expect(schema.optional().nullable().default("default").description).toEqual(description);
-});
-
-test("description should not carry over to chained array schema", () => {
-  const schema = z.string().describe(description);
-
-  expect(schema.description).toEqual(description);
-  expect(schema.array().description).toEqual(undefined);
-  expect(z.array(schema).description).toEqual(undefined);
-});

package/node_modules/zod/src/v3/tests/discriminated-unions.test.ts

@@ -1,315 +0,0 @@
-// @ts-ignore TS6133
-import { expect, test } from "vitest";
-
-import * as z from "zod/v3";
-
-test("valid", () => {
-  expect(
-    z
-      .discriminatedUnion("type", [
-        z.object({ type: z.literal("a"), a: z.string() }),
-        z.object({ type: z.literal("b"), b: z.string() }),
-      ])
-      .parse({ type: "a", a: "abc" })
-  ).toEqual({ type: "a", a: "abc" });
-});
-
-test("valid - discriminator value of various primitive types", () => {
-  const schema = z.discriminatedUnion("type", [
-    z.object({ type: z.literal("1"), val: z.literal(1) }),
-    z.object({ type: z.literal(1), val: z.literal(2) }),
-    z.object({ type: z.literal(BigInt(1)), val: z.literal(3) }),
-    z.object({ type: z.literal("true"), val: z.literal(4) }),
-    z.object({ type: z.literal(true), val: z.literal(5) }),
-    z.object({ type: z.literal("null"), val: z.literal(6) }),
-    z.object({ type: z.literal(null), val: z.literal(7) }),
-    z.object({ type: z.literal("undefined"), val: z.literal(8) }),
-    z.object({ type: z.literal(undefined), val: z.literal(9) }),
-    z.object({ type: z.literal("transform"), val: z.literal(10) }),
-    z.object({ type: z.literal("refine"), val: z.literal(11) }),
-    z.object({ type: z.literal("superRefine"), val: z.literal(12) }),
-  ]);
-
-  expect(schema.parse({ type: "1", val: 1 })).toEqual({ type: "1", val: 1 });
-  expect(schema.parse({ type: 1, val: 2 })).toEqual({ type: 1, val: 2 });
-  expect(schema.parse({ type: BigInt(1), val: 3 })).toEqual({
-    type: BigInt(1),
-    val: 3,
-  });
-  expect(schema.parse({ type: "true", val: 4 })).toEqual({
-    type: "true",
-    val: 4,
-  });
-  expect(schema.parse({ type: true, val: 5 })).toEqual({
-    type: true,
-    val: 5,
-  });
-  expect(schema.parse({ type: "null", val: 6 })).toEqual({
-    type: "null",
-    val: 6,
-  });
-  expect(schema.parse({ type: null, val: 7 })).toEqual({
-    type: null,
-    val: 7,
-  });
-  expect(schema.parse({ type: "undefined", val: 8 })).toEqual({
-    type: "undefined",
-    val: 8,
-  });
-  expect(schema.parse({ type: undefined, val: 9 })).toEqual({
-    type: undefined,
-    val: 9,
-  });
-});
-
-test("invalid - null", () => {
-  try {
-    z.discriminatedUnion("type", [
-      z.object({ type: z.literal("a"), a: z.string() }),
-      z.object({ type: z.literal("b"), b: z.string() }),
-    ]).parse(null);
-    throw new Error();
-  } catch (e: any) {
-    expect(JSON.parse(e.message)).toEqual([
-      {
-        code: z.ZodIssueCode.invalid_type,
-        expected: z.ZodParsedType.object,
-        message: "Expected object, received null",
-        received: z.ZodParsedType.null,
-        path: [],
-      },
-    ]);
-  }
-});
-
-test("invalid discriminator value", () => {
-  try {
-    z.discriminatedUnion("type", [
-      z.object({ type: z.literal("a"), a: z.string() }),
-      z.object({ type: z.literal("b"), b: z.string() }),
-    ]).parse({ type: "x", a: "abc" });
-    throw new Error();
-  } catch (e: any) {
-    expect(JSON.parse(e.message)).toEqual([
-      {
-        code: z.ZodIssueCode.invalid_union_discriminator,
-        options: ["a", "b"],
-        message: "Invalid discriminator value. Expected 'a' | 'b'",
-        path: ["type"],
-      },
-    ]);
-  }
-});
-
-test("valid discriminator value, invalid data", () => {
-  try {
-    z.discriminatedUnion("type", [
-      z.object({ type: z.literal("a"), a: z.string() }),
-      z.object({ type: z.literal("b"), b: z.string() }),
-    ]).parse({ type: "a", b: "abc" });
-    throw new Error();
-  } catch (e: any) {
-    expect(JSON.parse(e.message)).toEqual([
-      {
-        code: z.ZodIssueCode.invalid_type,
-        expected: z.ZodParsedType.string,
-        message: "Required",
-        path: ["a"],
-        received: z.ZodParsedType.undefined,
-      },
-    ]);
-  }
-});
-
-test("wrong schema - missing discriminator", () => {
-  try {
-    z.discriminatedUnion("type", [
-      z.object({ type: z.literal("a"), a: z.string() }),
-      z.object({ b: z.string() }) as any,
-    ]);
-    throw new Error();
-  } catch (e: any) {
-    expect(e.message.includes("could not be extracted")).toBe(true);
-  }
-});
-
-test("wrong schema - duplicate discriminator values", () => {
-  try {
-    z.discriminatedUnion("type", [
-      z.object({ type: z.literal("a"), a: z.string() }),
-      z.object({ type: z.literal("a"), b: z.string() }),
-    ]);
-    throw new Error();
-  } catch (e: any) {
-    expect(e.message.includes("has duplicate value")).toEqual(true);
-  }
-});
-
-test("async - valid", async () => {
-  expect(
-    await z
-      .discriminatedUnion("type", [
-        z.object({
-          type: z.literal("a"),
-          a: z
-            .string()
-            .refine(async () => true)
-            .transform(async (val) => Number(val)),
-        }),
-        z.object({
-          type: z.literal("b"),
-          b: z.string(),
-        }),
-      ])
-      .parseAsync({ type: "a", a: "1" })
-  ).toEqual({ type: "a", a: 1 });
-});
-
-test("async - invalid", async () => {
-  try {
-    await z
-      .discriminatedUnion("type", [
-        z.object({
-          type: z.literal("a"),
-          a: z
-            .string()
-            .refine(async () => true)
-            .transform(async (val) => val),
-        }),
-        z.object({
-          type: z.literal("b"),
-          b: z.string(),
-        }),
-      ])
-      .parseAsync({ type: "a", a: 1 });
-    throw new Error();
-  } catch (e: any) {
-    expect(JSON.parse(e.message)).toEqual([
-      {
-        code: "invalid_type",
-        expected: "string",
-        received: "number",
-        path: ["a"],
-        message: "Expected string, received number",
-      },
-    ]);
-  }
-});
-
-test("valid - literals with .default or .preprocess", () => {
-  const schema = z.discriminatedUnion("type", [
-    z.object({
-      type: z.literal("foo").default("foo"),
-      a: z.string(),
-    }),
-    z.object({
-      type: z.literal("custom"),
-      method: z.string(),
-    }),
-    z.object({
-      type: z.preprocess((val) => String(val), z.literal("bar")),
-      c: z.string(),
-    }),
-  ]);
-  expect(schema.parse({ type: "foo", a: "foo" })).toEqual({
-    type: "foo",
-    a: "foo",
-  });
-});
-
-test("enum and nativeEnum", () => {
-  enum MyEnum {
-    d = 0,
-    e = "e",
-  }
-
-  const schema = z.discriminatedUnion("key", [
-    z.object({
-      key: z.literal("a"),
-      // Add other properties specific to this option
-    }),
-    z.object({
-      key: z.enum(["b", "c"]),
-      // Add other properties specific to this option
-    }),
-    z.object({
-      key: z.nativeEnum(MyEnum),
-      // Add other properties specific to this option
-    }),
-  ]);
-
-  // type schema = z.infer<typeof schema>;
-
-  schema.parse({ key: "a" });
-  schema.parse({ key: "b" });
-  schema.parse({ key: "c" });
-  schema.parse({ key: MyEnum.d });
-  schema.parse({ key: MyEnum.e });
-  schema.parse({ key: "e" });
-});
-
-test("branded", () => {
-  const schema = z.discriminatedUnion("key", [
-    z.object({
-      key: z.literal("a"),
-      // Add other properties specific to this option
-    }),
-    z.object({
-      key: z.literal("b").brand("asdfaf"),
-      // Add other properties specific to this option
-    }),
-  ]);
-
-  // type schema = z.infer<typeof schema>;
-
-  schema.parse({ key: "a" });
-  schema.parse({ key: "b" });
-  expect(() => {
-    schema.parse({ key: "c" });
-  }).toThrow();
-});
-
-test("optional and nullable", () => {
-  const schema = z.discriminatedUnion("key", [
-    z.object({
-      key: z.literal("a").optional(),
-      a: z.literal(true),
-    }),
-    z.object({
-      key: z.literal("b").nullable(),
-      b: z.literal(true),
-      // Add other properties specific to this option
-    }),
-  ]);
-
-  type schema = z.infer<typeof schema>;
-  z.util.assertEqual<schema, { key?: "a" | undefined; a: true } | { key: "b" | null; b: true }>(true);
-
-  schema.parse({ key: "a", a: true });
-  schema.parse({ key: undefined, a: true });
-  schema.parse({ key: "b", b: true });
-  schema.parse({ key: null, b: true });
-  expect(() => {
-    schema.parse({ key: null, a: true });
-  }).toThrow();
-  expect(() => {
-    schema.parse({ key: "b", a: true });
-  }).toThrow();
-
-  const value = schema.parse({ key: null, b: true });
-
-  if (!("key" in value)) value.a;
-  if (value.key === undefined) value.a;
-  if (value.key === "a") value.a;
-  if (value.key === "b") value.b;
-  if (value.key === null) value.b;
-});
-
-test("readonly array of options", () => {
-  const options = [
-    z.object({ type: z.literal("x"), val: z.literal(1) }),
-    z.object({ type: z.literal("y"), val: z.literal(2) }),
-  ] as const;
-
-  expect(z.discriminatedUnion("type", options).parse({ type: "x", val: 1 })).toEqual({ type: "x", val: 1 });
-});

package/node_modules/zod/src/v3/tests/enum.test.ts

@@ -1,80 +0,0 @@
-// @ts-ignore TS6133
-import { expect, test } from "vitest";
-
-import * as z from "zod/v3";
-import { util } from "../helpers/util.js";
-
-test("create enum", () => {
-  const MyEnum = z.enum(["Red", "Green", "Blue"]);
-  expect(MyEnum.Values.Red).toEqual("Red");
-  expect(MyEnum.Enum.Red).toEqual("Red");
-  expect(MyEnum.enum.Red).toEqual("Red");
-});
-
-test("infer enum", () => {
-  const MyEnum = z.enum(["Red", "Green", "Blue"]);
-  type MyEnum = z.infer<typeof MyEnum>;
-  util.assertEqual<MyEnum, "Red" | "Green" | "Blue">(true);
-});
-
-test("get options", () => {
-  expect(z.enum(["tuna", "trout"]).options).toEqual(["tuna", "trout"]);
-});
-
-test("readonly enum", () => {
-  const HTTP_SUCCESS = ["200", "201"] as const;
-  const arg = z.enum(HTTP_SUCCESS);
-  type arg = z.infer<typeof arg>;
-  util.assertEqual<arg, "200" | "201">(true);
-
-  arg.parse("201");
-  expect(() => arg.parse("202")).toThrow();
-});
-
-test("error params", () => {
-  const result = z.enum(["test"], { required_error: "REQUIRED" }).safeParse(undefined);
-  expect(result.success).toEqual(false);
-  if (!result.success) {
-    expect(result.error.issues[0].message).toEqual("REQUIRED");
-  }
-});
-
-test("extract/exclude", () => {
-  const foods = ["Pasta", "Pizza", "Tacos", "Burgers", "Salad"] as const;
-  const FoodEnum = z.enum(foods);
-  const ItalianEnum = FoodEnum.extract(["Pasta", "Pizza"]);
-  const UnhealthyEnum = FoodEnum.exclude(["Salad"]);
-  const EmptyFoodEnum = FoodEnum.exclude(foods);
-
-  util.assertEqual<z.infer<typeof ItalianEnum>, "Pasta" | "Pizza">(true);
-  util.assertEqual<z.infer<typeof UnhealthyEnum>, "Pasta" | "Pizza" | "Tacos" | "Burgers">(true);
-  // @ts-expect-error TS2344
-  util.assertEqual<typeof EmptyFoodEnum, z.ZodEnum<[]>>(true);
-  util.assertEqual<z.infer<typeof EmptyFoodEnum>, never>(true);
-});
-
-test("error map in extract/exclude", () => {
-  const foods = ["Pasta", "Pizza", "Tacos", "Burgers", "Salad"] as const;
-  const FoodEnum = z.enum(foods, {
-    errorMap: () => ({ message: "This is not food!" }),
-  });
-  const ItalianEnum = FoodEnum.extract(["Pasta", "Pizza"]);
-  const foodsError = FoodEnum.safeParse("Cucumbers");
-  const italianError = ItalianEnum.safeParse("Tacos");
-  if (!foodsError.success && !italianError.success) {
-    expect(foodsError.error.issues[0].message).toEqual(italianError.error.issues[0].message);
-  }
-
-  const UnhealthyEnum = FoodEnum.exclude(["Salad"], {
-    errorMap: () => ({ message: "This is not healthy food!" }),
-  });
-  const unhealthyError = UnhealthyEnum.safeParse("Salad");
-  if (!unhealthyError.success) {
-    expect(unhealthyError.error.issues[0].message).toEqual("This is not healthy food!");
-  }
-});
-
-test("readonly in ZodEnumDef", () => {
-  let _t!: z.ZodEnumDef<readonly ["a", "b"]>;
-  _t;
-});