@psiclawops/hypermem 0.8.5 → 0.9.1

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

@@ -1,26 +0,0 @@
-import { expect, expectTypeOf, test } from "vitest";
-
-import * as z from "zod/v4";
-
-test("check any inference", () => {
-  const t1 = z.any();
-  t1.optional();
-  t1.nullable();
-  type t1 = z.infer<typeof t1>;
-  expectTypeOf<t1>().toEqualTypeOf<any>();
-});
-
-test("check unknown inference", () => {
-  const t1 = z.unknown();
-  t1.optional();
-  t1.nullable();
-  type t1 = z.infer<typeof t1>;
-  expectTypeOf<t1>().toEqualTypeOf<unknown>();
-});
-
-test("check never inference", () => {
-  const t1 = z.never();
-  expect(() => t1.parse(undefined)).toThrow();
-  expect(() => t1.parse("asdf")).toThrow();
-  expect(() => t1.parse(null)).toThrow();
-});

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

@@ -1,59 +0,0 @@
-import { expect, expectTypeOf, test } from "vitest";
-
-import * as z from "zod/v4";
-
-test("basic apply (object)", () => {
-  const schema = z
-    .object({
-      a: z.number(),
-      b: z.string(),
-    })
-    .apply((s) => s.omit({ b: true }))
-    .apply((s) => s.extend({ c: z.boolean() }));
-
-  expect(z.toJSONSchema(schema)).toMatchInlineSnapshot(`
-    {
-      "$schema": "https://json-schema.org/draft/2020-12/schema",
-      "additionalProperties": false,
-      "properties": {
-        "a": {
-          "type": "number",
-        },
-        "c": {
-          "type": "boolean",
-        },
-      },
-      "required": [
-        "a",
-        "c",
-      ],
-      "type": "object",
-    }
-  `);
-  expectTypeOf<z.infer<typeof schema>>().toEqualTypeOf<{
-    a: number;
-    c: boolean;
-  }>();
-});
-
-test("basic apply (number)", () => {
-  const setCommonNumberChecks = <T extends z.ZodNumber>(schema: T) => {
-    return schema.min(0).max(100);
-  };
-
-  const schema = z.number().apply(setCommonNumberChecks).nullable();
-
-  expect(() => schema.parse(-1)).toThrowError();
-  expect(() => schema.parse(101)).toThrowError();
-  expect(schema.parse(0)).toBe(0);
-  expect(schema.parse(null)).toBe(null);
-  expectTypeOf<z.infer<typeof schema>>().toEqualTypeOf<number | null>();
-});
-
-test("The callback's return value becomes the apply's return value.", () => {
-  const symbol = Symbol();
-  const result = z.number().apply(() => symbol);
-
-  expect(result).toBe(symbol);
-  expectTypeOf<typeof result>().toEqualTypeOf<symbol>();
-});

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

