claude-scope 0.1.6 → 0.1.8

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

@@ -1,330 +0,0 @@
-import { expect, expectTypeOf, test } from "vitest";
-import * as z from "zod/v4";
-
-const stringMap = z.map(z.string(), z.string());
-type stringMap = z.infer<typeof stringMap>;
-
-const minTwo = stringMap.min(2);
-const maxTwo = stringMap.max(2);
-const justTwo = stringMap.size(2);
-const nonEmpty = stringMap.nonempty();
-const nonEmptyMax = stringMap.nonempty().max(2);
-
-test("type inference", () => {
-  expectTypeOf<stringMap>().toEqualTypeOf<Map<string, string>>();
-});
-
-test("valid parse", () => {
-  const result = stringMap.safeParse(
-    new Map([
-      ["first", "foo"],
-      ["second", "bar"],
-    ])
-  );
-  expect(result.success).toEqual(true);
-  expect(result.data).toMatchInlineSnapshot(`
-    Map {
-      "first" => "foo",
-      "second" => "bar",
-    }
-  `);
-});
-
-test("valid parse: size-related methods", () => {
-  expect(() => {
-    minTwo.parse(
-      new Map([
-        ["a", "b"],
-        ["c", "d"],
-      ])
-    );
-    minTwo.parse(
-      new Map([
-        ["a", "b"],
-        ["c", "d"],
-        ["e", "f"],
-      ])
-    );
-    maxTwo.parse(
-      new Map([
-        ["a", "b"],
-        ["c", "d"],
-      ])
-    );
-    maxTwo.parse(new Map([["a", "b"]]));
-    justTwo.parse(
-      new Map([
-        ["a", "b"],
-        ["c", "d"],
-      ])
-    );
-    nonEmpty.parse(new Map([["a", "b"]]));
-    nonEmptyMax.parse(
-      new Map([
-        ["a", "b"],
-        ["c", "d"],
-      ])
-    );
-  }).not.toThrow();
-
-  const sizeZeroResult = stringMap.parse(new Map());
-  expect(sizeZeroResult.size).toBe(0);
-
-  const sizeTwoResult = minTwo.parse(
-    new Map([
-      ["a", "b"],
-      ["c", "d"],
-    ])
-  );
-  expect(sizeTwoResult.size).toBe(2);
-});
-
-test("failing when parsing empty map in nonempty ", () => {
-  const result = nonEmpty.safeParse(new Map());
-  expect(result.success).toEqual(false);
-  expect(result.error!.issues.length).toEqual(1);
-  expect(result.error!.issues[0].code).toEqual("too_small");
-});
-
-test("failing when map is bigger than max() ", () => {
-  const result = maxTwo.safeParse(
-    new Map([
-      ["a", "b"],
-      ["c", "d"],
-      ["e", "f"],
-    ])
-  );
-  expect(result.success).toEqual(false);
-  expect(result.error!.issues.length).toEqual(1);
-  expect(result.error!.issues[0].code).toEqual("too_big");
-});
-
-test("valid parse async", async () => {
-  const asyncMap = z.map(
-    z.string().refine(async () => false, "bad key"),
-    z.string().refine(async () => false, "bad value")
-  );
-  const result = await asyncMap.safeParseAsync(new Map([["first", "foo"]]));
-  expect(result.success).toEqual(false);
-  expect(result.error).toMatchInlineSnapshot(`
-    [ZodError: [
-      {
-        "code": "custom",
-        "path": [
-          "first"
-        ],
-        "message": "bad key"
-      },
-      {
-        "code": "custom",
-        "path": [
-          "first"
-        ],
-        "message": "bad value"
-      }
-    ]]
-  `);
-});
-
-test("throws when a Set is given", () => {
-  const result = stringMap.safeParse(new Set([]));
-  expect(result.success).toEqual(false);
-  if (result.success === false) {
-    expect(result.error.issues.length).toEqual(1);
-    expect(result.error.issues[0].code).toEqual("invalid_type");
-  }
-});
-
-test("throws when the given map has invalid key and invalid input", () => {
-  const result = stringMap.safeParse(new Map([[42, Symbol()]]));
-  expect(result.success).toEqual(false);
-  if (result.success === false) {
-    expect(result.error.issues.length).toEqual(2);
-    expect(result.error).toMatchInlineSnapshot(`
-      [ZodError: [
-        {
-          "expected": "string",
-          "code": "invalid_type",
-          "path": [
-            42
-          ],
-          "message": "Invalid input: expected string, received number"
-        },
-        {
-          "expected": "string",
-          "code": "invalid_type",
-          "path": [
-            42
-          ],
-          "message": "Invalid input: expected string, received symbol"
-        }
-      ]]
-    `);
-  }
-});
-
-test("throws when the given map has multiple invalid entries", () => {
-  // const result = stringMap.safeParse(new Map([[42, Symbol()]]));
-
-  const result = stringMap.safeParse(
-    new Map([
-      [1, "foo"],
-      ["bar", 2],
-    ] as [any, any][]) as Map<any, any>
-  );
-
-  // const result = stringMap.safeParse(new Map([[42, Symbol()]]));
-  expect(result.success).toEqual(false);
-  if (result.success === false) {
-    expect(result.error.issues.length).toEqual(2);
-    expect(result.error.issues).toMatchInlineSnapshot(`
-      [
-        {
-          "code": "invalid_type",
-          "expected": "string",
-          "message": "Invalid input: expected string, received number",
-          "path": [
-            1,
-          ],
-        },
-        {
-          "code": "invalid_type",
-          "expected": "string",
-          "message": "Invalid input: expected string, received number",
-          "path": [
-            "bar",
-          ],
-        },
-      ]
-    `);
-  }
-});
-
-test("dirty", async () => {
-  const map = z.map(
-    z.string().refine((val) => val === val.toUpperCase(), {
-      message: "Keys must be uppercase",
-    }),
-    z.string()
-  );
-  const result = await map.spa(
-    new Map([
-      ["first", "foo"],
-      ["second", "bar"],
-    ])
-  );
-  expect(result.success).toEqual(false);
-  if (!result.success) {
-    expect(result.error.issues.length).toEqual(2);
-    expect(result.error).toMatchInlineSnapshot(`
-      [ZodError: [
-        {
-          "code": "custom",
-          "path": [
-            "first"
-          ],
-          "message": "Keys must be uppercase"
-        },
-        {
-          "code": "custom",
-          "path": [
-            "second"
-          ],
-          "message": "Keys must be uppercase"
-        }
-      ]]
-    `);
-  }
-});
-
-test("map with object keys", () => {
-  const map = z.map(
-    z.object({
-      name: z.string(),
-      age: z.number(),
-    }),
-    z.string()
-  );
-  const data = new Map([
-    [{ name: "John", age: 30 }, "foo"],
-    [{ name: "Jane", age: 25 }, "bar"],
-  ]);
-  const result = map.safeParse(data);
-  expect(result.success).toEqual(true);
-  expect(result.data!).toEqual(data);
-
-  const badData = new Map([["bad", "foo"]]);
-  const badResult = map.safeParse(badData);
-  expect(badResult.success).toEqual(false);
-  expect(badResult.error).toMatchInlineSnapshot(`
-    [ZodError: [
-      {
-        "expected": "object",
-        "code": "invalid_type",
-        "path": [
-          "bad"
-        ],
-        "message": "Invalid input: expected object, received string"
-      }
-    ]]
-  `);
-});
-
-test("min/max", async () => {
-  const schema = stringMap.min(4).max(5);
-
-  const r1 = schema.safeParse(
-    new Map([
-      ["a", "a"],
-      ["b", "b"],
-      ["c", "c"],
-      ["d", "d"],
-    ])
-  );
-  expect(r1.success).toEqual(true);
-
-  const r2 = schema.safeParse(
-    new Map([
-      ["a", "a"],
-      ["b", "b"],
-      ["c", "c"],
-    ])
-  );
-  expect(r2.success).toEqual(false);
-  expect(r2.error!.issues).toMatchInlineSnapshot(`
-    [
-      {
-        "code": "too_small",
-        "inclusive": true,
-        "message": "Too small: expected map to have >=4 entries",
-        "minimum": 4,
-        "origin": "map",
-        "path": [],
-      },
-    ]
-  `);
-
-  const r3 = schema.safeParse(
-    new Map([
-      ["a", "a"],
-      ["b", "b"],
-      ["c", "c"],
-      ["d", "d"],
-      ["e", "e"],
-      ["f", "f"],
-    ])
-  );
-  expect(r3.success).toEqual(false);
-  expect(r3.error!.issues).toMatchInlineSnapshot(`
-    [
-      {
-        "code": "too_big",
-        "inclusive": true,
-        "maximum": 5,
-        "message": "Too big: expected map to have <=5 entries",
-        "origin": "map",
-        "path": [],
-      },
-    ]
-  `);
-});

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

