@weavecode/weave 0.0.0-stage → 0.1.1

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

@@ -0,0 +1,34 @@
+import { expect, expectTypeOf, test } from "vitest";
+import * as z from "zod/v4";
+
+test("instanceof", async () => {
+  class Test {}
+  class Subtest extends Test {}
+  abstract class AbstractBar {
+    constructor(public val: string) {}
+  }
+  class Bar extends AbstractBar {}
+
+  const TestSchema = z.instanceof(Test);
+  const SubtestSchema = z.instanceof(Subtest);
+  const AbstractSchema = z.instanceof(AbstractBar);
+  const BarSchema = z.instanceof(Bar);
+
+  TestSchema.parse(new Test());
+  TestSchema.parse(new Subtest());
+  SubtestSchema.parse(new Subtest());
+  AbstractSchema.parse(new Bar("asdf"));
+  const bar = BarSchema.parse(new Bar("asdf"));
+  expect(bar.val).toEqual("asdf");
+
+  await expect(() => SubtestSchema.parse(new Test())).toThrow();
+  await expect(() => TestSchema.parse(12)).toThrow();
+
+  expectTypeOf<Test>().toEqualTypeOf<z.infer<typeof TestSchema>>();
+});
+
+test("instanceof fatal", () => {
+  const schema = z.instanceof(Date).refine((d) => d.toString());
+  const res = schema.safeParse(null);
+  expect(res.success).toBe(false);
+});

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

