@psiclawops/hypermem 0.8.5 → 0.9.1

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

@@ -1,194 +0,0 @@
-// @ts-ignore TS6133
-import { expect, test } from "vitest";
-
-import * as z from "zod/v3";
-import { util } from "../helpers/util.js";
-
-enum testEnum {
-  A = 0,
-  B = 1,
-}
-
-const schemas = [
-  z.string().readonly(),
-  z.number().readonly(),
-  z.nan().readonly(),
-  z.bigint().readonly(),
-  z.boolean().readonly(),
-  z.date().readonly(),
-  z.undefined().readonly(),
-  z.null().readonly(),
-  z.any().readonly(),
-  z.unknown().readonly(),
-  z.void().readonly(),
-  z.function().args(z.string(), z.number()).readonly(),
-
-  z.array(z.string()).readonly(),
-  z.tuple([z.string(), z.number()]).readonly(),
-  z.map(z.string(), z.date()).readonly(),
-  z.set(z.promise(z.string())).readonly(),
-  z.record(z.string()).readonly(),
-  z.record(z.string(), z.number()).readonly(),
-  z.object({ a: z.string(), 1: z.number() }).readonly(),
-  z.nativeEnum(testEnum).readonly(),
-  z.promise(z.string()).readonly(),
-] as const;
-
-test("flat inference", () => {
-  util.assertEqual<z.infer<(typeof schemas)[0]>, string>(true);
-  util.assertEqual<z.infer<(typeof schemas)[1]>, number>(true);
-  util.assertEqual<z.infer<(typeof schemas)[2]>, number>(true);
-  util.assertEqual<z.infer<(typeof schemas)[3]>, bigint>(true);
-  util.assertEqual<z.infer<(typeof schemas)[4]>, boolean>(true);
-  util.assertEqual<z.infer<(typeof schemas)[5]>, Date>(true);
-  util.assertEqual<z.infer<(typeof schemas)[6]>, undefined>(true);
-  util.assertEqual<z.infer<(typeof schemas)[7]>, null>(true);
-  util.assertEqual<z.infer<(typeof schemas)[8]>, any>(true);
-  util.assertEqual<z.infer<(typeof schemas)[9]>, Readonly<unknown>>(true);
-  util.assertEqual<z.infer<(typeof schemas)[10]>, void>(true);
-  util.assertEqual<z.infer<(typeof schemas)[11]>, (args_0: string, args_1: number, ...args_2: unknown[]) => unknown>(
-    true
-  );
-  util.assertEqual<z.infer<(typeof schemas)[12]>, readonly string[]>(true);
-
-  util.assertEqual<z.infer<(typeof schemas)[13]>, readonly [string, number]>(true);
-  util.assertEqual<z.infer<(typeof schemas)[14]>, ReadonlyMap<string, Date>>(true);
-  util.assertEqual<z.infer<(typeof schemas)[15]>, ReadonlySet<Promise<string>>>(true);
-  util.assertEqual<z.infer<(typeof schemas)[16]>, Readonly<Record<string, string>>>(true);
-  util.assertEqual<z.infer<(typeof schemas)[17]>, Readonly<Record<string, number>>>(true);
-  util.assertEqual<z.infer<(typeof schemas)[18]>, { readonly a: string; readonly 1: number }>(true);
-  util.assertEqual<z.infer<(typeof schemas)[19]>, Readonly<testEnum>>(true);
-  util.assertEqual<z.infer<(typeof schemas)[20]>, Promise<string>>(true);
-});
-
-// test("deep inference", () => {
-//   util.assertEqual<z.infer<(typeof deepReadonlySchemas_0)[0]>, string>(true);
-//   util.assertEqual<z.infer<(typeof deepReadonlySchemas_0)[1]>, number>(true);
-//   util.assertEqual<z.infer<(typeof deepReadonlySchemas_0)[2]>, number>(true);
-//   util.assertEqual<z.infer<(typeof deepReadonlySchemas_0)[3]>, bigint>(true);
-//   util.assertEqual<z.infer<(typeof deepReadonlySchemas_0)[4]>, boolean>(true);
-//   util.assertEqual<z.infer<(typeof deepReadonlySchemas_0)[5]>, Date>(true);
-//   util.assertEqual<z.infer<(typeof deepReadonlySchemas_0)[6]>, undefined>(true);
-//   util.assertEqual<z.infer<(typeof deepReadonlySchemas_0)[7]>, null>(true);
-//   util.assertEqual<z.infer<(typeof deepReadonlySchemas_0)[8]>, any>(true);
-//   util.assertEqual<
-//     z.infer<(typeof deepReadonlySchemas_0)[9]>,
-//     Readonly<unknown>
-//   >(true);
-//   util.assertEqual<z.infer<(typeof deepReadonlySchemas_0)[10]>, void>(true);
-//   util.assertEqual<
-//     z.infer<(typeof deepReadonlySchemas_0)[11]>,
-//     (args_0: string, args_1: number, ...args_2: unknown[]) => unknown
-//   >(true);
-//   util.assertEqual<
-//     z.infer<(typeof deepReadonlySchemas_0)[12]>,
-//     readonly string[]
-//   >(true);
-//   util.assertEqual<
-//     z.infer<(typeof deepReadonlySchemas_0)[13]>,
-//     readonly [string, number]
-//   >(true);
-//   util.assertEqual<
-//     z.infer<(typeof deepReadonlySchemas_0)[14]>,
-//     ReadonlyMap<string, Date>
-//   >(true);
-//   util.assertEqual<
-//     z.infer<(typeof deepReadonlySchemas_0)[15]>,
-//     ReadonlySet<Promise<string>>
-//   >(true);
-//   util.assertEqual<
-//     z.infer<(typeof deepReadonlySchemas_0)[16]>,
-//     Readonly<Record<string, string>>
-//   >(true);
-//   util.assertEqual<
-//     z.infer<(typeof deepReadonlySchemas_0)[17]>,
-//     Readonly<Record<string, number>>
-//   >(true);
-//   util.assertEqual<
-//     z.infer<(typeof deepReadonlySchemas_0)[18]>,
-//     { readonly a: string; readonly 1: number }
-//   >(true);
-//   util.assertEqual<
-//     z.infer<(typeof deepReadonlySchemas_0)[19]>,
-//     Readonly<testEnum>
-//   >(true);
-//   util.assertEqual<
-//     z.infer<(typeof deepReadonlySchemas_0)[20]>,
-//     Promise<string>
-//   >(true);
-
-//   util.assertEqual<
-//     z.infer<typeof crazyDeepReadonlySchema>,
-//     ReadonlyMap<
-//       ReadonlySet<readonly [string, number]>,
-//       {
-//         readonly a: {
-//           readonly [x: string]: readonly any[];
-//         };
-//         readonly b: {
-//           readonly c: {
-//             readonly d: {
-//               readonly e: {
-//                 readonly f: {
-//                   readonly g?: {};
-//                 };
-//               };
-//             };
-//           };
-//         };
-//       }
-//     >
-//   >(true);
-// });
-
-test("object freezing", () => {
-  expect(Object.isFrozen(z.array(z.string()).readonly().parse(["a"]))).toBe(true);
-  expect(Object.isFrozen(z.tuple([z.string(), z.number()]).readonly().parse(["a", 1]))).toBe(true);
-  expect(
-    Object.isFrozen(
-      z
-        .map(z.string(), z.date())
-        .readonly()
-        .parse(new Map([["a", new Date()]]))
-    )
-  ).toBe(true);
-  expect(
-    Object.isFrozen(
-      z
-        .set(z.promise(z.string()))
-        .readonly()
-        .parse(new Set([Promise.resolve("a")]))
-    )
-  ).toBe(true);
-  expect(Object.isFrozen(z.record(z.string()).readonly().parse({ a: "b" }))).toBe(true);
-  expect(Object.isFrozen(z.record(z.string(), z.number()).readonly().parse({ a: 1 }))).toBe(true);
-  expect(Object.isFrozen(z.object({ a: z.string(), 1: z.number() }).readonly().parse({ a: "b", 1: 2 }))).toBe(true);
-  expect(Object.isFrozen(z.promise(z.string()).readonly().parse(Promise.resolve("a")))).toBe(true);
-});
-
-test("async object freezing", async () => {
-  expect(Object.isFrozen(await z.array(z.string()).readonly().parseAsync(["a"]))).toBe(true);
-  expect(Object.isFrozen(await z.tuple([z.string(), z.number()]).readonly().parseAsync(["a", 1]))).toBe(true);
-  expect(
-    Object.isFrozen(
-      await z
-        .map(z.string(), z.date())
-        .readonly()
-        .parseAsync(new Map([["a", new Date()]]))
-    )
-  ).toBe(true);
-  expect(
-    Object.isFrozen(
-      await z
-        .set(z.promise(z.string()))
-        .readonly()
-        .parseAsync(new Set([Promise.resolve("a")]))
-    )
-  ).toBe(true);
-  expect(Object.isFrozen(await z.record(z.string()).readonly().parseAsync({ a: "b" }))).toBe(true);
-  expect(Object.isFrozen(await z.record(z.string(), z.number()).readonly().parseAsync({ a: 1 }))).toBe(true);
-  expect(
-    Object.isFrozen(await z.object({ a: z.string(), 1: z.number() }).readonly().parseAsync({ a: "b", 1: 2 }))
-  ).toBe(true);
-  expect(Object.isFrozen(await z.promise(z.string()).readonly().parseAsync(Promise.resolve("a")))).toBe(true);
-});

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