@@ -1,21 +0,0 @@
-import { expect, expectTypeOf, test } from "vitest";
-
-import * as z from "zod/v4";
-
-const schema = z.nan();
-
-test("passing validations", () => {
-  schema.parse(Number.NaN);
-  schema.parse(Number("Not a number"));
-  expectTypeOf<typeof schema._output>().toEqualTypeOf<number>();
-});
-
-test("failing validations", () => {
-  expect(() => schema.parse(5)).toThrow();
-  expect(() => schema.parse("John")).toThrow();
-  expect(() => schema.parse(true)).toThrow();
-  expect(() => schema.parse(null)).toThrow();
-  expect(() => schema.parse(undefined)).toThrow();
-  expect(() => schema.parse({})).toThrow();
-  expect(() => schema.parse([])).toThrow();
-});

package/node_modules/zod/src/v4/classic/tests/nested-refine.test.ts

@@ -1,168 +0,0 @@
-import { expect, test } from "vitest";
-import * as z from "zod/v4";
-
-test("nested refinements", () => {
-  const zodSchema = z
-    .object({
-      password: z.string().min(1),
-      nested: z
-        .object({
-          confirm: z
-            .string()
-            .min(1)
-            .refine((value) => value.length > 2, {
-              message: "Confirm length should be > 2",
-            }),
-        })
-        .refine(
-          (data) => {
-            return data.confirm === "bar";
-          },
-          {
-            path: ["confirm"],
-            error: 'Value must be "bar"',
-          }
-        ),
-    })
-    .refine(
-      (data) => {
-        return data.nested.confirm === data.password;
-      },
-      {
-        path: ["nested", "confirm"],
-        error: "Password and confirm must match",
-      }
-    );
-
-  const DATA = {
-    password: "bar",
-    nested: { confirm: "" },
-  };
-  expect(zodSchema.safeParse(DATA)).toMatchInlineSnapshot(`
-    {
-      "error": [ZodError: [
-      {
-        "origin": "string",
-        "code": "too_small",
-        "minimum": 1,
-        "inclusive": true,
-        "path": [
-          "nested",
-          "confirm"
-        ],
-        "message": "Too small: expected string to have >=1 characters"
-      },
-      {
-        "code": "custom",
-        "path": [
-          "nested",
-          "confirm"
-        ],
-        "message": "Confirm length should be > 2"
-      },
-      {
-        "code": "custom",
-        "path": [
-          "nested",
-          "confirm"
-        ],
-        "message": "Value must be \\"bar\\""
-      },
-      {
-        "code": "custom",
-        "path": [
-          "nested",
-          "confirm"
-        ],
-        "message": "Password and confirm must match"
-      }
-    ]],
-      "success": false,
-    }
-  `);
-
-  expect(zodSchema.safeParse(DATA, { jitless: true })).toMatchInlineSnapshot(`
-    {
-      "error": [ZodError: [
-      {
-        "origin": "string",
-        "code": "too_small",
-        "minimum": 1,
-        "inclusive": true,
-        "path": [
-          "nested",
-          "confirm"
-        ],
-        "message": "Too small: expected string to have >=1 characters"
-      },
-      {
-        "code": "custom",
-        "path": [
-          "nested",
-          "confirm"
-        ],
-        "message": "Confirm length should be > 2"
-      },
-      {
-        "code": "custom",
-        "path": [
-          "nested",
-          "confirm"
-        ],
-        "message": "Value must be \\"bar\\""
-      },
-      {
-        "code": "custom",
-        "path": [
-          "nested",
-          "confirm"
-        ],
-        "message": "Password and confirm must match"
-      }
-    ]],
-      "success": false,
-    }
-  `);
-
-  expect(zodSchema["~standard"].validate(DATA)).toMatchInlineSnapshot(`
-    {
-      "issues": [
-        {
-          "code": "too_small",
-          "inclusive": true,
-          "message": "Too small: expected string to have >=1 characters",
-          "minimum": 1,
-          "origin": "string",
-          "path": [
-            "nested",
-            "confirm",
-          ],
-        },
-        {
-          "code": "custom",
-          "message": "Confirm length should be > 2",
-          "path": [
-            "nested",
-            "confirm",
-          ],
-        },
-        {
-          "code": "custom",
-          "message": "Value must be "bar"",
-          "path": [
-            "nested",
-            "confirm",
-          ],
-        },
-        {
-          "code": "custom",
-          "message": "Password and confirm must match",
-          "path": [
-            "nested",
-            "confirm",
-          ],
-        },
-      ],
-    }
-  `);
-});

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

