@guru-ai-product/ai-product-kit 0.2.251117192248 → 0.2.251118120602

package/mcp/node_modules/zod/src/v4/classic/tests/partial.test.ts

@@ -1,147 +0,0 @@
-import { expect, expectTypeOf, test } from "vitest";
-import * as z from "zod/v4";
-
-const nested = z.object({
-  name: z.string(),
-  age: z.number(),
-  outer: z.object({
-    inner: z.string(),
-  }),
-  array: z.array(z.object({ asdf: z.string() })),
-});
-
-test("shallow inference", () => {
-  const shallow = nested.partial();
-  type shallow = z.infer<typeof shallow>;
-
-  expectTypeOf<shallow>().toEqualTypeOf<{
-    name?: string | undefined;
-    age?: number | undefined;
-    outer?: { inner: string } | undefined;
-    array?: { asdf: string }[] | undefined;
-  }>();
-});
-
-test("shallow partial parse", () => {
-  const shallow = nested.partial();
-  shallow.parse({});
-  shallow.parse({
-    name: "asdf",
-    age: 23143,
-  });
-});
-
-test("required", () => {
-  const object = z.object({
-    name: z.string(),
-    age: z.number().optional(),
-    field: z.string().optional().default("asdf"),
-    nullableField: z.number().nullable(),
-    nullishField: z.string().nullish(),
-  });
-
-  const requiredObject = object.required();
-  expect(requiredObject.shape.name).toBeInstanceOf(z.ZodNonOptional);
-  expect(requiredObject.shape.name.unwrap()).toBeInstanceOf(z.ZodString);
-  expect(requiredObject.shape.age).toBeInstanceOf(z.ZodNonOptional);
-  expect(requiredObject.shape.age.unwrap()).toBeInstanceOf(z.ZodOptional);
-  expect(requiredObject.shape.field).toBeInstanceOf(z.ZodNonOptional);
-  expect(requiredObject.shape.field.unwrap()).toBeInstanceOf(z.ZodDefault);
-  expect(requiredObject.shape.nullableField).toBeInstanceOf(z.ZodNonOptional);
-  expect(requiredObject.shape.nullableField.unwrap()).toBeInstanceOf(z.ZodNullable);
-  expect(requiredObject.shape.nullishField).toBeInstanceOf(z.ZodNonOptional);
-  expect(requiredObject.shape.nullishField.unwrap()).toBeInstanceOf(z.ZodOptional);
-  expect(requiredObject.shape.nullishField.unwrap().unwrap()).toBeInstanceOf(z.ZodNullable);
-});
-
-test("required inference", () => {
-  const object = z.object({
-    name: z.string(),
-    age: z.number().optional(),
-    field: z.string().optional().default("asdf"),
-    nullableField: z.number().nullable(),
-    nullishField: z.string().nullish(),
-  });
-
-  const requiredObject = object.required();
-
-  type required = z.infer<typeof requiredObject>;
-  type expected = {
-    name: string;
-    age: number;
-    field: string;
-    nullableField: number | null;
-    nullishField: string | null;
-  };
-  expectTypeOf<expected>().toEqualTypeOf<required>();
-});
-
-test("required with mask", () => {
-  const object = z.object({
-    name: z.string(),
-    age: z.number().optional(),
-    field: z.string().optional().default("asdf"),
-    country: z.string().optional(),
-  });
-
-  const requiredObject = object.required({ age: true });
-  expect(requiredObject.shape.name).toBeInstanceOf(z.ZodString);
-  expect(requiredObject.shape.age).toBeInstanceOf(z.ZodNonOptional);
-  expect(requiredObject.shape.field).toBeInstanceOf(z.ZodDefault);
-  expect(requiredObject.shape.country).toBeInstanceOf(z.ZodOptional);
-});
-
-test("required with mask -- ignore falsy values", () => {
-  const object = z.object({
-    name: z.string(),
-    age: z.number().optional(),
-    field: z.string().optional().default("asdf"),
-    country: z.string().optional(),
-  });
-
-  // @ts-expect-error
-  const requiredObject = object.required({ age: true, country: false });
-  expect(requiredObject.shape.name).toBeInstanceOf(z.ZodString);
-  expect(requiredObject.shape.age).toBeInstanceOf(z.ZodNonOptional);
-  expect(requiredObject.shape.field).toBeInstanceOf(z.ZodDefault);
-  expect(requiredObject.shape.country).toBeInstanceOf(z.ZodOptional);
-});
-
-test("partial with mask", async () => {
-  const object = z.object({
-    name: z.string(),
-    age: z.number().optional(),
-    field: z.string().optional().default("asdf"),
-    country: z.string(),
-  });
-
-  const masked = object.partial({ age: true, field: true, name: true }).strict();
-
-  expect(masked.shape.name).toBeInstanceOf(z.ZodOptional);
-  expect(masked.shape.age).toBeInstanceOf(z.ZodOptional);
-  expect(masked.shape.field).toBeInstanceOf(z.ZodOptional);
-  expect(masked.shape.country).toBeInstanceOf(z.ZodString);
-
-  masked.parse({ country: "US" });
-  await masked.parseAsync({ country: "US" });
-});
-
-test("partial with mask -- ignore falsy values", async () => {
-  const object = z.object({
-    name: z.string(),
-    age: z.number().optional(),
-    field: z.string().optional().default("asdf"),
-    country: z.string(),
-  });
-
-  // @ts-expect-error
-  const masked = object.partial({ name: true, country: false }).strict();
-
-  expect(masked.shape.name).toBeInstanceOf(z.ZodOptional);
-  expect(masked.shape.age).toBeInstanceOf(z.ZodOptional);
-  expect(masked.shape.field).toBeInstanceOf(z.ZodDefault);
-  expect(masked.shape.country).toBeInstanceOf(z.ZodString);
-
-  masked.parse({ country: "US" });
-  await masked.parseAsync({ country: "US" });
-});