@@ -1,171 +0,0 @@
-// @ts-ignore TS6133
-import { expect, test } from "vitest";
-
-import * as z from "zod/v3";
-import { util } from "../helpers/util.js";
-
-const booleanRecord = z.record(z.boolean());
-type booleanRecord = z.infer<typeof booleanRecord>;
-
-const recordWithEnumKeys = z.record(z.enum(["Tuna", "Salmon"]), z.string());
-type recordWithEnumKeys = z.infer<typeof recordWithEnumKeys>;
-
-const recordWithLiteralKeys = z.record(z.union([z.literal("Tuna"), z.literal("Salmon")]), z.string());
-type recordWithLiteralKeys = z.infer<typeof recordWithLiteralKeys>;
-
-test("type inference", () => {
-  util.assertEqual<booleanRecord, Record<string, boolean>>(true);
-
-  util.assertEqual<recordWithEnumKeys, Partial<Record<"Tuna" | "Salmon", string>>>(true);
-
-  util.assertEqual<recordWithLiteralKeys, Partial<Record<"Tuna" | "Salmon", string>>>(true);
-});
-
-test("methods", () => {
-  booleanRecord.optional();
-  booleanRecord.nullable();
-});
-
-test("string record parse - pass", () => {
-  booleanRecord.parse({
-    k1: true,
-    k2: false,
-    1234: false,
-  });
-});
-
-test("string record parse - fail", () => {
-  const badCheck = () =>
-    booleanRecord.parse({
-      asdf: 1234,
-    } as any);
-  expect(badCheck).toThrow();
-
-  expect(() => booleanRecord.parse("asdf")).toThrow();
-});
-
-test("string record parse - fail", () => {
-  const badCheck = () =>
-    booleanRecord.parse({
-      asdf: {},
-    } as any);
-  expect(badCheck).toThrow();
-});
-
-test("string record parse - fail", () => {
-  const badCheck = () =>
-    booleanRecord.parse({
-      asdf: [],
-    } as any);
-  expect(badCheck).toThrow();
-});
-
-test("key schema", () => {
-  const result1 = recordWithEnumKeys.parse({
-    Tuna: "asdf",
-    Salmon: "asdf",
-  });
-  expect(result1).toEqual({
-    Tuna: "asdf",
-    Salmon: "asdf",
-  });
-
-  const result2 = recordWithLiteralKeys.parse({
-    Tuna: "asdf",
-    Salmon: "asdf",
-  });
-  expect(result2).toEqual({
-    Tuna: "asdf",
-    Salmon: "asdf",
-  });
-
-  // shouldn't require us to specify all props in record
-  const result3 = recordWithEnumKeys.parse({
-    Tuna: "abcd",
-  });
-  expect(result3).toEqual({
-    Tuna: "abcd",
-  });
-
-  // shouldn't require us to specify all props in record
-  const result4 = recordWithLiteralKeys.parse({
-    Salmon: "abcd",
-  });
-  expect(result4).toEqual({
-    Salmon: "abcd",
-  });
-
-  expect(() =>
-    recordWithEnumKeys.parse({
-      Tuna: "asdf",
-      Salmon: "asdf",
-      Trout: "asdf",
-    })
-  ).toThrow();
-
-  expect(() =>
-    recordWithLiteralKeys.parse({
-      Tuna: "asdf",
-      Salmon: "asdf",
-
-      Trout: "asdf",
-    })
-  ).toThrow();
-});
-
-// test("record element", () => {
-//   expect(booleanRecord.element).toBeInstanceOf(z.ZodBoolean);
-// });
-
-test("key and value getters", () => {
-  const rec = z.record(z.string(), z.number());
-
-  rec.keySchema.parse("asdf");
-  rec.valueSchema.parse(1234);
-  rec.element.parse(1234);
-});
-
-test("is not vulnerable to prototype pollution", async () => {
-  const rec = z.record(
-    z.object({
-      a: z.string(),
-    })
-  );
-
-  const data = JSON.parse(`
-    {
-      "__proto__": {
-        "a": "evil"
-      },
-      "b": {
-        "a": "good"
-      }
-    }
-  `);
-
-  const obj1 = rec.parse(data);
-  expect(obj1.a).toBeUndefined();
-
-  const obj2 = rec.safeParse(data);
-  expect(obj2.success).toBe(true);
-  if (obj2.success) {
-    expect(obj2.data.a).toBeUndefined();
-  }
-
-  const obj3 = await rec.parseAsync(data);
-  expect(obj3.a).toBeUndefined();
-
-  const obj4 = await rec.safeParseAsync(data);
-  expect(obj4.success).toBe(true);
-  if (obj4.success) {
-    expect(obj4.data.a).toBeUndefined();
-  }
-});
-
-test("dont parse undefined values", () => {
-  const result1 = z.record(z.any()).parse({ foo: undefined });
-
-  expect(result1).toEqual({
-    foo: undefined,
-  });
-});

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