@@ -1,101 +0,0 @@
-import { expect, expectTypeOf, test } from "vitest";
-import { z } from "zod/v4";
-
-test("nonoptional", () => {
-  const schema = z.string().nonoptional();
-  expectTypeOf<typeof schema._input>().toEqualTypeOf<string>();
-  expectTypeOf<typeof schema._output>().toEqualTypeOf<string>();
-
-  const result = schema.safeParse(undefined);
-  expect(result.success).toBe(false);
-  expect(result).toMatchInlineSnapshot(`
-    {
-      "error": [ZodError: [
-      {
-        "expected": "string",
-        "code": "invalid_type",
-        "path": [],
-        "message": "Invalid input: expected string, received undefined"
-      }
-    ]],
-      "success": false,
-    }
-  `);
-});
-
-test("nonoptional with default", () => {
-  const schema = z.string().optional().nonoptional();
-  expectTypeOf<typeof schema._input>().toEqualTypeOf<string>();
-  expectTypeOf<typeof schema._output>().toEqualTypeOf<string>();
-
-  const result = schema.safeParse(undefined);
-  expect(result.success).toBe(false);
-  expect(result).toMatchInlineSnapshot(`
-    {
-      "error": [ZodError: [
-      {
-        "code": "invalid_type",
-        "expected": "nonoptional",
-        "path": [],
-        "message": "Invalid input: expected nonoptional, received undefined"
-      }
-    ]],
-      "success": false,
-    }
-  `);
-});
-
-test("nonoptional in object", () => {
-  const schema = z.object({ hi: z.string().optional().nonoptional() });
-
-  expectTypeOf<typeof schema._input>().toEqualTypeOf<{ hi: string }>();
-  expectTypeOf<typeof schema._output>().toEqualTypeOf<{ hi: string }>();
-  const r1 = schema.safeParse({ hi: "asdf" });
-  expect(r1.success).toEqual(true);
-
-  const r2 = schema.safeParse({ hi: undefined });
-  // expect(schema.safeParse({ hi: undefined }).success).toEqual(false);
-  expect(r2.success).toEqual(false);
-  expect(r2.error).toMatchInlineSnapshot(`
-    [ZodError: [
-      {
-        "code": "invalid_type",
-        "expected": "nonoptional",
-        "path": [
-          "hi"
-        ],
-        "message": "Invalid input: expected nonoptional, received undefined"
-      }
-    ]]
-  `);
-
-  const r3 = schema.safeParse({});
-  expect(r3.success).toEqual(false);
-  expect(r3.error).toMatchInlineSnapshot(`
-    [ZodError: [
-      {
-        "code": "invalid_type",
-        "expected": "nonoptional",
-        "path": [
-          "hi"
-        ],
-        "message": "Invalid input: expected nonoptional, received undefined"
-      }
-    ]]
-  `);
-});
-
-test("encoding", () => {
-  const schema = z.string().optional().nonoptional();
-  expect(z.encode(schema, "hello")).toEqual("hello");
-  expect(() => z.encode(schema, undefined as any)).toThrowErrorMatchingInlineSnapshot(`
-    [ZodError: [
-      {
-        "code": "invalid_type",
-        "expected": "nonoptional",
-        "path": [],
-        "message": "Invalid input: expected nonoptional, received undefined"
-      }
-    ]]
-  `);
-});

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

@@ -1,22 +0,0 @@
-import { expect, test } from "vitest";
-
-import * as z from "zod/v4";
-
-test(".nullable()", () => {
-  const nullable = z.string().nullable();
-  expect(nullable.parse(null)).toBe(null);
-  expect(nullable.parse("asdf")).toBe("asdf");
-  expect(() => nullable.parse(123)).toThrow();
-});
-
-test(".nullable unwrap", () => {
-  const schema = z.string().nullable();
-  expect(schema).toBeInstanceOf(z.ZodNullable);
-  expect(schema.unwrap()).toBeInstanceOf(z.ZodString);
-});
-
-test("z.null", () => {
-  const n = z.null();
-  expect(n.parse(null)).toBe(null);
-  expect(() => n.parse("asdf")).toThrow();
-});