@@ -0,0 +1,171 @@
+import { expect, expectTypeOf, test } from "vitest";
+import type { util } from "zod/v4/core";
+
+import * as z from "zod/v4";
+
+test("object intersection", () => {
+  const A = z.object({ a: z.string() });
+  const B = z.object({ b: z.string() });
+
+  const C = z.intersection(A, B); // BaseC.merge(HasID);
+  type C = z.infer<typeof C>;
+  expectTypeOf<C>().toEqualTypeOf<{ a: string } & { b: string }>();
+  const data = { a: "foo", b: "foo" };
+  expect(C.parse(data)).toEqual(data);
+  expect(() => C.parse({ a: "foo" })).toThrow();
+});
+
+test("object intersection: loose", () => {
+  const A = z.looseObject({ a: z.string() });
+  const B = z.object({ b: z.string() });
+
+  const C = z.intersection(A, B); // BaseC.merge(HasID);
+  type C = z.infer<typeof C>;
+  expectTypeOf<C>().toEqualTypeOf<{ a: string; [x: string]: unknown } & { b: string }>();
+  const data = { a: "foo", b: "foo", c: "extra" };
+  expect(C.parse(data)).toEqual(data);
+  expect(() => C.parse({ a: "foo" })).toThrow();
+});
+
+test("object intersection: strict", () => {
+  const A = z.strictObject({ a: z.string() });
+  const B = z.object({ b: z.string() });
+
+  const C = z.intersection(A, B); // BaseC.merge(HasID);
+  type C = z.infer<typeof C>;
+  expectTypeOf<C>().toEqualTypeOf<{ a: string } & { b: string }>();
+  const data = { a: "foo", b: "foo", c: "extra" };
+
+  const result = C.safeParse(data);
+  expect(result.success).toEqual(false);
+});
+
+test("deep intersection", () => {
+  const Animal = z.object({
+    properties: z.object({
+      is_animal: z.boolean(),
+    }),
+  });
+  const Cat = z.intersection(
+    z.object({
+      properties: z.object({
+        jumped: z.boolean(),
+      }),
+    }),
+    Animal
+  );
+
+  type Cat = util.Flatten<z.infer<typeof Cat>>;
+  expectTypeOf<Cat>().toEqualTypeOf<{ properties: { is_animal: boolean } & { jumped: boolean } }>();
+  const a = Cat.safeParse({ properties: { is_animal: true, jumped: true } });
+  expect(a.data!.properties).toEqual({ is_animal: true, jumped: true });
+});
+
+test("deep intersection of arrays", async () => {
+  const Author = z.object({
+    posts: z.array(
+      z.object({
+        post_id: z.number(),
+      })
+    ),
+  });
+  const Registry = z.intersection(
+    Author,
+    z.object({
+      posts: z.array(
+        z.object({
+          title: z.string(),
+        })
+      ),
+    })
+  );
+
+  const posts = [
+    { post_id: 1, title: "Novels" },
+    { post_id: 2, title: "Fairy tales" },
+  ];
+  const cat = Registry.parse({ posts });
+  expect(cat.posts).toEqual(posts);
+  const asyncCat = await Registry.parseAsync({ posts });
+  expect(asyncCat.posts).toEqual(posts);
+});
+
+test("invalid intersection types", async () => {
+  const numberIntersection = z.intersection(
+    z.number(),
+    z.number().transform((x) => x + 1)
+  );
+
+  expect(() => {
+    numberIntersection.parse(1234);
+  }).toThrowErrorMatchingInlineSnapshot(`[Error: Unmergable intersection. Error path: []]`);
+});
+
+test("invalid array merge (incompatible lengths)", async () => {
+  const stringArrInt = z.intersection(
+    z.string().array(),
+    z
+      .string()
+      .array()
+      .transform((val) => [...val, "asdf"])
+  );
+
+  expect(() => stringArrInt.safeParse(["asdf", "qwer"])).toThrowErrorMatchingInlineSnapshot(
+    `[Error: Unmergable intersection. Error path: []]`
+  );
+});
+
+test("invalid array merge (incompatible elements)", async () => {
+  const stringArrInt = z.intersection(
+    z.string().array(),
+    z
+      .string()
+      .array()
+      .transform((val) => [...val.slice(0, -1), "asdf"])
+  );
+
+  expect(() => stringArrInt.safeParse(["asdf", "qwer"])).toThrowErrorMatchingInlineSnapshot(
+    `[Error: Unmergable intersection. Error path: [1]]`
+  );
+});
+
+test("invalid object merge", async () => {
+  const Cat = z.object({
+    phrase: z.string().transform((val) => `${val} Meow`),
+  });
+  const Dog = z.object({
+    phrase: z.string().transform((val) => `${val} Woof`),
+  });
+  const CatDog = z.intersection(Cat, Dog);
+
+  expect(() => CatDog.parse({ phrase: "Hello, my name is CatDog." })).toThrowErrorMatchingInlineSnapshot(
+    `[Error: Unmergable intersection. Error path: ["phrase"]]`
+  );
+});
+
+test("invalid deep merge of object and array combination", async () => {
+  const University = z.object({
+    students: z.array(
+      z.object({
+        name: z.string().transform((val) => `Student name: ${val}`),
+      })
+    ),
+  });
+  const Registry = z.intersection(
+    University,
+    z.object({
+      students: z.array(
+        z.object({
+          name: z.string(),
+          surname: z.string(),
+        })
+      ),
+    })
+  );
+
+  const students = [{ name: "John", surname: "Doe" }];
+
+  expect(() => Registry.parse({ students })).toThrowErrorMatchingInlineSnapshot(
+    `[Error: Unmergable intersection. Error path: ["students",0,"name"]]`
+  );
+});

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

