claude-scope 0.1.4 → 0.1.6

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

@@ -0,0 +1,330 @@
+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

@@ -0,0 +1,21 @@
+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

@@ -0,0 +1,168 @@
+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

@@ -0,0 +1,101 @@
+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

@@ -0,0 +1,22 @@
+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();
+});