claude-scope 0.1.4 → 0.1.6

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

@@ -0,0 +1,361 @@
+import { expect, expectTypeOf, test } from "vitest";
+import * as z from "zod/v4";
+
+test("transform ctx.addIssue with parse", () => {
+  const strs = ["foo", "bar"];
+  const schema = z.string().transform((data, ctx) => {
+    const i = strs.indexOf(data);
+    if (i === -1) {
+      ctx.addIssue({
+        input: data,
+        code: "custom",
+        message: `${data} is not one of our allowed strings`,
+      });
+    }
+    return data.length;
+  });
+  const result = schema.safeParse("asdf");
+  expect(result.success).toEqual(false);
+  expect(result.error!).toMatchInlineSnapshot(`
+    [ZodError: [
+      {
+        "code": "custom",
+        "message": "asdf is not one of our allowed strings",
+        "path": []
+      }
+    ]]
+  `);
+});
+
+test("transform ctx.addIssue with parseAsync", async () => {
+  const strs = ["foo", "bar"];
+
+  const result = await z
+    .string()
+    .transform(async (data, ctx) => {
+      const i = strs.indexOf(data);
+      if (i === -1) {
+        ctx.addIssue({
+          input: data,
+          code: "custom",
+          message: `${data} is not one of our allowed strings`,
+        });
+      }
+      return data.length;
+    })
+    .safeParseAsync("asdf");
+
+  expect(result).toMatchInlineSnapshot(`
+    {
+      "error": [ZodError: [
+      {
+        "code": "custom",
+        "message": "asdf is not one of our allowed strings",
+        "path": []
+      }
+    ]],
+      "success": false,
+    }
+  `);
+});
+
+test("z.NEVER in transform", () => {
+  const foo = z
+    .number()
+    .optional()
+    .transform((val, ctx) => {
+      if (!val) {
+        ctx.addIssue({
+          input: val,
+          code: z.ZodIssueCode.custom,
+          message: "bad",
+        });
+        return z.NEVER;
+      }
+      return val;
+    });
+  type foo = z.infer<typeof foo>;
+  expectTypeOf<foo>().toEqualTypeOf<number>();
+  const arg = foo.safeParse(undefined);
+  if (!arg.success) {
+    expect(arg.error.issues[0].message).toEqual("bad");
+  }
+});
+
+test("basic transformations", () => {
+  const r1 = z
+    .string()
+    .transform((data) => data.length)
+    .parse("asdf");
+  expect(r1).toEqual(4);
+});
+
+test("coercion", () => {
+  const numToString = z.number().transform((n) => String(n));
+  const data = z
+    .object({
+      id: numToString,
+    })
+    .parse({ id: 5 });
+
+  expect(data).toEqual({ id: "5" });
+});
+
+test("async coercion", async () => {
+  const numToString = z.number().transform(async (n) => String(n));
+  const data = await z
+    .object({
+      id: numToString,
+    })
+    .parseAsync({ id: 5 });
+
+  expect(data).toEqual({ id: "5" });
+});
+
+test("sync coercion async error", async () => {
+  const asyncNumberToString = z.number().transform(async (n) => String(n));
+  expect(() =>
+    z
+      .object({
+        id: asyncNumberToString,
+      })
+      .parse({ id: 5 })
+  ).toThrow();
+  // expect(data).toEqual({ id: '5' });
+});
+
+test("default", () => {
+  const data = z.string().default("asdf").parse(undefined); // => "asdf"
+  expect(data).toEqual("asdf");
+});
+
+test("dynamic default", () => {
+  const data = z
+    .string()
+    .default(() => "string")
+    .parse(undefined); // => "asdf"
+  expect(data).toEqual("string");
+});
+
+test("default when property is null or undefined", () => {
+  const data = z
+    .object({
+      foo: z.boolean().nullable().default(true),
+      bar: z.boolean().default(true),
+    })
+    .parse({ foo: null });
+
+  expect(data).toEqual({ foo: null, bar: true });
+});
+
+test("default with falsy values", () => {
+  const schema = z.object({
+    emptyStr: z.string().default("def"),
+    zero: z.number().default(5),
+    falseBoolean: z.boolean().default(true),
+  });
+  const input = { emptyStr: "", zero: 0, falseBoolean: true };
+  const output = schema.parse(input);
+  // defaults are not supposed to be used
+  expect(output).toEqual(input);
+});
+
+test("object typing", () => {
+  const stringToNumber = z.string().transform((arg) => Number.parseFloat(arg));
+
+  const t1 = z.object({
+    stringToNumber,
+  });
+
+  type t1 = z.input<typeof t1>;
+  type t2 = z.output<typeof t1>;
+
+  expectTypeOf<t1>().toEqualTypeOf<{ stringToNumber: string }>();
+  expectTypeOf<t2>().toEqualTypeOf<{ stringToNumber: number }>();
+});
+
+test("transform method overloads", () => {
+  const t1 = z.string().transform((val) => val.toUpperCase());
+  expect(t1.parse("asdf")).toEqual("ASDF");
+
+  const t2 = z.string().transform((val) => val.length);
+  expect(t2.parse("asdf")).toEqual(4);
+});
+
+test("multiple transformers", () => {
+  const stringToNumber = z.string().transform((arg) => Number.parseFloat(arg));
+
+  const doubler = stringToNumber.transform((val) => {
+    return val * 2;
+  });
+  expect(doubler.parse("5")).toEqual(10);
+});
+
+test("short circuit on dirty", () => {
+  const schema = z
+    .string()
+    .refine(() => false)
+    .transform((val) => val.toUpperCase());
+  const result = schema.safeParse("asdf");
+  expect(result.success).toEqual(false);
+
+  expect(result.error).toMatchInlineSnapshot(`
+    [ZodError: [
+      {
+        "code": "custom",
+        "path": [],
+        "message": "Invalid input"
+      }
+    ]]
+  `);
+
+  const result2 = schema.safeParse(1234);
+  expect(result2.success).toEqual(false);
+  if (!result2.success) {
+    expect(result2.error.issues[0].code).toEqual(z.ZodIssueCode.invalid_type);
+  }
+});
+
+test("async short circuit on dirty", async () => {
+  const schema = z
+    .string()
+    .refine(() => false)
+    .transform((val) => val.toUpperCase());
+  const result = await schema.spa("asdf");
+  expect(result.success).toEqual(false);
+
+  expect(result.error).toMatchInlineSnapshot(`
+    [ZodError: [
+      {
+        "code": "custom",
+        "path": [],
+        "message": "Invalid input"
+      }
+    ]]
+  `);
+
+  const result2 = await schema.spa(1234);
+  expect(result2.success).toEqual(false);
+
+  expect(result2.error).toMatchInlineSnapshot(`
+    [ZodError: [
+      {
+        "expected": "string",
+        "code": "invalid_type",
+        "path": [],
+        "message": "Invalid input: expected string, received number"
+      }
+    ]]
+  `);
+});
+
+test("do not continue by default", () => {
+  const A = z
+    .string()
+    .transform((val, ctx) => {
+      ctx.addIssue({
+        code: "custom",
+        message: `custom error`,
+      });
+      ctx.addIssue({
+        code: "custom",
+        message: `custom error`,
+      });
+      return val;
+    })
+    .pipe(z.number() as any);
+  expect(A.safeParse("asdf")).toMatchInlineSnapshot(`
+    {
+      "error": [ZodError: [
+      {
+        "code": "custom",
+        "message": "custom error",
+        "path": []
+      },
+      {
+        "code": "custom",
+        "message": "custom error",
+        "path": []
+      }
+    ]],
+      "success": false,
+    }
+  `);
+
+  const B = z
+    .string()
+    .transform((val, ctx) => {
+      ctx.issues.push({
+        code: "custom",
+        message: `custom error`,
+        input: val,
+      });
+      ctx.issues.push({
+        code: "custom",
+        message: `custom error`,
+        input: val,
+      });
+      return val;
+    })
+    .pipe(z.number() as any);
+  expect(B.safeParse("asdf")).toMatchInlineSnapshot(`
+    {
+      "error": [ZodError: [
+      {
+        "code": "custom",
+        "message": "custom error",
+        "path": []
+      },
+      {
+        "code": "custom",
+        "message": "custom error",
+        "path": []
+      }
+    ]],
+      "success": false,
+    }
+  `);
+
+  const C = z
+    .string()
+    .transform((val, ctx) => {
+      ctx.issues.push({
+        code: "custom",
+        message: `custom error`,
+        input: val,
+        continue: true,
+      });
+      ctx.issues.push({
+        code: "custom",
+        message: `custom error`,
+        input: val,
+        continue: true,
+      });
+      return val;
+    })
+    .pipe(z.number() as any);
+  expect(C.safeParse("asdf")).toMatchInlineSnapshot(`
+    {
+      "error": [ZodError: [
+      {
+        "code": "custom",
+        "message": "custom error",
+        "path": []
+      },
+      {
+        "code": "custom",
+        "message": "custom error",
+        "path": []
+      }
+    ]],
+      "success": false,
+    }
+  `);
+});
+
+test("encode error", () => {
+  const schema = z.string().transform((val) => val.length);
+  expect(() => z.encode(schema, 1234)).toThrowErrorMatchingInlineSnapshot(
+    `[ZodEncodeError: Encountered unidirectional transform during encode: ZodTransform]`
+  );
+});

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