@@ -1,264 +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("array min/max", () => {
-  const schema = z.array(z.string()).min(2).max(2);
-  const r1 = schema.safeParse(["asdf"]);
-  expect(r1.success).toEqual(false);
-  expect(r1.error!.issues).toMatchInlineSnapshot(`
-    [
-      {
-        "code": "too_small",
-        "inclusive": true,
-        "message": "Too small: expected array to have >=2 items",
-        "minimum": 2,
-        "origin": "array",
-        "path": [],
-      },
-    ]
-  `);
-
-  const r2 = schema.safeParse(["asdf", "asdf", "asdf"]);
-  expect(r2.success).toEqual(false);
-  expect(r2.error!.issues).toMatchInlineSnapshot(`
-    [
-      {
-        "code": "too_big",
-        "inclusive": true,
-        "maximum": 2,
-        "message": "Too big: expected array to have <=2 items",
-        "origin": "array",
-        "path": [],
-      },
-    ]
-  `);
-});
-
-test("array length", () => {
-  const schema = z.array(z.string()).length(2);
-  schema.parse(["asdf", "asdf"]);
-
-  const r1 = schema.safeParse(["asdf"]);
-  expect(r1.success).toEqual(false);
-  expect(r1.error!.issues).toMatchInlineSnapshot(`
-    [
-      {
-        "code": "too_small",
-        "exact": true,
-        "inclusive": true,
-        "message": "Too small: expected array to have >=2 items",
-        "minimum": 2,
-        "origin": "array",
-        "path": [],
-      },
-    ]
-  `);
-
-  const r2 = schema.safeParse(["asdf", "asdf", "asdf"]);
-  expect(r2.success).toEqual(false);
-  expect(r2.error!.issues).toMatchInlineSnapshot(`
-    [
-      {
-        "code": "too_big",
-        "exact": true,
-        "inclusive": true,
-        "maximum": 2,
-        "message": "Too big: expected array to have <=2 items",
-        "origin": "array",
-        "path": [],
-      },
-    ]
-  `);
-});
-
-test("array.nonempty()", () => {
-  const schema = z.string().array().nonempty();
-  schema.parse(["a"]);
-  expect(() => schema.parse([])).toThrow();
-});
-
-test("array.nonempty().max()", () => {
-  const schema = z.string().array().nonempty().max(2);
-  schema.parse(["a"]);
-  expect(() => schema.parse([])).toThrow();
-  expect(() => schema.parse(["a", "a", "a"])).toThrow();
-});
-
-test("parse empty array in nonempty", () => {
-  expect(() =>
-    z
-      .array(z.string())
-      .nonempty()
-      .parse([] as any)
-  ).toThrow();
-});
-
-test("get element", () => {
-  const schema = z.string().array();
-  schema.element.parse("asdf");
-  expect(() => schema.element.parse(12)).toThrow();
-});
-
-test("continue parsing despite array size error", () => {
-  const schema = z.object({
-    people: z.string().array().min(2),
-  });
-
-  const result = schema.safeParse({
-    people: [123],
-  });
-  expect(result).toMatchInlineSnapshot(`
-    {
-      "error": [ZodError: [
-      {
-        "expected": "string",
-        "code": "invalid_type",
-        "path": [
-          "people",
-          0
-        ],
-        "message": "Invalid input: expected string, received number"
-      },
-      {
-        "origin": "array",
-        "code": "too_small",
-        "minimum": 2,
-        "inclusive": true,
-        "path": [
-          "people"
-        ],
-        "message": "Too small: expected array to have >=2 items"
-      }
-    ]],
-      "success": false,
-    }
-  `);
-});
-
-test("parse should fail given sparse array", () => {
-  const schema = z.array(z.string()).nonempty().min(1).max(3);
-  const result = schema.safeParse(new Array(3));
-  expect(result.success).toEqual(false);
-  expect(result).toMatchInlineSnapshot(`
-    {
-      "error": [ZodError: [
-      {
-        "expected": "string",
-        "code": "invalid_type",
-        "path": [
-          0
-        ],
-        "message": "Invalid input: expected string, received undefined"
-      },
-      {
-        "expected": "string",
-        "code": "invalid_type",
-        "path": [
-          1
-        ],
-        "message": "Invalid input: expected string, received undefined"
-      },
-      {
-        "expected": "string",
-        "code": "invalid_type",
-        "path": [
-          2
-        ],
-        "message": "Invalid input: expected string, received undefined"
-      }
-    ]],
-      "success": false,
-    }
-  `);
-});
-
-// const unique = z.string().array().unique();
-// const uniqueArrayOfObjects = z.array(z.object({ name: z.string() })).unique({ identifier: (item) => item.name });
-
-// test("passing unique validation", () => {
-//   unique.parse(["a", "b", "c"]);
-//   uniqueArrayOfObjects.parse([{ name: "Leo" }, { name: "Joe" }]);
-// });
-
-// test("failing unique validation", () => {
-//   expect(() => unique.parse(["a", "a", "b"])).toThrow();
-//   expect(() => uniqueArrayOfObjects.parse([{ name: "Leo" }, { name: "Leo" }])).toThrow();
-// });
-
-// test("continue parsing despite array of primitives uniqueness error", () => {
-//   const schema = z.number().array().unique();
-
-//   const result = schema.safeParse([1, 1, 2, 2, 3]);
-
-//   expect(result.success).toEqual(false);
-//   if (!result.success) {
-//     const issue = result.error.issues.find(({ code }) => code === "not_unique");
-//     expect(issue?.message).toEqual("Values must be unique");
-//   }
-// });
-
-// test("continue parsing despite array of objects not_unique error", () => {
-//   const schema = z.array(z.object({ name: z.string() })).unique({
-//     identifier: (item) => item.name,
-//     showDuplicates: true,
-//   });
-
-//   const result = schema.safeParse([
-//     { name: "Leo" },
-//     { name: "Joe" },
-//     { name: "Leo" },
-//   ]);
-
-//   expect(result.success).toEqual(false);
-//   if (!result.success) {
-//     const issue = result.error.issues.find(({ code }) => code === "not_unique");
-//     expect(issue?.message).toEqual("Element(s): 'Leo' not unique");
-//   }
-// });
-
-// test("returns custom error message without duplicate elements", () => {
-//   const schema = z.number().array().unique({ message: "Custom message" });
-
-//   const result = schema.safeParse([1, 1, 2, 2, 3]);
-
-//   expect(result.success).toEqual(false);
-//   if (!result.success) {
-//     const issue = result.error.issues.find(({ code }) => code === "not_unique");
-//     expect(issue?.message).toEqual("Custom message");
-//   }
-// });
-
-// test("returns error message with duplicate elements", () => {
-//   const schema = z.number().array().unique({ showDuplicates: true });
-
-//   const result = schema.safeParse([1, 1, 2, 2, 3]);
-
-//   expect(result.success).toEqual(false);
-//   if (!result.success) {
-//     const issue = result.error.issues.find(({ code }) => code === "not_unique");
-//     expect(issue?.message).toEqual("Element(s): '1,2' not unique");
-//   }
-// });
-
-// test("returns custom error message with duplicate elements", () => {
-//   const schema = z
-//     .number()
-//     .array()
-//     .unique({
-//       message: (item) => `Custom message: '${item}' are not unique`,
-//       showDuplicates: true,
-//     });
-
-//   const result = schema.safeParse([1, 1, 2, 2, 3]);
-
-//   expect(result.success).toEqual(false);
-//   if (!result.success) {
-//     const issue = result.error.issues.find(({ code }) => code === "not_unique");
-//     expect(issue?.message).toEqual("Custom message: '1,2' are not unique");
-//   }
-// });

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