@@ -0,0 +1,108 @@
+import { test } from "vitest";
+// import * as z from "zod/v4";
+
+test(() => {});
+// test("overload types", () => {
+//   const schema = z.string().json();
+//   util.assertEqual<typeof schema, z.ZodString>(true);
+//   const schema2 = z.string().json(z.number());
+//   util.assertEqual<typeof schema2, z.ZodPipe<z.ZodTransform<any, string>, z.ZodNumber>>(true);
+//   const r2 = schema2.parse("12");
+//   util.assertEqual<number, typeof r2>(true);
+// });
+// test("parse string to json", async () => {
+//   const Env = z.object({
+//     myJsonConfig: z.string().jsonString(z.object({ foo: z.number() })),
+//     someOtherValue: z.string(),
+//   });
+
+//   expect(
+//     Env.parse({
+//       myJsonConfig: '{ "foo": 123 }',
+//       someOtherValue: "abc",
+//     })
+//   ).toEqual({
+//     myJsonConfig: { foo: 123 },
+//     someOtherValue: "abc",
+//   });
+
+//   const invalidValues = Env.safeParse({
+//     myJsonConfig: '{"foo": "not a number!"}',
+//     someOtherValue: null,
+//   });
+//   expect(JSON.parse(JSON.stringify(invalidValues))).toEqual({
+//     success: false,
+//     error: {
+//       name: "ZodError",
+//       issues: [
+//         {
+//           code: "invalid_type",
+//           expected: "number",
+//           input: "not a number!",
+//           received: "string",
+//           path: ["myJsonConfig", "foo"],
+//           message: "Expected number, received string",
+//         },
+//         {
+//           code: "invalid_type",
+//           expected: "string",
+//           input: null,
+//           received: "null",
+//           path: ["someOtherValue"],
+//           message: "Expected string, received null",
+//         },
+//       ],
+//     },
+//   });
+
+//   const invalidJsonSyntax = Env.safeParse({
+//     myJsonConfig: "This is not valid json",
+//     someOtherValue: null,
+//   });
+//   expect(JSON.parse(JSON.stringify(invalidJsonSyntax))).toMatchObject({
+//     success: false,
+//     error: {
+//       name: "ZodError",
+//       issues: [
+//         {
+//           code: "invalid_string",
+//           input: {
+//             _def: {
+//               catchall: {
+//                 _def: {
+//                   typeName: "ZodNever",
+//                 },
+//               },
+//               typeName: "ZodObject",
+//               unknownKeys: "strip",
+//             },
+//           },
+//           validation: "json",
+//           message: "Invalid json",
+//           path: ["myJsonConfig"],
+//         },
+//         {
+//           code: "invalid_type",
+//           expected: "string",
+//           input: null,
+//           received: "null",
+//           path: ["someOtherValue"],
+//           message: "Expected string, received null",
+//         },
+//       ],
+//     },
+//   });
+// });
+
+// test("no argument", () => {
+//   const schema = z.string().json();
+//   util.assertEqual<typeof schema, z.ZodString>(true);
+//   z.string().json().parse(`{}`);
+//   z.string().json().parse(`null`);
+//   z.string().json().parse(`12`);
+//   z.string().json().parse(`{ "test": "test"}`);
+//   expect(() => z.string().json().parse(`asdf`)).toThrow();
+//   expect(() => z.string().json().parse(`{ "test": undefined }`)).toThrow();
+//   expect(() => z.string().json().parse(`{ "test": 12n }`)).toThrow();
+//   expect(() => z.string().json().parse(`{ test: "test" }`)).toThrow();
+// });

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