package/mcp/node_modules/zod/src/v4/classic/tests/pickomit.test.ts

@@ -1,127 +0,0 @@
-import { expect, expectTypeOf, test } from "vitest";
-import * as z from "zod/v4";
-
-const fish = z.object({
-  name: z.string(),
-  age: z.number(),
-  nested: z.object({}),
-});
-
-test("pick type inference", () => {
-  const nameonlyFish = fish.pick({ name: true });
-  type nameonlyFish = z.infer<typeof nameonlyFish>;
-  expectTypeOf<nameonlyFish>().toEqualTypeOf<{ name: string }>();
-});
-
-test("pick parse - success", () => {
-  const nameonlyFish = fish.pick({ name: true });
-  nameonlyFish.parse({ name: "bob" });
-
-  // @ts-expect-error checking runtime picks `name` only.
-  const anotherNameonlyFish = fish.pick({ name: true, age: false });
-  anotherNameonlyFish.parse({ name: "bob" });
-});
-
-test("pick parse - fail", () => {
-  fish.pick({ name: true }).parse({ name: "12" } as any);
-  fish.pick({ name: true }).parse({ name: "bob", age: 12 } as any);
-  fish.pick({ age: true }).parse({ age: 12 } as any);
-
-  const nameonlyFish = fish.pick({ name: true }).strict();
-  const bad1 = () => nameonlyFish.parse({ name: 12 } as any);
-  const bad2 = () => nameonlyFish.parse({ name: "bob", age: 12 } as any);
-  const bad3 = () => nameonlyFish.parse({ age: 12 } as any);
-
-  // @ts-expect-error checking runtime picks `name` only.
-  const anotherNameonlyFish = fish.pick({ name: true, age: false }).strict();
-  const bad4 = () => anotherNameonlyFish.parse({ name: "bob", age: 12 } as any);
-
-  expect(bad1).toThrow();
-  expect(bad2).toThrow();
-  expect(bad3).toThrow();
-  expect(bad4).toThrow();
-});
-
-test("pick - remove optional", () => {
-  const schema = z.object({ a: z.string(), b: z.string().optional() });
-  expect("a" in schema._zod.def.shape).toEqual(true);
-  expect("b" in schema._zod.def.shape!).toEqual(true);
-  const picked = schema.pick({ a: true });
-  expect("a" in picked._zod.def.shape).toEqual(true);
-  expect("b" in picked._zod.def.shape!).toEqual(false);
-});
-
-test("omit type inference", () => {
-  const nonameFish = fish.omit({ name: true });
-  type nonameFish = z.infer<typeof nonameFish>;
-
-  expectTypeOf<nonameFish>().toEqualTypeOf<{ age: number; nested: Record<string, never> }>();
-});
-
-test("omit parse - success", () => {
-  const nonameFish = fish.omit({ name: true });
-  nonameFish.parse({ age: 12, nested: {} });
-
-  // @ts-expect-error checking runtime omits `name` only.
-  const anotherNonameFish = fish.omit({ name: true, age: false });
-  anotherNonameFish.parse({ age: 12, nested: {} });
-});
-
-test("omit parse - fail", () => {
-  const nonameFish = fish.omit({ name: true });
-  const bad1 = () => nonameFish.parse({ name: 12 } as any);
-  const bad2 = () => nonameFish.parse({ age: 12 } as any);
-  const bad3 = () => nonameFish.parse({} as any);
-
-  // @ts-expect-error checking runtime omits `name` only.
-  const anotherNonameFish = fish.omit({ name: true, age: false });
-  const bad4 = () => anotherNonameFish.parse({ nested: {} } as any);
-
-  expect(bad1).toThrow();
-  expect(bad2).toThrow();
-  expect(bad3).toThrow();
-  expect(bad4).toThrow();
-});
-
-test("omit - remove optional", () => {
-  const schema = z.object({ a: z.string(), b: z.string().optional() });
-  expect("a" in schema._zod.def.shape).toEqual(true);
-  const omitted = schema.omit({ a: true });
-  expect("a" in omitted._zod.def.shape).toEqual(false);
-});
-
-test("nonstrict inference", () => {
-  const laxfish = fish.pick({ name: true }).catchall(z.any());
-  type laxfish = z.infer<typeof laxfish>;
-  expectTypeOf<laxfish>().toEqualTypeOf<{ name: string; [k: string]: any }>();
-});
-
-test("nonstrict parsing - pass", () => {
-  const laxfish = fish.passthrough().pick({ name: true });
-  laxfish.parse({ name: "asdf", whatever: "asdf" });
-  laxfish.parse({ name: "asdf", age: 12, nested: {} });
-});
-
-test("nonstrict parsing - fail", () => {
-  const laxfish = fish.passthrough().pick({ name: true });
-  const bad = () => laxfish.parse({ whatever: "asdf" } as any);
-  expect(bad).toThrow();
-});
-
-test("pick/omit/required/partial - do not allow unknown keys", () => {
-  const schema = z.object({
-    name: z.string(),
-    age: z.number(),
-  });
-
-  expect(() => schema.pick({ name: true, asdf: true })).toThrow();
-
-  // @ts-expect-error
-  expect(() => schema.pick({ $unknown: true })).toThrow();
-  // @ts-expect-error
-  expect(() => schema.omit({ $unknown: true })).toThrow();
-  // @ts-expect-error
-  expect(() => schema.required({ $unknown: true })).toThrow();
-  // @ts-expect-error
-  expect(() => schema.partial({ $unknown: true })).toThrow();
-});