@@ -1,210 +0,0 @@
-import { expectTypeOf, test } from "vitest";
-
-import * as z from "zod/v4";
-
-test("assignability", () => {
-  // $ZodString
-  z.string() satisfies z.core.$ZodString;
-  z.string() satisfies z.ZodString;
-
-  // $ZodNumber
-  z.number() satisfies z.core.$ZodNumber;
-  z.number() satisfies z.ZodNumber;
-
-  // $ZodBigInt
-  z.bigint() satisfies z.core.$ZodBigInt;
-  z.bigint() satisfies z.ZodBigInt;
-
-  // $ZodBoolean
-  z.boolean() satisfies z.core.$ZodBoolean;
-  z.boolean() satisfies z.ZodBoolean;
-
-  // $ZodDate
-  z.date() satisfies z.core.$ZodDate;
-  z.date() satisfies z.ZodDate;
-
-  // $ZodSymbol
-  z.symbol() satisfies z.core.$ZodSymbol;
-  z.symbol() satisfies z.ZodSymbol;
-
-  // $ZodUndefined
-  z.undefined() satisfies z.core.$ZodUndefined;
-  z.undefined() satisfies z.ZodUndefined;
-
-  // $ZodNullable
-  z.string().nullable() satisfies z.core.$ZodNullable;
-  z.string().nullable() satisfies z.ZodNullable;
-
-  // $ZodNull
-  z.null() satisfies z.core.$ZodNull;
-  z.null() satisfies z.ZodNull;
-
-  // $ZodAny
-  z.any() satisfies z.core.$ZodAny;
-  z.any() satisfies z.ZodAny;
-
-  // $ZodUnknown
-  z.unknown() satisfies z.core.$ZodUnknown;
-  z.unknown() satisfies z.ZodUnknown;
-
-  // $ZodNever
-  z.never() satisfies z.core.$ZodNever;
-  z.never() satisfies z.ZodNever;
-
-  // $ZodVoid
-  z.void() satisfies z.core.$ZodVoid;
-  z.void() satisfies z.ZodVoid;
-
-  // $ZodArray
-  z.array(z.string()) satisfies z.core.$ZodArray;
-  z.array(z.string()) satisfies z.ZodArray;
-  z.array(z.string()) satisfies z.ZodType<Array<unknown>>;
-
-  // $ZodObject
-  z.object({ key: z.string() }) satisfies z.core.$ZodObject;
-  z.object({ key: z.string() }) satisfies z.ZodObject<{ key: z.ZodType }>;
-  z.object({ key: z.string() }) satisfies z.ZodType<{ key: string }>;
-
-  // $ZodUnion
-  z.union([z.string(), z.number()]) satisfies z.core.$ZodUnion;
-  z.union([z.string(), z.number()]) satisfies z.ZodUnion;
-  z.union([z.string(), z.number()]) satisfies z.ZodType<string | number>;
-
-  // $ZodIntersection
-  z.intersection(z.string(), z.number()) satisfies z.core.$ZodIntersection;
-  z.intersection(z.string(), z.number()) satisfies z.ZodIntersection;
-
-  // $ZodTuple
-  z.tuple([z.string(), z.number()]) satisfies z.core.$ZodTuple;
-  z.tuple([z.string(), z.number()]) satisfies z.ZodTuple;
-
-  // $ZodRecord
-  z.record(z.string(), z.number()) satisfies z.core.$ZodRecord;
-  z.record(z.string(), z.number()) satisfies z.ZodRecord;
-
-  // $ZodMap
-  z.map(z.string(), z.number()) satisfies z.core.$ZodMap;
-  z.map(z.string(), z.number()) satisfies z.ZodMap;
-
-  // $ZodSet
-  z.set(z.string()) satisfies z.core.$ZodSet;
-  z.set(z.string()) satisfies z.ZodSet;
-
-  // $ZodLiteral
-  z.literal("example") satisfies z.core.$ZodLiteral;
-  z.literal("example") satisfies z.ZodLiteral;
-
-  // $ZodEnum
-  z.enum(["a", "b", "c"]) satisfies z.core.$ZodEnum;
-  z.enum(["a", "b", "c"]) satisfies z.ZodEnum;
-
-  // $ZodPromise
-  z.promise(z.string()) satisfies z.core.$ZodPromise;
-  z.promise(z.string()) satisfies z.ZodPromise;
-
-  // $ZodLazy
-  const lazySchema = z.lazy(() => z.string());
-  lazySchema satisfies z.core.$ZodLazy;
-  lazySchema satisfies z.ZodLazy;
-
-  // $ZodOptional
-  z.string().optional() satisfies z.core.$ZodOptional;
-  z.string().optional() satisfies z.ZodOptional;
-
-  // $ZodDefault
-  z.string().default("default") satisfies z.core.$ZodDefault;
-  z.string().default("default") satisfies z.ZodDefault;
-
-  // $ZodTemplateLiteral
-  z.templateLiteral([z.literal("a"), z.literal("b")]) satisfies z.core.$ZodTemplateLiteral;
-  z.templateLiteral([z.literal("a"), z.literal("b")]) satisfies z.ZodTemplateLiteral;
-
-  // $ZodCustom
-  z.custom<string>((val) => typeof val === "string") satisfies z.core.$ZodCustom;
-  z.custom<string>((val) => typeof val === "string") satisfies z.ZodCustom;
-
-  // $ZodTransform
-  z.transform((val) => val as string) satisfies z.core.$ZodTransform;
-  z.transform((val) => val as string) satisfies z.ZodTransform;
-
-  // $ZodNonOptional
-  z.string().optional().nonoptional() satisfies z.core.$ZodNonOptional;
-  z.string().optional().nonoptional() satisfies z.ZodNonOptional;
-
-  // $ZodReadonly
-  z.object({ key: z.string() }).readonly() satisfies z.core.$ZodReadonly;
-  z.object({ key: z.string() }).readonly() satisfies z.ZodReadonly;
-
-  // $ZodNaN
-  z.nan() satisfies z.core.$ZodNaN;
-  z.nan() satisfies z.ZodNaN;
-
-  // $ZodPipe
-  z.unknown().pipe(z.number()) satisfies z.core.$ZodPipe;
-  z.unknown().pipe(z.number()) satisfies z.ZodPipe;
-
-  // $ZodSuccess
-  z.success(z.string()) satisfies z.core.$ZodSuccess;
-  z.success(z.string()) satisfies z.ZodSuccess;
-
-  // $ZodCatch
-  z.string().catch("fallback") satisfies z.core.$ZodCatch;
-  z.string().catch("fallback") satisfies z.ZodCatch;
-
-  // $ZodFile
-  z.file() satisfies z.core.$ZodFile;
-  z.file() satisfies z.ZodFile;
-});
-
-test("checks", () => {
-  const _a: z.core.$ZodCheck = {} as any as z.core.$ZodChecks;
-  const _b: z.core.$ZodCheck = {} as any as z.core.$ZodStringFormatChecks;
-  const _c: z.core.$ZodType = {} as any as z.core.$ZodTypes;
-  const _d: z.core.$ZodType = {} as any as z.core.$ZodStringFormatTypes;
-});
-
-test("assignability to $ZodType", () => {
-  z.string() satisfies z.ZodType;
-  z.number() satisfies z.ZodType;
-  z.boolean() satisfies z.ZodType;
-  z.object({ key: z.string() }) satisfies z.ZodType;
-  z.object({ key: z.string() }) satisfies z.ZodType<{ key: string }>;
-  z.array(z.string()) satisfies z.ZodType;
-  z.union([z.string(), z.number()]) satisfies z.ZodType;
-  z.intersection(z.string(), z.number()) satisfies z.ZodType;
-  z.tuple([z.string(), z.number()]) satisfies z.ZodType;
-  z.record(z.string(), z.number()) satisfies z.ZodType;
-  z.map(z.string(), z.number()) satisfies z.ZodType;
-  z.set(z.string()) satisfies z.ZodType;
-  z.literal("example") satisfies z.ZodType;
-
-  expectTypeOf<z.ZodType extends z.core.$ZodType ? true : false>().toEqualTypeOf<true>();
-});
-
-test("assignability with narrowing", () => {
-  type _RefinedSchema<T extends z.ZodType<object> | z.ZodUnion> = T extends z.ZodUnion
-    ? RefinedUnionSchema<T> // <-- Type instantiation is excessively deep and possibly infinite.
-    : T extends z.ZodType<object>
-      ? RefinedTypeSchema<z.output<T>> // <-- Type instantiation is excessively deep and possibly infinite.
-      : never;
-
-  type RefinedTypeSchema<T extends object> = T;
-
-  type RefinedUnionSchema<T extends z.ZodUnion> = T;
-});
-
-test("generic assignability in objects", () => {
-  interface SortItem<T extends string> {
-    key: T;
-    order: string;
-  }
-
-  const createSortItemSchema = <T extends z.ZodType<string>>(sortKeySchema: T) =>
-    z.object({
-      key: sortKeySchema,
-      order: z.string(),
-    });
-
-  <T extends z.ZodType<string>>(sortKeySchema: T, defaultSortBy: SortItem<z.output<T>>[] = []) =>
-    createSortItemSchema(sortKeySchema).array().default(defaultSortBy);
-});