claude-scope 0.1.6 → 0.1.8

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

@@ -1,360 +0,0 @@
-import { expect, expectTypeOf, test } from "vitest";
-import * as z from "zod/v4";
-
-const args1 = z.tuple([z.string()]);
-const returns1 = z.number();
-const func1 = z.function({
-  input: args1,
-
-  output: returns1,
-});
-
-test("function parsing", () => {
-  const parsed = func1.implement((arg: any) => arg.length);
-  const result = parsed("asdf");
-  expect(result).toBe(4);
-});
-
-test("parsed function fail 1", () => {
-  // @ts-expect-error
-  const parsed = func1.implement((x: string) => x);
-  expect(() => parsed("asdf")).toThrow();
-});
-
-test("parsed function fail 2", () => {
-  // @ts-expect-error
-  const parsed = func1.implement((x: string) => x);
-  expect(() => parsed(13 as any)).toThrow();
-});
-
-test("function inference 1", () => {
-  type func1 = (typeof func1)["_input"];
-  expectTypeOf<func1>().toEqualTypeOf<(k: string) => number>();
-});
-
-test("method parsing", () => {
-  const methodObject = z.object({
-    property: z.number(),
-    method: z
-      .function()
-      .input(z.tuple([z.string()]))
-      .output(z.number()),
-  });
-  const methodInstance = {
-    property: 3,
-    method: function (s: string) {
-      return s.length + this.property;
-    },
-  };
-  const parsed = methodObject.parse(methodInstance);
-  expect(parsed.method("length=8")).toBe(11); // 8 length + 3 property
-});
-
-test("async method parsing", async () => {
-  const methodObject = z.object({
-    property: z.number(),
-    method: z.function().input([z.string()]).output(z.promise(z.number())),
-  });
-  const methodInstance = {
-    property: 3,
-    method: async function (s: string) {
-      return s.length + this.property;
-    },
-  };
-  const parsed = methodObject.parse(methodInstance);
-  expect(await parsed.method("length=8")).toBe(11); // 8 length + 3 property
-});
-
-test("args method", () => {
-  const t1 = z.function();
-  type t1 = (typeof t1)["_input"];
-  expectTypeOf<t1>().toEqualTypeOf<(...args_1: never[]) => unknown>();
-  t1._input;
-
-  const t2args = z.tuple([z.string()], z.unknown());
-
-  const t2 = t1.input(t2args);
-  type t2 = (typeof t2)["_input"];
-  expectTypeOf<t2>().toEqualTypeOf<(arg: string, ...args_1: unknown[]) => unknown>();
-
-  const t3 = t2.output(z.boolean());
-  type t3 = (typeof t3)["_input"];
-  expectTypeOf<t3>().toEqualTypeOf<(arg: string, ...args_1: unknown[]) => boolean>();
-});
-
-// test("custom args", () => {
-//   const fn = z.function().implement((_a: string, _b: number) => {
-//     return new Date();
-//   });
-
-//   expectTypeOf(fn).toEqualTypeOf<(a: string, b: number) => Date>();
-// });
-
-const args2 = z.tuple([
-  z.object({
-    f1: z.number(),
-    f2: z.string().nullable(),
-    f3: z.array(z.boolean().optional()).optional(),
-  }),
-]);
-const returns2 = z.union([z.string(), z.number()]);
-
-const func2 = z.function({
-  input: args2,
-  output: returns2,
-});
-
-test("function inference 2", () => {
-  type func2 = (typeof func2)["_input"];
-
-  expectTypeOf<func2>().toEqualTypeOf<
-    (arg: {
-      f3?: (boolean | undefined)[] | undefined;
-      f1: number;
-      f2: string | null;
-    }) => string | number
-  >();
-});
-
-test("valid function run", () => {
-  const validFunc2Instance = func2.implement((_x) => {
-    _x.f2;
-    _x.f3![0];
-    return "adf" as any;
-  });
-
-  validFunc2Instance({
-    f1: 21,
-    f2: "asdf",
-    f3: [true, false],
-  });
-});
-
-const args3 = [
-  z.object({
-    f1: z.number(),
-    f2: z.string().nullable(),
-    f3: z.array(z.boolean().optional()).optional(),
-  }),
-] as const;
-const returns3 = z.union([z.string(), z.number()]);
-
-const func3 = z.function({
-  input: args3,
-  output: returns3,
-});
-
-test("function inference 3", () => {
-  type func3 = (typeof func3)["_input"];
-
-  expectTypeOf<func3>().toEqualTypeOf<
-    (arg: {
-      f3?: (boolean | undefined)[] | undefined;
-      f1: number;
-      f2: string | null;
-    }) => string | number
-  >();
-});
-
-test("valid function run", () => {
-  const validFunc3Instance = func3.implement((_x) => {
-    _x.f2;
-    _x.f3![0];
-    return "adf" as any;
-  });
-
-  validFunc3Instance({
-    f1: 21,
-    f2: "asdf",
-    f3: [true, false],
-  });
-});
-
-test("input validation error", () => {
-  const schema = z.function({
-    input: z.tuple([z.string()]),
-    output: z.void(),
-  });
-  const fn = schema.implement(() => 1234 as any);
-
-  // @ts-expect-error
-  const checker = () => fn();
-
-  try {
-    checker();
-  } catch (e: any) {
-    expect(e.issues).toMatchInlineSnapshot(`
-      [
-        {
-          "code": "invalid_type",
-          "expected": "string",
-          "message": "Invalid input: expected string, received undefined",
-          "path": [
-            0,
-          ],
-        },
-      ]
-    `);
-  }
-});
-
-test("array inputs", () => {
-  const a = z.function({
-    input: [
-      z.object({
-        name: z.string(),
-        age: z.number().int(),
-      }),
-    ],
-    output: z.string(),
-  });
-
-  a.implement((args) => {
-    return `${args.age}`;
-  });
-
-  const b = z.function({
-    input: [
-      z.object({
-        name: z.string(),
-        age: z.number().int(),
-      }),
-    ],
-  });
-  b.implement((args) => {
-    return `${args.age}`;
-  });
-});
-
-test("output validation error", () => {
-  const schema = z.function({
-    input: z.tuple([]),
-    output: z.string(),
-  });
-  const fn = schema.implement(() => 1234 as any);
-  try {
-    fn();
-  } catch (e: any) {
-    expect(e.issues).toMatchInlineSnapshot(`
-      [
-        {
-          "code": "invalid_type",
-          "expected": "string",
-          "message": "Invalid input: expected string, received number",
-          "path": [],
-        },
-      ]
-    `);
-  }
-});
-
-test("function with async refinements", async () => {
-  const schema = z
-    .function()
-    .input([z.string().refine(async (val) => val.length > 10)])
-    .output(z.promise(z.number().refine(async (val) => val > 10)));
-
-  const func = schema.implementAsync(async (val) => {
-    return val.length;
-  });
-  const results = [];
-  try {
-    await func("asdfasdf");
-    results.push("success");
-  } catch (_) {
-    results.push("fail");
-  }
-  try {
-    await func("asdflkjasdflkjsf");
-    results.push("success");
-  } catch (_) {
-    results.push("fail");
-  }
-
-  expect(results).toEqual(["fail", "success"]);
-});
-
-test("implement async with transforms", async () => {
-  const typeGuard = (data: string): data is "1234" => data === "1234";
-  const codeSchema = z.string().transform((data, ctx) => {
-    if (typeGuard(data)) {
-      return data;
-    } else {
-      ctx.addIssue({
-        code: z.ZodIssueCode.custom,
-        message: "Invalid code",
-      });
-      return z.NEVER;
-    }
-  });
-  const inputSchema = z.object({
-    code: codeSchema,
-  });
-  const outputSchema = z.object({
-    data: z.array(z.string()).default([]),
-  });
-  const fnImplementation = async (data: z.infer<typeof inputSchema>): Promise<z.infer<typeof outputSchema>> => {
-    return {
-      data: [data.code],
-    };
-  };
-  const schema = z.function().input([inputSchema]).output(outputSchema);
-
-  const func = schema.implementAsync(fnImplementation);
-  type TheInterface = {
-    myFunction: (data: z.infer<typeof inputSchema>) => Promise<z.infer<typeof outputSchema>>;
-  };
-  const theImplementation: TheInterface = {
-    myFunction: func,
-  };
-  const results = [];
-  try {
-    await theImplementation.myFunction({
-      code: "1234",
-    });
-    results.push("success");
-  } catch (_) {
-    results.push("fail");
-  }
-  try {
-    await func({ data: "asdflkjasdflkjsf" } as any);
-    results.push("success");
-  } catch (_) {
-    results.push("fail");
-  }
-
-  expect(results).toEqual(["success", "fail"]);
-});
-
-test("non async function with async refinements should fail", async () => {
-  const func = z
-    .function()
-    .input([z.string().refine(async (val) => val.length > 10)])
-    .output(z.number().refine(async (val) => val > 10))
-    .implement((val) => {
-      return val.length;
-    });
-
-  const results = [];
-  try {
-    await func("asdasdfasdffasdf");
-    results.push("success");
-  } catch (_) {
-    results.push("fail");
-  }
-
-  expect(results).toEqual(["fail"]);
-});
-
-test("extra parameters with rest", () => {
-  const maxLength5 = z
-    .function()
-    .input([z.string()], z.unknown())
-    .output(z.boolean())
-    .implement((str, _arg, _qewr) => {
-      return str.length <= 5;
-    });
-
-  const filteredList = ["apple", "orange", "pear", "banana", "strawberry"].filter(maxLength5);
-  expect(filteredList.length).toEqual(2);
-});

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

