@psiclawops/hypermem 0.9.0 → 0.9.1

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

@@ -1,219 +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.boolean()]).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": "invalid_type",
-                "expected": "boolean",
-                "message": "Invalid input: expected boolean, received string",
-                "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",
-    }
-  `);
-});
-
-test("non-aborted errors", () => {
-  const zItemTest = z.union([
-    z.object({
-      date: z.number(),
-      startDate: z.optional(z.null()),
-      endDate: z.optional(z.null()),
-    }),
-    z
-      .object({
-        date: z.optional(z.null()),
-        startDate: z.number(),
-        endDate: z.number(),
-      })
-      .refine((data) => data.startDate !== data.endDate, {
-        error: "startDate and endDate must be different",
-        path: ["endDate"],
-      }),
-  ]);
-
-  const res = zItemTest.safeParse({
-    date: null,
-    startDate: 1,
-    endDate: 1,
-  });
-
-  expect(res).toMatchInlineSnapshot(`
-    {
-      "error": [ZodError: [
-      {
-        "code": "custom",
-        "path": [
-          "endDate"
-        ],
-        "message": "startDate and endDate must be different"
-      }
-    ]],
-      "success": false,
-    }
-  `);
-});
-
-test("surface continuable errors only if they exist", () => {
-  const schema = z.union([z.boolean(), z.uuid(), z.jwt()]);
-
-  expect(schema.safeParse("asdf")).toMatchInlineSnapshot(`
-    {
-      "error": [ZodError: [
-      {
-        "code": "invalid_union",
-        "errors": [
-          [
-            {
-              "expected": "boolean",
-              "code": "invalid_type",
-              "path": [],
-              "message": "Invalid input: expected boolean, received string"
-            }
-          ],
-          [
-            {
-              "origin": "string",
-              "code": "invalid_format",
-              "format": "uuid",
-              "pattern": "/^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/",
-              "path": [],
-              "message": "Invalid UUID"
-            }
-          ],
-          [
-            {
-              "code": "invalid_format",
-              "format": "jwt",
-              "path": [],
-              "message": "Invalid JWT"
-            }
-          ]
-        ],
-        "path": [],
-        "message": "Invalid input"
-      }
-    ]],
-      "success": false,
-    }
-  `);
-});
-
-// z.xor() tests
-test("z.xor() - exactly one match succeeds", () => {
-  const schema = z.xor([z.string(), z.number()]);
-  expect(schema.parse("hello")).toBe("hello");
-  expect(schema.parse(42)).toBe(42);
-});
-
-test("z.xor() - zero matches fails", () => {
-  const schema = z.xor([z.string(), z.number()]);
-  const result = schema.safeParse(true);
-  expect(result.success).toBe(false);
-});
-
-test("z.xor() - multiple matches fails", () => {
-  const schema = z.xor([z.string(), z.any()]);
-  const result = schema.safeParse("hello");
-  expect(result.success).toBe(false);
-  if (!result.success) {
-    expect(result.error.issues[0].code).toBe("invalid_union");
-    expect((result.error.issues[0] as any).inclusive).toBe(false);
-  }
-});
-
-test("z.xor() with custom error message", () => {
-  const schema = z.xor([z.string(), z.number()], "Expected exactly one of string or number");
-  const result = schema.safeParse(true);
-  expect(result.success).toBe(false);
-  if (!result.success) {
-    expect(result.error.issues[0].message).toBe("Expected exactly one of string or number");
-  }
-});
-
-test("z.xor() type inference", () => {
-  const schema = z.xor([z.string(), z.number(), z.boolean()]);
-  type Result = z.infer<typeof schema>;
-  expectTypeOf<Result>().toEqualTypeOf<string | number | boolean>();
-});

package/node_modules/zod/src/v4/classic/tests/url.test.ts

@@ -1,13 +0,0 @@
-import { expect, expectTypeOf, test } from "vitest";
-import * as z from "zod/v4";
-
-test("type inference", () => {
-  const schema = z.string().array();
-  expectTypeOf<z.infer<typeof schema>>().toEqualTypeOf<string[]>();
-});
-
-test("url regex", () => {
-  expect((z.url({ hostname: /^example\.com$/ }).safeParse("http://example.org/").error?.issues[0] as any).pattern).toBe(
-    "^example\\.com$"
-  );
-});

package/node_modules/zod/src/v4/classic/tests/validations.test.ts

@@ -1,283 +0,0 @@
-import { expect, test } from "vitest";
-
-import * as z from "zod/v4";
-
-test("string length", async () => {
-  try {
-    await z.string().length(4).parseAsync("asd");
-  } catch (err) {
-    // ("String must contain exactly 4 character(s)");
-    expect((err as z.ZodError).issues).toMatchInlineSnapshot(`
-      [
-        {
-          "code": "too_small",
-          "exact": true,
-          "inclusive": true,
-          "message": "Too small: expected string to have >=4 characters",
-          "minimum": 4,
-          "origin": "string",
-          "path": [],
-        },
-      ]
-    `);
-  }
-
-  try {
-    await z.string().length(4).parseAsync("asdaa");
-  } catch (err) {
-    // ("String must contain exactly 4 character(s)");
-    expect((err as z.ZodError).issues).toMatchInlineSnapshot(`
-      [
-        {
-          "code": "too_big",
-          "exact": true,
-          "inclusive": true,
-          "maximum": 4,
-          "message": "Too big: expected string to have <=4 characters",
-          "origin": "string",
-          "path": [],
-        },
-      ]
-    `);
-  }
-});
-
-test("string min/max", async () => {
-  try {
-    await z.string().min(4).parseAsync("asd");
-  } catch (err) {
-    // ("String must contain at least 4 character(s)");
-    expect((err as z.ZodError).issues).toMatchInlineSnapshot(`
-      [
-        {
-          "code": "too_small",
-          "inclusive": true,
-          "message": "Too small: expected string to have >=4 characters",
-          "minimum": 4,
-          "origin": "string",
-          "path": [],
-        },
-      ]
-    `);
-  }
-});
-
-test("string max", async () => {
-  try {
-    await z.string().max(4).parseAsync("aasdfsdfsd");
-  } catch (err) {
-    // ("String must contain at most 4 character(s)");
-    expect((err as z.ZodError).issues).toMatchInlineSnapshot(`
-      [
-        {
-          "code": "too_big",
-          "inclusive": true,
-          "maximum": 4,
-          "message": "Too big: expected string to have <=4 characters",
-          "origin": "string",
-          "path": [],
-        },
-      ]
-    `);
-  }
-});
-
-test("number min", async () => {
-  try {
-    await z.number().min(3).parseAsync(2);
-  } catch (err) {
-    // ("Number must be greater than or equal to 3");
-    expect((err as z.ZodError).issues).toMatchInlineSnapshot(`
-      [
-        {
-          "code": "too_small",
-          "inclusive": true,
-          "message": "Too small: expected number to be >=3",
-          "minimum": 3,
-          "origin": "number",
-          "path": [],
-        },
-      ]
-    `);
-  }
-});
-
-test("number gte", async () => {
-  try {
-    await z.number().gte(3).parseAsync(2);
-  } catch (err) {
-    // ("Number must be greater than or equal to 3");
-    expect((err as z.ZodError).issues).toMatchInlineSnapshot(`
-      [
-        {
-          "code": "too_small",
-          "inclusive": true,
-          "message": "Too small: expected number to be >=3",
-          "minimum": 3,
-          "origin": "number",
-          "path": [],
-        },
-      ]
-    `);
-  }
-});
-
-test("number gt", async () => {
-  try {
-    await z.number().gt(3).parseAsync(3);
-  } catch (err) {
-    // ("Number must be greater than or equal to 3");
-    expect((err as z.ZodError).issues).toMatchInlineSnapshot(`
-      [
-        {
-          "code": "too_small",
-          "inclusive": false,
-          "message": "Too small: expected number to be >3",
-          "minimum": 3,
-          "origin": "number",
-          "path": [],
-        },
-      ]
-    `);
-  }
-});
-
-test("number max", async () => {
-  try {
-    await z.number().max(3).parseAsync(4);
-  } catch (err) {
-    // ("Number must be less than or equal to 3");
-    expect((err as z.ZodError).issues).toMatchInlineSnapshot(`
-      [
-        {
-          "code": "too_big",
-          "inclusive": true,
-          "maximum": 3,
-          "message": "Too big: expected number to be <=3",
-          "origin": "number",
-          "path": [],
-        },
-      ]
-    `);
-  }
-});
-
-test("number lte", async () => {
-  try {
-    await z.number().lte(3).parseAsync(4);
-  } catch (err) {
-    // ("Number must be less than or equal to 3");
-    expect((err as z.ZodError).issues).toMatchInlineSnapshot(`
-      [
-        {
-          "code": "too_big",
-          "inclusive": true,
-          "maximum": 3,
-          "message": "Too big: expected number to be <=3",
-          "origin": "number",
-          "path": [],
-        },
-      ]
-    `);
-  }
-});
-
-test("number lt", async () => {
-  try {
-    await z.number().lt(3).parseAsync(3);
-  } catch (err) {
-    // ("Number must be less than or equal to 3");
-    expect((err as z.ZodError).issues).toMatchInlineSnapshot(`
-      [
-        {
-          "code": "too_big",
-          "inclusive": false,
-          "maximum": 3,
-          "message": "Too big: expected number to be <3",
-          "origin": "number",
-          "path": [],
-        },
-      ]
-    `);
-  }
-});
-
-test("number nonnegative", async () => {
-  try {
-    await z.number().nonnegative().parseAsync(-1);
-  } catch (err) {
-    // ("Number must be greater than or equal to 0");
-    expect((err as z.ZodError).issues).toMatchInlineSnapshot(`
-      [
-        {
-          "code": "too_small",
-          "inclusive": true,
-          "message": "Too small: expected number to be >=0",
-          "minimum": 0,
-          "origin": "number",
-          "path": [],
-        },
-      ]
-    `);
-  }
-});
-
-test("number nonpositive", async () => {
-  try {
-    await z.number().nonpositive().parseAsync(1);
-  } catch (err) {
-    // ("Number must be less than or equal to 0");
-    expect((err as z.ZodError).issues).toMatchInlineSnapshot(`
-      [
-        {
-          "code": "too_big",
-          "inclusive": true,
-          "maximum": 0,
-          "message": "Too big: expected number to be <=0",
-          "origin": "number",
-          "path": [],
-        },
-      ]
-    `);
-  }
-});
-
-test("number negative", async () => {
-  try {
-    await z.number().negative().parseAsync(1);
-  } catch (err) {
-    // ("Number must be less than 0");
-    expect((err as z.ZodError).issues).toMatchInlineSnapshot(`
-      [
-        {
-          "code": "too_big",
-          "inclusive": false,
-          "maximum": 0,
-          "message": "Too big: expected number to be <0",
-          "origin": "number",
-          "path": [],
-        },
-      ]
-    `);
-  }
-});
-
-test("number positive", async () => {
-  try {
-    await z.number().positive().parseAsync(-1);
-  } catch (err) {
-    // ("Number must be greater than 0");
-    expect((err as z.ZodError).issues).toMatchInlineSnapshot(`
-      [
-        {
-          "code": "too_small",
-          "inclusive": false,
-          "message": "Too small: expected number to be >0",
-          "minimum": 0,
-          "origin": "number",
-          "path": [],
-        },
-      ]
-    `);
-  }
-});

package/node_modules/zod/src/v4/classic/tests/void.test.ts

@@ -1,12 +0,0 @@
-import { expect, expectTypeOf, test } from "vitest";
-import * as z from "zod/v4";
-test("void", () => {
-  const v = z.void();
-  v.parse(undefined);
-
-  expect(() => v.parse(null)).toThrow();
-  expect(() => v.parse("")).toThrow();
-
-  type v = z.infer<typeof v>;
-  expectTypeOf<v>().toEqualTypeOf<void>();
-});