kennel 0.2.12 → 0.2.15

package/node_modules/zod/src/v4/mini/tests/number.test.ts

@@ -1,95 +0,0 @@
-import { expect, expectTypeOf, test } from "vitest";
-import * as z from "zod/mini";
-
-test("z.number", () => {
-  const a = z.number();
-  expect(z.parse(a, 123)).toEqual(123);
-  expect(z.parse(a, 123.45)).toEqual(123.45);
-  expect(() => z.parse(a, "123")).toThrow();
-  expect(() => z.parse(a, false)).toThrow();
-
-  type a = z.infer<typeof a>;
-  expectTypeOf<a>().toEqualTypeOf<number>();
-});
-
-test("z.number async", async () => {
-  const a = z.number().check(z.refine(async (_) => _ > 0));
-  await expect(z.parseAsync(a, 123)).resolves.toEqual(123);
-  await expect(() => z.parseAsync(a, -123)).rejects.toThrow();
-  await expect(() => z.parseAsync(a, "123")).rejects.toThrow();
-});
-
-test("z.int", () => {
-  const a = z.int();
-  expect(z.parse(a, 123)).toEqual(123);
-  expect(() => z.parse(a, 123.45)).toThrow();
-  expect(() => z.parse(a, "123")).toThrow();
-  expect(() => z.parse(a, false)).toThrow();
-});
-
-test("z.float32", () => {
-  const a = z.float32();
-  expect(z.parse(a, 123.45)).toEqual(123.45);
-  expect(() => z.parse(a, "123.45")).toThrow();
-  expect(() => z.parse(a, false)).toThrow();
-  // -3.4028234663852886e38, 3.4028234663852886e38;
-  expect(() => z.parse(a, 3.4028234663852886e38 * 2)).toThrow(); // Exceeds max
-  expect(() => z.parse(a, -3.4028234663852886e38 * 2)).toThrow(); // Exceeds min
-});
-
-test("z.float64", () => {
-  const a = z.float64();
-  expect(z.parse(a, 123.45)).toEqual(123.45);
-  expect(() => z.parse(a, "123.45")).toThrow();
-  expect(() => z.parse(a, false)).toThrow();
-  expect(() => z.parse(a, 1.7976931348623157e308 * 2)).toThrow(); // Exceeds max
-  expect(() => z.parse(a, -1.7976931348623157e308 * 2)).toThrow(); // Exceeds min
-});
-
-test("z.int32", () => {
-  const a = z.int32();
-  expect(z.parse(a, 123)).toEqual(123);
-  expect(() => z.parse(a, 123.45)).toThrow();
-  expect(() => z.parse(a, "123")).toThrow();
-  expect(() => z.parse(a, false)).toThrow();
-  expect(() => z.parse(a, 2147483648)).toThrow(); // Exceeds max
-  expect(() => z.parse(a, -2147483649)).toThrow(); // Exceeds min
-});
-
-test("z.uint32", () => {
-  const a = z.uint32();
-  expect(z.parse(a, 123)).toEqual(123);
-  expect(() => z.parse(a, -123)).toThrow();
-  expect(() => z.parse(a, 123.45)).toThrow();
-  expect(() => z.parse(a, "123")).toThrow();
-  expect(() => z.parse(a, false)).toThrow();
-  expect(() => z.parse(a, 4294967296)).toThrow(); // Exceeds max
-  expect(() => z.parse(a, -1)).toThrow(); // Below min
-});
-
-test("z.int64", () => {
-  const a = z.int64();
-  expect(z.parse(a, BigInt(123))).toEqual(BigInt(123));
-  expect(() => z.parse(a, 123)).toThrow();
-  expect(() => z.parse(a, 123.45)).toThrow();
-  expect(() => z.parse(a, "123")).toThrow();
-  expect(() => z.parse(a, false)).toThrow();
-  expect(() => z.parse(a, BigInt("9223372036854775808"))).toThrow();
-  expect(() => z.parse(a, BigInt("-9223372036854775809"))).toThrow();
-  // expect(() => z.parse(a, BigInt("9223372036854775808"))).toThrow(); // Exceeds max
-  // expect(() => z.parse(a, BigInt("-9223372036854775809"))).toThrow(); // Exceeds min
-});
-
-test("z.uint64", () => {
-  const a = z.uint64();
-  expect(z.parse(a, BigInt(123))).toEqual(BigInt(123));
-  expect(() => z.parse(a, 123)).toThrow();
-  expect(() => z.parse(a, -123)).toThrow();
-  expect(() => z.parse(a, 123.45)).toThrow();
-  expect(() => z.parse(a, "123")).toThrow();
-  expect(() => z.parse(a, false)).toThrow();
-  expect(() => z.parse(a, BigInt("18446744073709551616"))).toThrow(); // Exceeds max
-  expect(() => z.parse(a, BigInt("-1"))).toThrow(); // Below min
-  // expect(() => z.parse(a, BigInt("18446744073709551616"))).toThrow(); // Exceeds max
-  // expect(() => z.parse(a, BigInt("-1"))).toThrow(); // Below min
-});

