makecoder 1.0.25

package/dist/zod/src/v3/tests/function.test.ts

@@ -0,0 +1,257 @@
+// @ts-ignore TS6133
+import { expect, test } from "vitest";
+
+import * as z from "zod/v3";
+import { util } from "../helpers/util.js";
+
+const args1 = z.tuple([z.string()]);
+const returns1 = z.number();
+const func1 = z.function(args1, returns1);
+
+test("function parsing", () => {
+  const parsed = func1.parse((arg: any) => arg.length);
+  parsed("asdf");
+});
+
+test("parsed function fail 1", () => {
+  const parsed = func1.parse((x: string) => x);
+  expect(() => parsed("asdf")).toThrow();
+});
+
+test("parsed function fail 2", () => {
+  const parsed = func1.parse((x: string) => x);
+  expect(() => parsed(13 as any)).toThrow();
+});
+
+test("function inference 1", () => {
+  type func1 = z.TypeOf<typeof func1>;
+  util.assertEqual<func1, (k: string) => number>(true);
+});
+
+test("method parsing", () => {
+  const methodObject = z.object({
+    property: z.number(),
+    method: z.function().args(z.string()).returns(z.number()),
+  });
+  const methodInstance = {
+    property: 3,
+    method: function (s: string) {
+      return s.length + this.property;
+    },
+  };
+  const parsed = methodObject.parse(methodInstance);
+  expect(parsed.method("length=8")).toBe(11); // 8 length + 3 property
+});
+
+test("async method parsing", async () => {
+  const methodObject = z.object({
+    property: z.number(),
+    method: z.function().args(z.string()).returns(z.promise(z.number())),
+  });
+  const methodInstance = {
+    property: 3,
+    method: async function (s: string) {
+      return s.length + this.property;
+    },
+  };
+  const parsed = methodObject.parse(methodInstance);
+  expect(await parsed.method("length=8")).toBe(11); // 8 length + 3 property
+});
+
+test("args method", () => {
+  const t1 = z.function();
+  type t1 = z.infer<typeof t1>;
+  util.assertEqual<t1, (...args_1: unknown[]) => unknown>(true);
+
+  const t2 = t1.args(z.string());
+  type t2 = z.infer<typeof t2>;
+  util.assertEqual<t2, (arg: string, ...args_1: unknown[]) => unknown>(true);
+
+  const t3 = t2.returns(z.boolean());
+  type t3 = z.infer<typeof t3>;
+  util.assertEqual<t3, (arg: string, ...args_1: unknown[]) => boolean>(true);
+});
+
+const args2 = z.tuple([
+  z.object({
+    f1: z.number(),
+    f2: z.string().nullable(),
+    f3: z.array(z.boolean().optional()).optional(),
+  }),
+]);
+const returns2 = z.union([z.string(), z.number()]);
+
+const func2 = z.function(args2, returns2);
+
+test("function inference 2", () => {
+  type func2 = z.TypeOf<typeof func2>;
+  util.assertEqual<
+    func2,
+    (arg: {
+      f1: number;
+      f2: string | null;
+      f3?: (boolean | undefined)[] | undefined;
+    }) => string | number
+  >(true);
+});
+
+test("valid function run", () => {
+  const validFunc2Instance = func2.validate((_x) => {
+    return "adf" as any;
+  });
+
+  const checker = () => {
+    validFunc2Instance({
+      f1: 21,
+      f2: "asdf",
+      f3: [true, false],
+    });
+  };
+
+  checker();
+});
+
+test("input validation error", () => {
+  const invalidFuncInstance = func2.validate((_x) => {
+    return "adf" as any;
+  });
+
+  const checker = () => {
+    invalidFuncInstance("Invalid_input" as any);
+  };
+
+  expect(checker).toThrow();
+});
+
+test("output validation error", () => {
+  const invalidFuncInstance = func2.validate((_x) => {
+    return ["this", "is", "not", "valid", "output"] as any;
+  });
+
+  const checker = () => {
+    invalidFuncInstance({
+      f1: 21,
+      f2: "asdf",
+      f3: [true, false],
+    });
+  };
+
+  expect(checker).toThrow();
+});
+
+z.function(z.tuple([z.string()])).args()._def.args;
+
+test("special function error codes", () => {
+  const checker = z.function(z.tuple([z.string()]), z.boolean()).implement((arg) => {
+    return arg.length as any;
+  });
+  try {
+    checker("12" as any);
+  } catch (err) {
+    const zerr = err as z.ZodError;
+    const first = zerr.issues[0];
+    if (first.code !== z.ZodIssueCode.invalid_return_type) throw new Error();
+
+    expect(first.returnTypeError).toBeInstanceOf(z.ZodError);
+  }
+
+  try {
+    checker(12 as any);
+  } catch (err) {
+    const zerr = err as z.ZodError;
+    const first = zerr.issues[0];
+    if (first.code !== z.ZodIssueCode.invalid_arguments) throw new Error();
+    expect(first.argumentsError).toBeInstanceOf(z.ZodError);
+  }
+});
+
+test("function with async refinements", async () => {
+  const func = z
+    .function()
+    .args(z.string().refine(async (val) => val.length > 10))
+    .returns(z.promise(z.number().refine(async (val) => val > 10)))
+    .implement(async (val) => {
+      return val.length;
+    });
+  const results = [];
+  try {
+    await func("asdfasdf");
+    results.push("success");
+  } catch (_err) {
+    results.push("fail");
+  }
+  try {
+    await func("asdflkjasdflkjsf");
+    results.push("success");
+  } catch (_err) {
+    results.push("fail");
+  }
+
+  expect(results).toEqual(["fail", "success"]);
+});
+
+test("non async function with async refinements should fail", async () => {
+  const func = z
+    .function()
+    .args(z.string().refine(async (val) => val.length > 10))
+    .returns(z.number().refine(async (val) => val > 10))
+    .implement((val) => {
+      return val.length;
+    });
+
+  const results = [];
+  try {
+    await func("asdasdfasdffasdf");
+    results.push("success");
+  } catch (_err) {
+    results.push("fail");
+  }
+
+  expect(results).toEqual(["fail"]);
+});
+
+test("allow extra parameters", () => {
+  const maxLength5 = z
+    .function()
+    .args(z.string())
+    .returns(z.boolean())
+    .implement((str, _arg, _qewr) => {
+      return str.length <= 5;
+    });
+
+  const filteredList = ["apple", "orange", "pear", "banana", "strawberry"].filter(maxLength5);
+  expect(filteredList.length).toEqual(2);
+});
+
+test("params and returnType getters", () => {
+  const func = z.function().args(z.string()).returns(z.string());
+
+  func.parameters().items[0].parse("asdf");
+  func.returnType().parse("asdf");
+});
+
+test("inference with transforms", () => {
+  const funcSchema = z
+    .function()
+    .args(z.string().transform((val) => val.length))
+    .returns(z.object({ val: z.number() }));
+  const myFunc = funcSchema.implement((val) => {
+    return { val, extra: "stuff" };
+  });
+  myFunc("asdf");
+
+  util.assertEqual<typeof myFunc, (arg: string, ...args_1: unknown[]) => { val: number; extra: string }>(true);
+});
+
+test("fallback to OuterTypeOfFunction", () => {
+  const funcSchema = z
+    .function()
+    .args(z.string().transform((val) => val.length))
+    .returns(z.object({ arg: z.number() }).transform((val) => val.arg));
+
+  const myFunc = funcSchema.implement((val) => {
+    return { arg: val, arg2: false };
+  });
+
+  util.assertEqual<typeof myFunc, (arg: string, ...args_1: unknown[]) => number>(true);
+});