@@ -0,0 +1,227 @@
+import { expect, expectTypeOf, test } from "vitest";
+
+import * as z from "zod/v4";
+
+test("opt passthrough", () => {
+  const object = z.object({
+    a: z.lazy(() => z.string()),
+    b: z.lazy(() => z.string().optional()),
+    c: z.lazy(() => z.string().default("default")),
+  });
+
+  type ObjectTypeIn = z.input<typeof object>;
+  expectTypeOf<ObjectTypeIn>().toEqualTypeOf<{
+    a: string;
+    b?: string | undefined;
+    c?: string | undefined;
+  }>();
+
+  type ObjectTypeOut = z.output<typeof object>;
+  expectTypeOf<ObjectTypeOut>().toEqualTypeOf<{
+    a: string;
+    b?: string | undefined;
+    c: string;
+  }>();
+
+  const result = object.parse(
+    {
+      a: "hello",
+      b: undefined,
+    },
+    { jitless: true }
+  );
+  expect(result).toEqual({
+    a: "hello",
+    // b: undefined,
+    c: "default",
+  });
+
+  expect(z.lazy(() => z.string())._zod.optin).toEqual(undefined);
+  expect(z.lazy(() => z.string())._zod.optout).toEqual(undefined);
+
+  expect(z.lazy(() => z.string().optional())._zod.optin).toEqual("optional");
+  expect(z.lazy(() => z.string().optional())._zod.optout).toEqual("optional");
+
+  expect(z.lazy(() => z.string().default("asdf"))._zod.optin).toEqual("optional");
+  expect(z.lazy(() => z.string().default("asdf"))._zod.optout).toEqual(undefined);
+});
+
+//////////////   LAZY   //////////////
+
+test("schema getter", () => {
+  z.lazy(() => z.string()).parse("asdf");
+});
+
+test("lazy proxy", () => {
+  const schema = z.lazy(() => z.string())._zod.innerType.min(6);
+  schema.parse("123456");
+  expect(schema.safeParse("12345").success).toBe(false);
+});
+
+interface Category {
+  name: string;
+  subcategories: Category[];
+}
+
+const testCategory: Category = {
+  name: "I",
+  subcategories: [
+    {
+      name: "A",
+      subcategories: [
+        {
+          name: "1",
+          subcategories: [
+            {
+              name: "a",
+              subcategories: [],
+            },
+          ],
+        },
+      ],
+    },
+  ],
+};
+
+test("recursion with z.lazy", () => {
+  const Category: z.ZodType<Category> = z.lazy(() =>
+    z.object({
+      name: z.string(),
+      subcategories: z.array(Category),
+    })
+  );
+  Category.parse(testCategory);
+});
+
+type LinkedList = null | { value: number; next: LinkedList };
+
+const linkedListExample = {
+  value: 1,
+  next: {
+    value: 2,
+    next: {
+      value: 3,
+      next: {
+        value: 4,
+        next: null,
+      },
+    },
+  },
+};
+
+test("recursive union wit z.lazy", () => {
+  const LinkedListSchema: z.ZodType<LinkedList> = z.lazy(() =>
+    z.union([
+      z.null(),
+      z.object({
+        value: z.number(),
+        next: LinkedListSchema,
+      }),
+    ])
+  );
+  LinkedListSchema.parse(linkedListExample);
+});
+
+interface A {
+  val: number;
+  b: B;
+}
+
+interface B {
+  val: number;
+  a?: A | undefined;
+}
+
+test("mutual recursion with lazy", () => {
+  const Alazy: z.ZodType<A> = z.lazy(() =>
+    z.object({
+      val: z.number(),
+      b: Blazy,
+    })
+  );
+
+  const Blazy: z.ZodType<B> = z.lazy(() =>
+    z.object({
+      val: z.number(),
+      a: Alazy.optional(),
+    })
+  );
+
+  const testData = {
+    val: 1,
+    b: {
+      val: 5,
+      a: {
+        val: 3,
+        b: {
+          val: 4,
+          a: {
+            val: 2,
+            b: {
+              val: 1,
+            },
+          },
+        },
+      },
+    },
+  };
+
+  Alazy.parse(testData);
+  Blazy.parse(testData.b);
+
+  expect(() => Alazy.parse({ val: "asdf" })).toThrow();
+});
+
+// TODO
+test("mutual recursion with cyclical data", () => {
+  const a: any = { val: 1 };
+  const b: any = { val: 2 };
+  a.b = b;
+  b.a = a;
+});
+
+test("complicated self-recursion", () => {
+  const Category = z.object({
+    name: z.string(),
+    age: z.optional(z.number()),
+    get nullself() {
+      return Category.nullable();
+    },
+    get optself() {
+      return Category.optional();
+    },
+    get self() {
+      return Category;
+    },
+    get subcategories() {
+      return z.array(Category);
+    },
+    nested: z.object({
+      get sub() {
+        return Category;
+      },
+    }),
+  });
+
+  type _Category = z.output<typeof Category>;
+});
+
+test("lazy initialization", () => {
+  const a: any = z.lazy(() => a).optional();
+  const b: any = z.lazy(() => b).nullable();
+  const c: any = z.lazy(() => c).default({} as any);
+  const d: any = z.lazy(() => d).prefault({} as any);
+  const e: any = z.lazy(() => e).nonoptional();
+  const f: any = z.lazy(() => f).catch({} as any);
+  const g: any = z.lazy(() => z.object({ g })).readonly();
+
+  const baseCategorySchema = z.object({
+    name: z.string(),
+  });
+  type Category = z.infer<typeof baseCategorySchema> & {
+    subcategories: Category[];
+  };
+  const categorySchema: z.ZodType<Category> = baseCategorySchema.extend({
+    subcategories: z.lazy(() => categorySchema.array()),
+  });
+});

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