package/mcp/node_modules/zod/src/v4/classic/tests/pipe.test.ts

@@ -1,81 +0,0 @@
-import { expect, test } from "vitest";
-
-import * as z from "zod/v4";
-
-test("string to number pipe", () => {
-  const schema = z.string().transform(Number).pipe(z.number());
-  expect(schema.parse("1234")).toEqual(1234);
-});
-
-test("string to number pipe async", async () => {
-  const schema = z
-    .string()
-    .transform(async (val) => Number(val))
-    .pipe(z.number());
-  expect(await schema.parseAsync("1234")).toEqual(1234);
-});
-
-test("string with default fallback", () => {
-  const stringWithDefault = z
-    .pipe(
-      z.transform((v) => (v === "none" ? undefined : v)),
-      z.string()
-    )
-    .catch("default");
-
-  expect(stringWithDefault.parse("ok")).toBe("ok");
-  expect(stringWithDefault.parse(undefined)).toBe("default");
-  expect(stringWithDefault.parse("none")).toBe("default");
-  expect(stringWithDefault.parse(15)).toBe("default");
-});
-
-test("continue on non-fatal errors", () => {
-  const schema = z
-    .string()
-    .refine((c) => c === "1234", "A")
-    .transform((val) => Number(val))
-    .refine((c) => c === 1234, "B");
-
-  schema.parse("1234");
-
-  expect(schema.safeParse("4321")).toMatchInlineSnapshot(`
-    {
-      "error": [ZodError: [
-      {
-        "code": "custom",
-        "path": [],
-        "message": "A"
-      },
-      {
-        "code": "custom",
-        "path": [],
-        "message": "B"
-      }
-    ]],
-      "success": false,
-    }
-  `);
-});
-
-test("break on fatal errors", () => {
-  const schema = z
-    .string()
-    .refine((c) => c === "1234", { message: "A", abort: true })
-    .transform((val) => Number(val))
-    .refine((c) => c === 1234, "B");
-
-  schema.parse("1234");
-
-  expect(schema.safeParse("4321")).toMatchInlineSnapshot(`
-    {
-      "error": [ZodError: [
-      {
-        "code": "custom",
-        "path": [],
-        "message": "A"
-      }
-    ]],
-      "success": false,
-    }
-  `);
-});

package/mcp/node_modules/zod/src/v4/classic/tests/prefault.test.ts

