@farthershore/cli 0.3.10 → 0.3.12

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

@@ -1,60 +0,0 @@
-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);
-});
-
-test("instanceof respects customError", () => {
-  class Test {
-    name!: string;
-  }
-
-  z.config({
-    customError: () => {
-      return "This is invalid!";
-    },
-  });
-
-  const TestSchema = z.instanceof(Test);
-  const result = TestSchema.safeParse("whatever");
-  expect(result.success).toBe(false);
-  if (!result.success) {
-    const issue = result.error.issues[0];
-    expect(issue.code).toBe("invalid_type");
-    if (issue.code === "invalid_type") {
-      expect(issue.expected).toBe("Test");
-    }
-    expect(issue.message).toBe("This is invalid!");
-  }
-
-  z.config({ customError: undefined });
-});

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

@@ -1,198 +0,0 @@
-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 + strip", () => {
-  const A = z.strictObject({ a: z.string() });
-  const B = z.object({ b: z.string() });
-
-  const C = z.intersection(A, B);
-  type C = z.infer<typeof C>;
-  expectTypeOf<C>().toEqualTypeOf<{ a: string } & { b: string }>();
-
-  // Keys recognized by either side should work
-  expect(C.parse({ a: "foo", b: "bar" })).toEqual({ a: "foo", b: "bar" });
-
-  // Extra keys are stripped (follows strip behavior from B)
-  expect(C.parse({ a: "foo", b: "bar", c: "extra" })).toEqual({ a: "foo", b: "bar" });
-});
-
-test("object intersection: strict + strict", () => {
-  const A = z.strictObject({ a: z.string() });
-  const B = z.strictObject({ b: z.string() });
-
-  const C = z.intersection(A, B);
-
-  // Keys recognized by either side should work
-  expect(C.parse({ a: "foo", b: "bar" })).toEqual({ a: "foo", b: "bar" });
-
-  // Keys unrecognized by BOTH sides should error
-  const result = C.safeParse({ a: "foo", b: "bar", c: "extra" });
-  expect(result.error?.issues).toMatchInlineSnapshot(`
-    [
-      {
-        "code": "unrecognized_keys",
-        "keys": [
-          "c",
-        ],
-        "message": "Unrecognized key: "c"",
-        "path": [],
-      },
-    ]
-  `);
-});
-
-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

@@ -1,109 +0,0 @@
-import { expect, test } from "vitest";
-
-test("placeholder test", () => {
-  expect(2).toBe(2);
-});
-// 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

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

@@ -1,117 +0,0 @@
-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);
-});
-
-test("literal pattern", () => {
-  expect(z.literal(1.1)._zod.pattern).toMatchInlineSnapshot(`/\\^\\(1\\\\\\.1\\)\\$/`);
-
-  expect(z.templateLiteral([z.literal(1.1)]).safeParse("1.1")).toMatchInlineSnapshot(`
-    {
-      "data": "1.1",
-      "success": true,
-    }
-  `);
-  expect(z.templateLiteral([z.literal(1.1)]).safeParse("1n1")).toMatchInlineSnapshot(`
-    {
-      "error": [ZodError: [
-      {
-        "code": "invalid_format",
-        "format": "template_literal",
-        "pattern": "^(1\\\\.1)$",
-        "path": [],
-        "message": "Invalid input"
-      }
-    ]],
-      "success": false,
-    }
-  `);
-});