package/node_modules/zod/src/v4/mini/tests/object.test.ts

@@ -1,227 +0,0 @@
-import { expect, expectTypeOf, test } from "vitest";
-import * as z from "zod/mini";
-
-test("z.object", () => {
-  const a = z.object({
-    name: z.string(),
-    age: z.number(),
-    points: z.optional(z.number()),
-    "test?": z.boolean(),
-  });
-
-  a._zod.def.shape["test?"];
-  a._zod.def.shape.points._zod.optin;
-
-  type a = z.output<typeof a>;
-
-  expectTypeOf<a>().toEqualTypeOf<{
-    name: string;
-    age: number;
-    points?: number | undefined;
-    "test?": boolean;
-  }>();
-  expect(z.parse(a, { name: "john", age: 30, "test?": true })).toEqual({
-    name: "john",
-    age: 30,
-    "test?": true,
-  });
-  // "test?" is required in ZodObject
-  expect(() => z.parse(a, { name: "john", age: "30" })).toThrow();
-  expect(() => z.parse(a, "hello")).toThrow();
-
-  // null prototype
-  const schema = z.object({ a: z.string() });
-  const obj = Object.create(null);
-  obj.a = "foo";
-  expect(schema.parse(obj)).toEqual({ a: "foo" });
-});
-
-test("z.object().check()", () => {
-  const a = z.object({
-    name: z.string(),
-    age: z.number(),
-    points: z.optional(z.number()),
-    "test?": z.boolean(),
-  });
-
-  type a = z.output<typeof a>;
-
-  a.check(({ value }) => {
-    expectTypeOf(value).toEqualTypeOf<a>();
-  });
-});
-
-test("z.strictObject", () => {
-  const a = z.strictObject({
-    name: z.string(),
-  });
-  expect(z.parse(a, { name: "john" })).toEqual({ name: "john" });
-  expect(() => z.parse(a, { name: "john", age: 30 })).toThrow();
-  expect(() => z.parse(a, "hello")).toThrow();
-});
-
-test("z.looseObject", () => {
-  const a = z.looseObject({
-    name: z.string(),
-    age: z.number(),
-  });
-  expect(z.parse(a, { name: "john", age: 30 })).toEqual({
-    name: "john",
-    age: 30,
-  });
-  expect(z.parse(a, { name: "john", age: 30, extra: true })).toEqual({
-    name: "john",
-    age: 30,
-    extra: true,
-  });
-  expect(() => z.parse(a, "hello")).toThrow();
-});
-
-const userSchema = z.object({
-  name: z.string(),
-  age: z.number(),
-  email: z.optional(z.string()),
-});
-
-test("z.keyof", () => {
-  // z.keyof returns an enum schema of the keys of an object schema
-  const userKeysSchema = z.keyof(userSchema);
-  type UserKeys = z.infer<typeof userKeysSchema>;
-  expectTypeOf<UserKeys>().toEqualTypeOf<"name" | "age" | "email">();
-  expect(userKeysSchema).toBeDefined();
-  expect(userKeysSchema._zod.def.type).toBe("enum");
-  expect(userKeysSchema._zod.def.entries).toEqual({
-    name: "name",
-    age: "age",
-    email: "email",
-  });
-  expect(z.safeParse(userKeysSchema, "name").success).toBe(true);
-  expect(z.safeParse(userKeysSchema, "age").success).toBe(true);
-  expect(z.safeParse(userKeysSchema, "email").success).toBe(true);
-  expect(z.safeParse(userKeysSchema, "isAdmin").success).toBe(false);
-});
-
-test("z.extend", () => {
-  const extendedSchema = z.extend(userSchema, {
-    isAdmin: z.boolean(),
-  });
-  type ExtendedUser = z.infer<typeof extendedSchema>;
-  expectTypeOf<ExtendedUser>().toEqualTypeOf<{
-    name: string;
-    age: number;
-    email?: string | undefined;
-    isAdmin: boolean;
-  }>();
-  expect(extendedSchema).toBeDefined();
-  expect(z.safeParse(extendedSchema, { name: "John", age: 30, isAdmin: true }).success).toBe(true);
-});
-
-test("z.safeExtend", () => {
-  const extended = z.safeExtend(userSchema, { name: z.string() });
-  expect(z.safeParse(extended, { name: "John", age: 30 }).success).toBe(true);
-  type Extended = z.infer<typeof extended>;
-  expectTypeOf<Extended>().toEqualTypeOf<{ name: string; age: number; email?: string | undefined }>();
-  // @ts-expect-error
-  z.safeExtend(userSchema, { name: z.number() });
-});
-
-test("z.pick", () => {
-  const pickedSchema = z.pick(userSchema, { name: true, email: true });
-  type PickedUser = z.infer<typeof pickedSchema>;
-  expectTypeOf<PickedUser>().toEqualTypeOf<{ name: string; email?: string | undefined }>();
-  expect(pickedSchema).toBeDefined();
-  expect(z.safeParse(pickedSchema, { name: "John", email: "john@example.com" }).success).toBe(true);
-});
-
-test("z.omit", () => {
-  const omittedSchema = z.omit(userSchema, { age: true });
-  type OmittedUser = z.infer<typeof omittedSchema>;
-  expectTypeOf<OmittedUser>().toEqualTypeOf<{
-    name: string;
-    email?: string | undefined;
-  }>();
-  expect(omittedSchema).toBeDefined();
-  expect(Reflect.ownKeys(omittedSchema._zod.def.shape)).toEqual(["name", "email"]);
-  expect(z.safeParse(omittedSchema, { name: "John", email: "john@example.com" }).success).toBe(true);
-});
-
-test("z.partial", () => {
-  const partialSchema = z.partial(userSchema);
-  type PartialUser = z.infer<typeof partialSchema>;
-  expectTypeOf<PartialUser>().toEqualTypeOf<{
-    name?: string | undefined;
-    age?: number | undefined;
-    email?: string | undefined;
-  }>();
-  expect(z.safeParse(partialSchema, { name: "John" }).success).toBe(true);
-});
-
-test("z.partial with mask", () => {
-  const partialSchemaWithMask = z.partial(userSchema, { name: true });
-  type PartialUserWithMask = z.infer<typeof partialSchemaWithMask>;
-  expectTypeOf<PartialUserWithMask>().toEqualTypeOf<{
-    name?: string | undefined;
-    age: number;
-    email?: string | undefined;
-  }>();
-  expect(z.safeParse(partialSchemaWithMask, { age: 30 }).success).toBe(true);
-  expect(z.safeParse(partialSchemaWithMask, { name: "John" }).success).toBe(false);
-});
-
-test("z.pick/omit/partial/required - do not allow unknown keys", () => {
-  const schema = z.object({
-    name: z.string(),
-    age: z.number(),
-  });
-
-  // Mixed valid + invalid keys - throws at parse time (lazy evaluation)
-  // @ts-expect-error
-  expect(() => z.parse(z.pick(schema, { name: true, asdf: true }), {})).toThrow();
-  // @ts-expect-error
-  expect(() => z.parse(z.omit(schema, { name: true, asdf: true }), {})).toThrow();
-  // @ts-expect-error
-  expect(() => z.parse(z.partial(schema, { name: true, asdf: true }), {})).toThrow();
-  // @ts-expect-error
-  expect(() => z.parse(z.required(schema, { name: true, asdf: true }), {})).toThrow();
-
-  // Only invalid keys
-  // @ts-expect-error
-  expect(() => z.parse(z.pick(schema, { $unknown: true }), {})).toThrow();
-  // @ts-expect-error
-  expect(() => z.parse(z.omit(schema, { $unknown: true }), {})).toThrow();
-  // @ts-expect-error
-  expect(() => z.parse(z.partial(schema, { $unknown: true }), {})).toThrow();
-  // @ts-expect-error
-  expect(() => z.parse(z.required(schema, { $unknown: true }), {})).toThrow();
-});
-
-test("z.catchall", () => {
-  // z.catchall()
-  const schema = z.catchall(
-    z.object({
-      name: z.string(),
-      // age: z.number(),
-    }),
-    z.string()
-  );
-
-  type schemaIn = z.input<typeof schema>;
-  type schemaOut = z.output<typeof schema>;
-  expectTypeOf<schemaIn>().toEqualTypeOf<{
-    name: string;
-    [key: string]: string;
-  }>();
-
-  expectTypeOf<schemaOut>().toEqualTypeOf<{
-    name: string;
-    [key: string]: string;
-  }>();
-
-  schema.parse({
-    name: "john",
-    age: "30",
-    extra: "extra value",
-  });
-
-  expect(() => schema.parse({ name: "john", age: 30 })).toThrow();
-});