package/dist/zod/src/v3/tests/generics.test.ts

@@ -0,0 +1,48 @@
+// @ts-ignore TS6133
+import { expect, test } from "vitest";
+
+import * as z from "zod/v3";
+import { util } from "../helpers/util.js";
+
+test("generics", () => {
+  async function stripOuter<TData extends z.ZodTypeAny>(schema: TData, data: unknown) {
+    return z
+      .object({
+        nested: schema, // as z.ZodTypeAny,
+      })
+      .transform((data) => {
+        return data.nested!;
+      })
+      .parse({ nested: data });
+  }
+
+  const result = stripOuter(z.object({ a: z.string() }), { a: "asdf" });
+  util.assertEqual<typeof result, Promise<{ a: string }>>(true);
+});
+
+// test("assignability", () => {
+//   const createSchemaAndParse = <K extends string, VS extends z.ZodString>(
+//     key: K,
+//     valueSchema: VS,
+//     data: unknown
+//   ) => {
+//     const schema = z.object({
+//       [key]: valueSchema,
+//     } as { [k in K]: VS });
+//     return { [key]: valueSchema };
+//     const parsed = schema.parse(data);
+//     return parsed;
+//     // const inferred: z.infer<z.ZodObject<{ [k in K]: VS }>> = parsed;
+//     // return inferred;
+//   };
+//   const parsed = createSchemaAndParse("foo", z.string(), { foo: "" });
+//   util.assertEqual<typeof parsed, { foo: string }>(true);
+// });
+
+test("nested no undefined", () => {
+  const inner = z.string().or(z.array(z.string()));
+  const outer = z.object({ inner });
+  type outerSchema = z.infer<typeof outer>;
+  z.util.assertEqual<outerSchema, { inner: string | string[] }>(true);
+  expect(outer.safeParse({ inner: undefined }).success).toEqual(false);
+});

package/dist/zod/src/v3/tests/instanceof.test.ts

@@ -0,0 +1,37 @@
+// @ts-ignore TS6133
+import { expect, test } from "vitest";
+
+import * as z from "zod/v3";
+import { util } from "../helpers/util.js";
+
+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(/Input not instance of Subtest/);
+  await expect(() => TestSchema.parse(12)).toThrow(/Input not instance of Test/);
+
+  util.assertEqual<Test, z.infer<typeof TestSchema>>(true);
+});
+
+test("instanceof fatal", () => {
+  const schema = z.instanceof(Date).refine((d) => d.toString());
+  const res = schema.safeParse(null);
+  expect(res.success).toBe(false);
+});