@@ -1,37 +0,0 @@
-import { expect, expectTypeOf, test } from "vitest";
-import { z } from "zod/v4";
-
-test("basic prefault", () => {
-  const a = z.prefault(z.string().trim(), "  default  ");
-  expect(a).toBeInstanceOf(z.ZodPrefault);
-  expect(a.parse("  asdf  ")).toEqual("asdf");
-  expect(a.parse(undefined)).toEqual("default");
-
-  type inp = z.input<typeof a>;
-  expectTypeOf<inp>().toEqualTypeOf<string | undefined>();
-  type out = z.output<typeof a>;
-  expectTypeOf<out>().toEqualTypeOf<string>();
-});
-
-test("prefault inside object", () => {
-  // test optinality
-  const a = z.object({
-    name: z.string().optional(),
-    age: z.number().default(1234),
-    email: z.string().prefault("1234"),
-  });
-
-  type inp = z.input<typeof a>;
-  expectTypeOf<inp>().toEqualTypeOf<{
-    name?: string | undefined;
-    age?: number | undefined;
-    email?: string | undefined;
-  }>();
-
-  type out = z.output<typeof a>;
-  expectTypeOf<out>().toEqualTypeOf<{
-    name?: string | undefined;
-    age: number;
-    email: string;
-  }>();
-});

package/mcp/node_modules/zod/src/v4/classic/tests/preprocess.test.ts