@@ -1,197 +0,0 @@
-// @ts-ignore TS6133
-import { test } from "vitest";
-
-import { z } from "zod/v3";
-
-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.late.object", () => {
-  const Category: z.ZodType<Category> = z.late.object(() => ({
-    name: z.string(),
-    subcategories: z.array(Category),
-  }));
-  Category.parse(testCategory);
-});
-
-test("recursion with z.lazy", () => {
-  const Category: z.ZodType<Category> = z.lazy(() =>
-    z.object({
-      name: z.string(),
-      subcategories: z.array(Category),
-    })
-  );
-  Category.parse(testCategory);
-});
-
-test("schema getter", () => {
-  z.lazy(() => z.string()).schema.parse("asdf");
-});
-
-type LinkedList = null | { value: number; next: LinkedList };
-
-const linkedListExample = {
-  value: 1,
-  next: {
-    value: 2,
-    next: {
-      value: 3,
-      next: {
-        value: 4,
-        next: null,
-      },
-    },
-  },
-};
-
-test("recursion involving union type", () => {
-  const LinkedListSchema: z.ZodType<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;
-// }
-
-// const A: z.ZodType<A> = z.late.object(() => ({
-//   val: z.number(),
-//   b: B,
-// }));
-
-// const B: z.ZodType<B> = z.late.object(() => ({
-//   val: z.number(),
-//   a: A,
-// }));
-
-// const Alazy: z.ZodType<A> = z.lazy(() => z.object({
-//   val: z.number(),
-//   b: B,
-// }));
-
-// const Blazy: z.ZodType<B> = z.lazy(() => z.object({
-//   val: z.number(),
-//   a: A,
-// }));
-
-// const a: any = { val: 1 };
-// const b: any = { val: 2 };
-// a.b = b;
-// b.a = a;
-
-// test('valid check', () => {
-//   A.parse(a);
-//   B.parse(b);
-// });
-
-// test("valid check lazy", () => {
-//   A.parse({val:1, b:});
-//   B.parse(b);
-// });
-
-// test('masking check', () => {
-//   const FragmentOnA = z
-//     .object({
-//       val: z.number(),
-//       b: z
-//         .object({
-//           val: z.number(),
-//           a: z
-//             .object({
-//               val: z.number(),
-//             })
-//             .nonstrict(),
-//         })
-//         .nonstrict(),
-//     })
-//     .nonstrict();
-
-//   const fragment = FragmentOnA.parse(a);
-//   fragment;
-// });
-
-// test('invalid check', () => {
-//   expect(() => A.parse({} as any)).toThrow();
-// });
-
-// test('schema getter', () => {
-//   (A as z.ZodLazy<any>).schema;
-// });
-
-// test("self recursion with cyclical data", () => {
-//   interface Category {
-//     name: string;
-//     subcategories: Category[];
-//   }
-
-//   const Category: z.ZodType<Category> = z.late.object(() => ({
-//     name: z.string(),
-//     subcategories: z.array(Category),
-//   }));
-
-//   const untypedCategory: any = {
-//     name: "Category A",
-//   };
-//   // creating a cycle
-//   untypedCategory.subcategories = [untypedCategory];
-//   Category.parse(untypedCategory);
-// });
-
-// test("self recursion with base type", () => {
-//   const BaseCategory = z.object({
-//     name: z.string(),
-//   });
-//   type BaseCategory = z.infer<typeof BaseCategory>;
-
-//   type Category = BaseCategory & { subcategories: Category[] };
-
-//   const Category: z.ZodType<Category> = z.late
-//     .object(() => ({
-//       subcategories: z.array(Category),
-//     }))
-//     .extend({
-//       name: z.string(),
-//     });
-
-//   const untypedCategory: any = {
-//     name: "Category A",
-//   };
-//   // creating a cycle
-//   untypedCategory.subcategories = [untypedCategory];
-//   Category.parse(untypedCategory); // parses successfully
-// });