package/node_modules/zod/src/v4/mini/tests/prototypes.test.ts

@@ -1,43 +0,0 @@
-import { expect, test } from "vitest";
-import * as z from "zod/mini";
-
-declare module "zod/v4/core" {
-  interface $ZodType {
-    /** @deprecated */
-    _core(): string;
-  }
-}
-
-test("prototype extension", () => {
-  z.core.$ZodType.prototype._core = function () {
-    return "_core";
-  };
-
-  // should pass
-  const result = z.string()._core();
-  expect(result).toBe("_core");
-  // expectTypeOf<typeof result>().toEqualTypeOf<string>();
-
-  // clean up
-  z.ZodMiniType.prototype._core = undefined;
-});
-
-declare module "zod/v4/mini" {
-  interface ZodMiniType {
-    /** @deprecated */
-    _mini(): string;
-  }
-}
-
-test("prototype extension", () => {
-  z.ZodMiniType.prototype._mini = function () {
-    return "_mini";
-  };
-
-  // should pass
-  const result = z.string()._mini();
-  expect(result).toBe("_mini");
-
-  // clean up
-  z.ZodMiniType.prototype._mini = undefined;
-});

package/node_modules/zod/src/v4/mini/tests/recursive-types.test.ts

@@ -1,325 +0,0 @@
-import { expect, expectTypeOf, test } from "vitest";
-import { z } from "zod/mini";
-
-test("recursion with z.lazy", () => {
-  const data = {
-    name: "I",
-    subcategories: [
-      {
-        name: "A",
-        subcategories: [
-          {
-            name: "1",
-            subcategories: [
-              {
-                name: "a",
-                subcategories: [],
-              },
-            ],
-          },
-        ],
-      },
-    ],
-  };
-
-  const Category = z.object({
-    name: z.string(),
-    get subcategories(): z.ZodMiniOptional<z.ZodMiniArray<typeof Category>> {
-      return z.optional(z.array(Category));
-    },
-  });
-  Category.parse(data);
-
-  type Category = z.infer<typeof Category>;
-  interface _Category {
-    name: string;
-    subcategories?: _Category[] | undefined;
-  }
-  expectTypeOf<Category>().toEqualTypeOf<_Category>();
-});
-
-test("recursion involving union type", () => {
-  const data = {
-    value: 1,
-    next: {
-      value: 2,
-      next: {
-        value: 3,
-        next: {
-          value: 4,
-          next: null,
-        },
-      },
-    },
-  };
-
-  const LL = z.object({
-    value: z.number(),
-    get next(): z.ZodMiniNullable<typeof LL> {
-      return z.nullable(LL);
-    },
-  });
-
-  LL.parse(data);
-  type LL = z.infer<typeof LL>;
-  type _LL = {
-    value: number;
-    next: _LL | null;
-  };
-  expectTypeOf<LL>().toEqualTypeOf<_LL>();
-});
-
-test("mutual recursion - native", () => {
-  const Alazy = z.object({
-    val: z.number(),
-    get b() {
-      return z.optional(Blazy);
-    },
-  });
-
-  const Blazy = z.object({
-    val: z.number(),
-    get a() {
-      return z.optional(Alazy);
-    },
-  });
-  const testData = {
-    val: 1,
-    b: {
-      val: 5,
-      a: {
-        val: 3,
-        b: {
-          val: 4,
-          a: {
-            val: 2,
-            b: {
-              val: 1,
-            },
-          },
-        },
-      },
-    },
-  };
-
-  Alazy.parse(testData);
-  Blazy.parse(testData.b);
-
-  type Alazy = z.infer<typeof Alazy>;
-  type Blazy = z.infer<typeof Blazy>;
-  interface _Alazy {
-    val: number;
-    b?: _Blazy | undefined;
-  }
-  interface _Blazy {
-    val: number;
-    a?: _Alazy | undefined;
-  }
-  expectTypeOf<Alazy>().toEqualTypeOf<_Alazy>();
-  expectTypeOf<Blazy>().toEqualTypeOf<_Blazy>();
-
-  expect(() => Alazy.parse({ val: "asdf" })).toThrow();
-});
-
-test("pick and omit with getter", () => {
-  const Category = z.strictObject({
-    name: z.string(),
-    get subcategories() {
-      return z.array(Category);
-    },
-  });
-
-  type Category = z.infer<typeof Category>;
-  interface _Category {
-    name: string;
-    subcategories: _Category[];
-  }
-  expectTypeOf<Category>().toEqualTypeOf<_Category>();
-
-  const PickedCategory = z.pick(Category, { name: true });
-  const OmittedCategory = z.omit(Category, { subcategories: true });
-  type PickedCategory = z.infer<typeof PickedCategory>;
-  type OmittedCategory = z.infer<typeof OmittedCategory>;
-  interface _PickedCategory {
-    name: string;
-  }
-  interface _OmittedCategory {
-    name: string;
-  }
-  expectTypeOf<PickedCategory>().toEqualTypeOf<_PickedCategory>();
-  expectTypeOf<OmittedCategory>().toEqualTypeOf<_OmittedCategory>();
-
-  const picked = { name: "test" };
-  const omitted = { name: "test" };
-
-  PickedCategory.parse(picked);
-  OmittedCategory.parse(omitted);
-
-  expect(() => PickedCategory.parse({ name: "test", subcategories: [] })).toThrow();
-  expect(() => OmittedCategory.parse({ name: "test", subcategories: [] })).toThrow();
-});
-
-test("deferred self-recursion", () => {
-  const Feature = z.object({
-    title: z.string(),
-    get features(): z.ZodMiniOptional<z.ZodMiniArray<typeof Feature>> {
-      return z.optional(z.array(Feature)); //.optional();
-    },
-  });
-  type Feature = z.infer<typeof Feature>;
-
-  const Output = z.object({
-    id: z.int(), //.nonnegative(),
-    name: z.string(),
-    features: z.array(Feature), //.array(), // <—
-  });
-
-  type Output = z.output<typeof Output>;
-
-  type _Feature = {
-    title: string;
-    features?: _Feature[] | undefined;
-  };
-
-  type _Output = {
-    id: number;
-    name: string;
-    features: _Feature[];
-  };
-
-  expectTypeOf<Feature>().toEqualTypeOf<_Feature>();
-  expectTypeOf<Output>().toEqualTypeOf<_Output>();
-});
-
-test("recursion compatibility", () => {
-  // array
-  const A = z.object({
-    get subcategories() {
-      return z.array(A);
-    },
-  });
-  // tuple
-  const B = z.object({
-    get subcategories() {
-      return z.tuple([B, B]);
-    },
-  });
-  // object
-  const C = z.object({
-    get subcategories() {
-      return z.object({
-        subcategories: C,
-      });
-    },
-  });
-  // union
-  const D = z.object({
-    get subcategories() {
-      return z.union([D, z.string()]);
-    },
-  });
-  // intersection
-  const E = z.object({
-    get subcategories() {
-      return z.intersection(E, E);
-    },
-  });
-  // record
-  const F = z.object({
-    get subcategories() {
-      return z.record(z.string(), F);
-    },
-  });
-  // map
-  const G = z.object({
-    get subcategories() {
-      return z.map(z.string(), G);
-    },
-  });
-  // set
-  const H = z.object({
-    get subcategories() {
-      return z.set(H);
-    },
-  });
-  // optional
-  const I = z.object({
-    get subcategories() {
-      return z.optional(I);
-    },
-  });
-  // nullable
-  const J = z.object({
-    get subcategories() {
-      return z.nullable(J);
-    },
-  });
-  // optional
-  const L = z.object({
-    get subcategories() {
-      return z.optional(L);
-    },
-  });
-  // nullable
-  const M = z.object({
-    get subcategories() {
-      return z.nullable(M);
-    },
-  });
-  // nonoptional
-  const N = z.object({
-    get subcategories() {
-      return z.nonoptional(N);
-    },
-  });
-});
-
-test("shape stays writeable through object/strictObject/looseObject/extend with getters", () => {
-  const Cat = z.object({
-    name: z.string(),
-    get sub(): z.ZodMiniArray<typeof Cat> {
-      return z.array(Cat);
-    },
-  });
-  type CatShape = (typeof Cat)["shape"];
-  expectTypeOf<CatShape>().toEqualTypeOf<{
-    name: z.ZodMiniString<string>;
-    sub: z.ZodMiniArray<typeof Cat>;
-  }>();
-
-  const StrictCat = z.strictObject({
-    name: z.string(),
-    get sub(): z.ZodMiniArray<typeof StrictCat> {
-      return z.array(StrictCat);
-    },
-  });
-  type StrictShape = (typeof StrictCat)["shape"];
-  expectTypeOf<StrictShape>().toEqualTypeOf<{
-    name: z.ZodMiniString<string>;
-    sub: z.ZodMiniArray<typeof StrictCat>;
-  }>();
-
-  const LooseCat = z.looseObject({
-    name: z.string(),
-    get sub(): z.ZodMiniArray<typeof LooseCat> {
-      return z.array(LooseCat);
-    },
-  });
-  type LooseShape = (typeof LooseCat)["shape"];
-  expectTypeOf<LooseShape>().toEqualTypeOf<{
-    name: z.ZodMiniString<string>;
-    sub: z.ZodMiniArray<typeof LooseCat>;
-  }>();
-
-  const Base = z.object({ name: z.string() });
-  const Extended = z.extend(Base, {
-    get sub(): z.ZodMiniArray<typeof Extended> {
-      return z.array(Extended);
-    },
-  });
-  type ExtendedShape = (typeof Extended)["shape"];
-  expectTypeOf<ExtendedShape>().toEqualTypeOf<{
-    name: z.ZodMiniString<string>;
-    sub: z.ZodMiniArray<typeof Extended>;
-  }>();
-});