@@ -0,0 +1,183 @@
+import { expect, expectTypeOf, test } from "vitest";
+import * as z from "zod/v4";
+
+test("successful validation", () => {
+  const testTuple = z.tuple([z.string(), z.number()]);
+  expectTypeOf<typeof testTuple._output>().toEqualTypeOf<[string, number]>();
+
+  const val = testTuple.parse(["asdf", 1234]);
+  expect(val).toEqual(val);
+
+  const r1 = testTuple.safeParse(["asdf", "asdf"]);
+  expect(r1.success).toEqual(false);
+  expect(r1.error!).toMatchInlineSnapshot(`
+    [ZodError: [
+      {
+        "expected": "number",
+        "code": "invalid_type",
+        "path": [
+          1
+        ],
+        "message": "Invalid input: expected number, received string"
+      }
+    ]]
+  `);
+
+  const r2 = testTuple.safeParse(["asdf", 1234, true]);
+  expect(r2.success).toEqual(false);
+  expect(r2.error!).toMatchInlineSnapshot(`
+    [ZodError: [
+      {
+        "code": "too_big",
+        "maximum": 2,
+        "inclusive": true,
+        "origin": "array",
+        "path": [],
+        "message": "Too big: expected array to have <=2 items"
+      }
+    ]]
+  `);
+
+  const r3 = testTuple.safeParse({});
+  expect(r3.success).toEqual(false);
+  expect(r3.error!).toMatchInlineSnapshot(`
+    [ZodError: [
+      {
+        "expected": "tuple",
+        "code": "invalid_type",
+        "path": [],
+        "message": "Invalid input: expected tuple, received object"
+      }
+    ]]
+  `);
+});
+
+test("async validation", async () => {
+  const testTuple = z
+    .tuple([z.string().refine(async () => true), z.number().refine(async () => true)])
+    .refine(async () => true);
+  expectTypeOf<typeof testTuple._output>().toEqualTypeOf<[string, number]>();
+
+  const val = await testTuple.parseAsync(["asdf", 1234]);
+  expect(val).toEqual(val);
+
+  const r1 = await testTuple.safeParseAsync(["asdf", "asdf"]);
+  expect(r1.success).toEqual(false);
+  expect(r1.error!).toMatchInlineSnapshot(`
+    [ZodError: [
+      {
+        "expected": "number",
+        "code": "invalid_type",
+        "path": [
+          1
+        ],
+        "message": "Invalid input: expected number, received string"
+      }
+    ]]
+  `);
+
+  const r2 = await testTuple.safeParseAsync(["asdf", 1234, true]);
+  expect(r2.success).toEqual(false);
+  expect(r2.error!).toMatchInlineSnapshot(`
+    [ZodError: [
+      {
+        "code": "too_big",
+        "maximum": 2,
+        "inclusive": true,
+        "origin": "array",
+        "path": [],
+        "message": "Too big: expected array to have <=2 items"
+      }
+    ]]
+  `);
+
+  const r3 = await testTuple.safeParseAsync({});
+  expect(r3.success).toEqual(false);
+  expect(r3.error!).toMatchInlineSnapshot(`
+    [ZodError: [
+      {
+        "expected": "tuple",
+        "code": "invalid_type",
+        "path": [],
+        "message": "Invalid input: expected tuple, received object"
+      }
+    ]]
+  `);
+});
+
+test("tuple with optional elements", () => {
+  const myTuple = z.tuple([z.string(), z.number().optional(), z.string().optional()]).rest(z.boolean());
+  expectTypeOf<typeof myTuple._output>().toEqualTypeOf<[string, number?, string?, ...boolean[]]>();
+
+  const goodData = [["asdf"], ["asdf", 1234], ["asdf", 1234, "asdf"], ["asdf", 1234, "asdf", true, false, true]];
+  for (const data of goodData) {
+    expect(myTuple.parse(data)).toEqual(data);
+  }
+
+  const badData = [
+    ["asdf", "asdf"],
+    ["asdf", 1234, "asdf", "asdf"],
+    ["asdf", 1234, "asdf", true, false, "asdf"],
+  ];
+  for (const data of badData) {
+    expect(() => myTuple.parse(data)).toThrow();
+  }
+});
+
+test("tuple with optional elements followed by required", () => {
+  const myTuple = z.tuple([z.string(), z.number().optional(), z.string()]).rest(z.boolean());
+  expectTypeOf<typeof myTuple._output>().toEqualTypeOf<[string, number | undefined, string, ...boolean[]]>();
+
+  const goodData = [
+    ["asdf", 1234, "asdf"],
+    ["asdf", 1234, "asdf", true, false, true],
+  ];
+  for (const data of goodData) {
+    expect(myTuple.parse(data)).toEqual(data);
+  }
+
+  const badData = [
+    ["asdf"],
+    ["asdf", 1234],
+    ["asdf", 1234, "asdf", "asdf"],
+    ["asdf", 1234, "asdf", true, false, "asdf"],
+  ];
+  for (const data of badData) {
+    expect(() => myTuple.parse(data)).toThrow();
+  }
+});
+
+test("tuple with all optional elements", () => {
+  const allOptionalTuple = z.tuple([z.string().optional(), z.number().optional(), z.boolean().optional()]);
+  expectTypeOf<typeof allOptionalTuple._output>().toEqualTypeOf<[string?, number?, boolean?]>();
+
+  // Empty array should be valid (all items optional)
+  expect(allOptionalTuple.parse([])).toEqual([]);
+
+  // Partial arrays should be valid
+  expect(allOptionalTuple.parse(["hello"])).toEqual(["hello"]);
+  expect(allOptionalTuple.parse(["hello", 42])).toEqual(["hello", 42]);
+
+  // Full array should be valid
+  expect(allOptionalTuple.parse(["hello", 42, true])).toEqual(["hello", 42, true]);
+
+  // Array that's too long should fail
+  expect(() => allOptionalTuple.parse(["hello", 42, true, "extra"])).toThrow();
+});
+
+test("tuple with rest schema", () => {
+  const myTuple = z.tuple([z.string(), z.number()]).rest(z.boolean());
+  expect(myTuple.parse(["asdf", 1234, true, false, true])).toEqual(["asdf", 1234, true, false, true]);
+
+  expect(myTuple.parse(["asdf", 1234])).toEqual(["asdf", 1234]);
+
+  expect(() => myTuple.parse(["asdf", 1234, "asdf"])).toThrow();
+  type t1 = z.output<typeof myTuple>;
+
+  expectTypeOf<t1>().toEqualTypeOf<[string, number, ...boolean[]]>();
+});
+
+test("sparse array input", () => {
+  const schema = z.tuple([z.string(), z.number()]);
+  expect(() => schema.parse(new Array(2))).toThrow();
+});