@@ -0,0 +1,92 @@
+import { expect, test } from "vitest";
+
+import * as z from "zod/v4";
+
+const literalTuna = z.literal("tuna");
+const literalTunaCustomMessage = z.literal("tuna", {
+  message: "That's not a tuna",
+});
+const literalFortyTwo = z.literal(42);
+const literalTrue = z.literal(true);
+
+test("passing validations", () => {
+  literalTuna.parse("tuna");
+  literalFortyTwo.parse(42);
+  literalTrue.parse(true);
+});
+
+test("failing validations", () => {
+  expect(() => literalTuna.parse("shark")).toThrow();
+  expect(() => literalFortyTwo.parse(43)).toThrow();
+  expect(() => literalTrue.parse(false)).toThrow();
+});
+
+test("invalid_literal should have `input` field with data", () => {
+  const data = "shark";
+  const result = literalTuna.safeParse(data);
+
+  const issue = result.error!.issues[0];
+  expect(issue.code).toBe("invalid_value");
+  expect(issue).toMatchInlineSnapshot(`
+    {
+      "code": "invalid_value",
+      "message": "Invalid input: expected "tuna"",
+      "path": [],
+      "values": [
+        "tuna",
+      ],
+    }
+  `);
+});
+
+test("invalid_literal should return default message", () => {
+  const data = "shark";
+  const result = literalTuna.safeParse(data);
+
+  const issue = result.error!.issues[0];
+  expect(issue.message).toEqual(`Invalid input: expected \"tuna\"`);
+});
+
+test("invalid_literal should return custom message", () => {
+  const data = "shark";
+  const result = literalTunaCustomMessage.safeParse(data);
+
+  const issue = result.error!.issues[0];
+  expect(issue.message).toEqual(`That's not a tuna`);
+});
+
+test("literal default error message", () => {
+  const result = z.literal("Tuna").safeParse("Trout");
+  expect(result.success).toEqual(false);
+  expect(result.error!.issues.length).toEqual(1);
+  expect(result.error).toMatchInlineSnapshot(`
+    [ZodError: [
+      {
+        "code": "invalid_value",
+        "values": [
+          "Tuna"
+        ],
+        "path": [],
+        "message": "Invalid input: expected \\"Tuna\\""
+      }
+    ]]
+  `);
+});
+
+test("literal bigint default error message", () => {
+  const result = z.literal(BigInt(12)).safeParse(BigInt(13));
+  expect(result.success).toBe(false);
+
+  expect(result.error!.issues.length).toEqual(1);
+  expect(result.error!.issues[0].message).toEqual(`Invalid input: expected 12n`);
+});
+
+test(".value getter", () => {
+  expect(z.literal("tuna").value).toEqual("tuna");
+  expect(() => z.literal([1, 2, 3]).value).toThrow();
+});
+
+test("readonly", () => {
+  const a = ["asdf"] as const;
+  z.literal(a);
+});