@@ -1,298 +0,0 @@
-import { expect, expectTypeOf, test } from "vitest";
-import * as z from "zod/v4";
-
-test("preprocess", () => {
-  const schema = z.preprocess((data) => [data], z.string().array());
-  const value = schema.parse("asdf");
-  expect(value).toEqual(["asdf"]);
-  expectTypeOf<(typeof schema)["_input"]>().toEqualTypeOf<unknown>();
-});
-
-test("async preprocess", async () => {
-  const schema = z.preprocess(async (data) => {
-    return [data];
-  }, z.string().array());
-  const value = await schema.safeParseAsync("asdf");
-  expect(value.data).toEqual(["asdf"]);
-  expect(value).toMatchInlineSnapshot(`
-    {
-      "data": [
-        "asdf",
-      ],
-      "success": true,
-    }
-  `);
-});
-
-test("ctx.addIssue accepts string", () => {
-  const schema = z.preprocess((_, ctx) => {
-    ctx.addIssue("bad stuff");
-  }, z.string());
-  const result = schema.safeParse("asdf");
-  expect(result.error!.issues).toHaveLength(1);
-  expect(result).toMatchInlineSnapshot(`
-    {
-      "error": [ZodError: [
-      {
-        "message": "bad stuff",
-        "code": "custom",
-        "path": []
-      }
-    ]],
-      "success": false,
-    }
-  `);
-});
-
-test("preprocess ctx.addIssue with parse", () => {
-  const a = z.preprocess((data, ctx) => {
-    ctx.addIssue({
-      input: data,
-      code: "custom",
-      message: `${data} is not one of our allowed strings`,
-    });
-    return data;
-  }, z.string());
-
-  const result = a.safeParse("asdf");
-
-  // expect(result.error!.toJSON()).toContain("not one of our allowed strings");
-
-  expect(result.error!.issues).toHaveLength(1);
-  expect(result).toMatchInlineSnapshot(`
-    {
-      "error": [ZodError: [
-      {
-        "code": "custom",
-        "message": "asdf is not one of our allowed strings",
-        "path": []
-      }
-    ]],
-      "success": false,
-    }
-  `);
-});
-
-test("preprocess ctx.addIssue non-fatal by default", () => {
-  const schema = z.preprocess((data, ctx) => {
-    ctx.addIssue({
-      code: "custom",
-      message: `custom error`,
-    });
-    return data;
-  }, z.string());
-  const result = schema.safeParse(1234);
-
-  expect(result.error!.issues).toHaveLength(2);
-  expect(result).toMatchInlineSnapshot(`
-    {
-      "error": [ZodError: [
-      {
-        "code": "custom",
-        "message": "custom error",
-        "path": []
-      },
-      {
-        "expected": "string",
-        "code": "invalid_type",
-        "path": [],
-        "message": "Invalid input: expected string, received number"
-      }
-    ]],
-      "success": false,
-    }
-  `);
-});
-
-test("preprocess ctx.addIssue fatal true", () => {
-  const schema = z.preprocess((data, ctx) => {
-    ctx.addIssue({
-      input: data,
-      code: "custom",
-      origin: "custom",
-      message: `custom error`,
-      fatal: true,
-    });
-    return data;
-  }, z.string());
-
-  const result = schema.safeParse(1234);
-
-  expect(result.error!.issues).toHaveLength(1);
-  expect(result).toMatchInlineSnapshot(`
-    {
-      "error": [ZodError: [
-      {
-        "code": "custom",
-        "origin": "custom",
-        "message": "custom error",
-        "fatal": true,
-        "path": []
-      }
-    ]],
-      "success": false,
-    }
-  `);
-});
-
-test("async preprocess ctx.addIssue with parseAsync", async () => {
-  const schema = z.preprocess(async (data, ctx) => {
-    ctx.addIssue({
-      input: data,
-      code: "custom",
-      message: `${data} is not one of our allowed strings`,
-    });
-    return data;
-  }, z.string());
-
-  const result = await schema.safeParseAsync("asdf");
-
-  expect(result.error!.issues).toHaveLength(1);
-  expect(result).toMatchInlineSnapshot(`
-    {
-      "error": [ZodError: [
-      {
-        "code": "custom",
-        "message": "asdf is not one of our allowed strings",
-        "path": []
-      }
-    ]],
-      "success": false,
-    }
-  `);
-});
-
-test("z.NEVER in preprocess", () => {
-  const foo = z.preprocess((val, ctx) => {
-    if (!val) {
-      ctx.addIssue({ input: val, code: "custom", message: "bad" });
-      return z.NEVER;
-    }
-    return val;
-  }, z.number());
-
-  type foo = z.infer<typeof foo>;
-  expectTypeOf<foo>().toEqualTypeOf<number>();
-  const result = foo.safeParse(undefined);
-
-  expect(result.error!.issues).toHaveLength(2);
-  expect(result).toMatchInlineSnapshot(`
-    {
-      "error": [ZodError: [
-      {
-        "code": "custom",
-        "message": "bad",
-        "path": []
-      },
-      {
-        "expected": "number",
-        "code": "invalid_type",
-        "path": [],
-        "message": "Invalid input: expected number, received object"
-      }
-    ]],
-      "success": false,
-    }
-  `);
-});
-
-test("preprocess as the second property of object", () => {
-  const schema = z.object({
-    nonEmptyStr: z.string().min(1),
-    positiveNum: z.preprocess((v) => Number(v), z.number().positive()),
-  });
-  const result = schema.safeParse({
-    nonEmptyStr: "",
-    positiveNum: "",
-  });
-
-  expect(result.error!.issues).toHaveLength(2);
-  expect(result).toMatchInlineSnapshot(`
-    {
-      "error": [ZodError: [
-      {
-        "origin": "string",
-        "code": "too_small",
-        "minimum": 1,
-        "inclusive": true,
-        "path": [
-          "nonEmptyStr"
-        ],
-        "message": "Too small: expected string to have >=1 characters"
-      },
-      {
-        "origin": "number",
-        "code": "too_small",
-        "minimum": 0,
-        "inclusive": false,
-        "path": [
-          "positiveNum"
-        ],
-        "message": "Too small: expected number to be >0"
-      }
-    ]],
-      "success": false,
-    }
-  `);
-});
-
-test("preprocess validates with sibling errors", () => {
-  const schema = z.object({
-    missing: z.string().refine(() => false),
-    preprocess: z.preprocess((data: any) => data?.trim(), z.string().regex(/ asdf/)),
-  });
-
-  const result = schema.safeParse({ preprocess: " asdf" });
-
-  expect(result.error!.issues).toHaveLength(2);
-  expect(result).toMatchInlineSnapshot(`
-    {
-      "error": [ZodError: [
-      {
-        "expected": "string",
-        "code": "invalid_type",
-        "path": [
-          "missing"
-        ],
-        "message": "Invalid input: expected string, received undefined"
-      },
-      {
-        "origin": "string",
-        "code": "invalid_format",
-        "format": "regex",
-        "pattern": "/ asdf/",
-        "path": [
-          "preprocess"
-        ],
-        "message": "Invalid string: must match pattern / asdf/"
-      }
-    ]],
-      "success": false,
-    }
-  `);
-});
-
-test("perform transform with non-fatal issues", () => {
-  const A = z
-    .string()
-    .refine((_) => false)
-    .min(4)
-    .transform((val) => val.length)
-    .pipe(z.number())
-    .refine((_) => false);
-  expect(A.safeParse("asdfasdf").error!.issues).toHaveLength(2);
-  expect(A.safeParse("asdfasdf").error).toMatchInlineSnapshot(`
-    [ZodError: [
-      {
-        "code": "custom",
-        "path": [],
-        "message": "Invalid input"
-      },
-      {
-        "code": "custom",
-        "path": [],
-        "message": "Invalid input"
-      }
-    ]]
-  `);
-});