@@ -1,72 +0,0 @@
-import { expect, expectTypeOf, test } from "vitest";
-import * as z from "zod/v4";
-
-function nest<TData extends z.ZodType>(schema: TData) {
-  return z.object({
-    nested: schema,
-  });
-}
-
-test("generics", () => {
-  const a = nest(z.object({ a: z.string() }));
-  type a = z.infer<typeof a>;
-  expectTypeOf<a>().toEqualTypeOf<{ nested: { a: string } }>();
-
-  const b = nest(z.object({ a: z.string().optional() }));
-  type b = z.infer<typeof b>;
-  expectTypeOf<b>().toEqualTypeOf<{ nested: { a?: string | undefined } }>();
-});
-
-test("generics with optional", () => {
-  async function stripOuter<TData extends z.ZodType>(schema: TData, data: unknown) {
-    return z
-      .object({
-        nested: schema.optional(),
-      })
-      .transform((data) => {
-        return data.nested;
-      })
-      .parse({ nested: data });
-  }
-
-  const result = stripOuter(z.object({ a: z.string() }), { a: "asdf" });
-  expectTypeOf<typeof result>().toEqualTypeOf<Promise<{ a: string } | undefined>>();
-});
-
-// test("assignability", () => {
-//   const createSchemaAndParse = <K extends string, VS extends z.ZodString>(key: K, valueSchema: VS, data: unknown) => {
-//     const schema = z.object({
-//       [key]: valueSchema,
-//     });
-//     // return { [key]: valueSchema };
-//     const parsed = schema.parse(data);
-//     return parsed;
-//     // const inferred: z.infer<z.ZodObject<{ [k in K]: VS }>> = parsed;
-//     // return inferred;
-//   };
-//   const parsed = createSchemaAndParse("foo", z.string(), { foo: "" });
-//   expectTypeOf<typeof parsed>().toEqualTypeOf<{ foo: string }>();
-// });
-
-test("nested no undefined", () => {
-  const inner = z.string().or(z.array(z.string()));
-  const outer = z.object({ inner });
-  type outerSchema = z.infer<typeof outer>;
-  expectTypeOf<outerSchema>().toEqualTypeOf<{ inner: string | string[] }>();
-
-  expect(outer.safeParse({ inner: undefined }).success).toEqual(false);
-});
-
-test("generic on output type", () => {
-  const createV4Schema = <Output>(opts: {
-    schema: z.ZodType<Output>;
-  }) => {
-    return opts.schema;
-  };
-
-  createV4Schema({
-    schema: z.object({
-      name: z.string(),
-    }),
-  })?._zod?.output?.name;
-});

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