package/dist/zod/src/v3/tests/intersection.test.ts

@@ -0,0 +1,110 @@
+// @ts-ignore TS6133
+import { expect, test } from "vitest";
+
+import * as z from "zod/v3";
+
+test("object intersection", () => {
+  const BaseTeacher = z.object({
+    subjects: z.array(z.string()),
+  });
+  const HasID = z.object({ id: z.string() });
+
+  const Teacher = z.intersection(BaseTeacher.passthrough(), HasID); // BaseTeacher.merge(HasID);
+  const data = {
+    subjects: ["math"],
+    id: "asdfasdf",
+  };
+  expect(Teacher.parse(data)).toEqual(data);
+  expect(() => Teacher.parse({ subject: data.subjects })).toThrow();
+  expect(Teacher.parse({ ...data, extra: 12 })).toEqual({ ...data, extra: 12 });
+
+  expect(() => z.intersection(BaseTeacher.strict(), HasID).parse({ ...data, extra: 12 })).toThrow();
+});
+
+test("deep intersection", () => {
+  const Animal = z.object({
+    properties: z.object({
+      is_animal: z.boolean(),
+    }),
+  });
+  const Cat = z
+    .object({
+      properties: z.object({
+        jumped: z.boolean(),
+      }),
+    })
+    .and(Animal);
+
+  type _Cat = z.infer<typeof Cat>;
+  // const cat:Cat = 'asdf' as any;
+  const cat = Cat.parse({ properties: { is_animal: true, jumped: true } });
+  expect(cat.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
+    .object({
+      posts: z.array(
+        z.object({
+          title: z.string(),
+        })
+      ),
+    })
+    .and(Author);
+
+  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)
+  );
+
+  const syncResult = numberIntersection.safeParse(1234);
+  expect(syncResult.success).toEqual(false);
+  if (!syncResult.success) {
+    expect(syncResult.error.issues[0].code).toEqual(z.ZodIssueCode.invalid_intersection_types);
+  }
+
+  const asyncResult = await numberIntersection.spa(1234);
+  expect(asyncResult.success).toEqual(false);
+  if (!asyncResult.success) {
+    expect(asyncResult.error.issues[0].code).toEqual(z.ZodIssueCode.invalid_intersection_types);
+  }
+});
+
+test("invalid array merge", async () => {
+  const stringArrInt = z.intersection(
+    z.string().array(),
+    z
+      .string()
+      .array()
+      .transform((val) => [...val, "asdf"])
+  );
+  const syncResult = stringArrInt.safeParse(["asdf", "qwer"]);
+  expect(syncResult.success).toEqual(false);
+  if (!syncResult.success) {
+    expect(syncResult.error.issues[0].code).toEqual(z.ZodIssueCode.invalid_intersection_types);
+  }
+
+  const asyncResult = await stringArrInt.spa(["asdf", "qwer"]);
+  expect(asyncResult.success).toEqual(false);
+  if (!asyncResult.success) {
+    expect(asyncResult.error.issues[0].code).toEqual(z.ZodIssueCode.invalid_intersection_types);
+  }
+});

package/dist/zod/src/v3/tests/language-server.source.ts

@@ -0,0 +1,76 @@
+import * as z from "zod/v3";
+
+export const filePath = __filename;
+
+// z.object()
+
+export const Test = z.object({
+  f1: z.number(),
+});
+
+export type Test = z.infer<typeof Test>;
+
+export const instanceOfTest: Test = {
+  f1: 1,
+};
+
+// z.object().merge()
+
+export const TestMerge = z
+  .object({
+    f2: z.string().optional(),
+  })
+  .merge(Test);
+
+export type TestMerge = z.infer<typeof TestMerge>;
+
+export const instanceOfTestMerge: TestMerge = {
+  f1: 1,
+  f2: "string",
+};
+
+// z.union()
+
+export const TestUnion = z.union([
+  z.object({
+    f2: z.string().optional(),
+  }),
+  Test,
+]);
+
+export type TestUnion = z.infer<typeof TestUnion>;
+
+export const instanceOfTestUnion: TestUnion = {
+  f1: 1,
+  f2: "string",
+};
+
+// z.object().partial()
+
+export const TestPartial = Test.partial();
+
+export type TestPartial = z.infer<typeof TestPartial>;
+
+export const instanceOfTestPartial: TestPartial = {
+  f1: 1,
+};
+
+// z.object().pick()
+
+export const TestPick = TestMerge.pick({ f1: true });
+
+export type TestPick = z.infer<typeof TestPick>;
+
+export const instanceOfTestPick: TestPick = {
+  f1: 1,
+};
+
+// z.object().omit()
+
+export const TestOmit = TestMerge.omit({ f2: true });
+
+export type TestOmit = z.infer<typeof TestOmit>;
+
+export const instanceOfTestOmit: TestOmit = {
+  f1: 1,
+};