@@ -1,68 +0,0 @@
-import { expect, expectTypeOf, test } from "vitest";
-import { type ZodCustomStringFormat, hash } from "zod"; // adjust path as needed
-
-test("hash() API — types and runtime across all alg/enc combinations", async () => {
-  const { createHash } = await import("node:crypto");
-
-  type Alg = "md5" | "sha1" | "sha256" | "sha384" | "sha512";
-  // type Enc = "hex" | "base64" | "base64url";
-
-  const toB64Url = (b64: string) => b64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/g, "");
-
-  const makeDigests = (alg: Alg, input: string) => {
-    const buf = createHash(alg).update(input).digest();
-    const hex = buf.toString("hex");
-    const base64 = buf.toString("base64");
-    const base64url = toB64Url(base64);
-    return { hex, base64, base64url };
-  };
-
-  const algs: ReadonlyArray<Alg> = ["md5", "sha1", "sha256", "sha384", "sha512"];
-  const input = "zodasklfjaasdf";
-
-  // --- Type-level checks (ensure the literal format string is encoded in the return type)
-  expectTypeOf(hash("md5")).toEqualTypeOf<ZodCustomStringFormat<"md5_hex">>();
-  expectTypeOf(hash("sha1")).toEqualTypeOf<ZodCustomStringFormat<"sha1_hex">>();
-  expectTypeOf(hash("sha256", { enc: "base64" as const })).toEqualTypeOf<ZodCustomStringFormat<"sha256_base64">>();
-  expectTypeOf(hash("sha384", { enc: "base64url" as const })).toEqualTypeOf<
-    ZodCustomStringFormat<"sha384_base64url">
-  >();
-
-  // Test generic format types are correctly inferred and Enc defaults to "hex"
-  expectTypeOf(hash("sha256")).toEqualTypeOf<ZodCustomStringFormat<"sha256_hex">>();
-
-  // --- Runtime matrix (success + a few sharp-edged failures per combo)
-  for (const alg of algs) {
-    const { hex, base64, base64url } = makeDigests(alg, input);
-
-    // Success cases
-    expect(hash(alg).parse(hex)).toBe(hex); // default enc=hex
-    expect(hash(alg, { enc: "hex" }).parse(hex)).toBe(hex);
-    expect(hash(alg, { enc: "base64" }).parse(base64)).toBe(base64);
-    expect(hash(alg, { enc: "base64url" }).parse(base64url)).toBe(base64url);
-
-    // Failure cases (wrong encoding to schema)
-    expect(() => hash(alg, { enc: "hex" }).parse(base64)).toThrow();
-    expect(() => hash(alg, { enc: "base64" }).parse(hex)).toThrow();
-    expect(() => hash(alg, { enc: "base64url" }).parse(base64)).toThrow();
-
-    // Encoding-specific failures
-    // hex: uppercase allowed, wrong length should fail
-    hash(alg, { enc: "hex" }).parse(hex.toUpperCase());
-    expect(() => hash(alg, { enc: "hex" }).parse(hex.slice(0, -1))).toThrow();
-
-    // base64: missing required padding should fail (only for algorithms that require padding)
-    if (base64.includes("=")) {
-      const base64NoPad = base64.replace(/=+$/g, "");
-      expect(() => hash(alg, { enc: "base64" }).parse(base64NoPad)).toThrow();
-    }
-
-    // base64url: adding padding or using invalid characters should fail
-    expect(() => hash(alg, { enc: "base64url" }).parse(base64url + "=")).toThrow();
-    expect(() => hash(alg, { enc: "base64url" }).parse(base64url + "!")).toThrow();
-
-    // Param object present but enc omitted should still default to hex at runtime
-    const schemaWithEmptyParams = hash(alg, {} as any);
-    expect(schemaWithEmptyParams.parse(hex)).toBe(hex);
-  }
-});