@auto-ai/agent 2.1.104 → 2.1.105

package/tools-runtime/code-tool/node_modules/zod/src/v3/tests/primitive.test.ts

@@ -1,440 +0,0 @@
-// @ts-ignore TS6133
-import { expect, test } from "vitest";
-
-import * as z from "zod/v3";
-import { util } from "../helpers/util.js";
-import { Mocker } from "./Mocker.js";
-
-const literalStringSchema = z.literal("asdf");
-const literalNumberSchema = z.literal(12);
-const literalBooleanSchema = z.literal(true);
-const literalBigIntSchema = z.literal(BigInt(42));
-const MySymbol = Symbol("stuff");
-const literalSymbolSchema = z.literal(MySymbol);
-const stringSchema = z.string();
-const numberSchema = z.number();
-const bigintSchema = z.bigint();
-const booleanSchema = z.boolean();
-const dateSchema = z.date();
-const symbolSchema = z.symbol();
-
-const nullSchema = z.null();
-const undefinedSchema = z.undefined();
-const stringSchemaOptional = z.string().optional();
-const stringSchemaNullable = z.string().nullable();
-const numberSchemaOptional = z.number().optional();
-const numberSchemaNullable = z.number().nullable();
-const bigintSchemaOptional = z.bigint().optional();
-const bigintSchemaNullable = z.bigint().nullable();
-const booleanSchemaOptional = z.boolean().optional();
-const booleanSchemaNullable = z.boolean().nullable();
-const dateSchemaOptional = z.date().optional();
-const dateSchemaNullable = z.date().nullable();
-const symbolSchemaOptional = z.symbol().optional();
-const symbolSchemaNullable = z.symbol().nullable();
-
-const val = new Mocker();
-
-test("literal string correct", () => {
-  expect(literalStringSchema.parse("asdf")).toBe("asdf");
-});
-
-test("literal string incorrect", () => {
-  const f = () => literalStringSchema.parse("not_asdf");
-  expect(f).toThrow();
-});
-
-test("literal string number", () => {
-  const f = () => literalStringSchema.parse(123);
-  expect(f).toThrow();
-});
-
-test("literal string boolean", () => {
-  const f = () => literalStringSchema.parse(true);
-  expect(f).toThrow();
-});
-
-test("literal string boolean", () => {
-  const f = () => literalStringSchema.parse(true);
-  expect(f).toThrow();
-});
-
-test("literal string object", () => {
-  const f = () => literalStringSchema.parse({});
-  expect(f).toThrow();
-});
-
-test("literal number correct", () => {
-  expect(literalNumberSchema.parse(12)).toBe(12);
-});
-
-test("literal number incorrect", () => {
-  const f = () => literalNumberSchema.parse(13);
-  expect(f).toThrow();
-});
-
-test("literal number number", () => {
-  const f = () => literalNumberSchema.parse(val.string);
-  expect(f).toThrow();
-});
-
-test("literal number boolean", () => {
-  const f = () => literalNumberSchema.parse(val.boolean);
-  expect(f).toThrow();
-});
-
-test("literal number object", () => {
-  const f = () => literalStringSchema.parse({});
-  expect(f).toThrow();
-});
-
-test("literal boolean correct", () => {
-  expect(literalBooleanSchema.parse(true)).toBe(true);
-});
-
-test("literal boolean incorrect", () => {
-  const f = () => literalBooleanSchema.parse(false);
-  expect(f).toThrow();
-});
-
-test("literal boolean number", () => {
-  const f = () => literalBooleanSchema.parse("asdf");
-  expect(f).toThrow();
-});
-
-test("literal boolean boolean", () => {
-  const f = () => literalBooleanSchema.parse(123);
-  expect(f).toThrow();
-});
-
-test("literal boolean object", () => {
-  const f = () => literalBooleanSchema.parse({});
-  expect(f).toThrow();
-});
-
-test("literal bigint correct", () => {
-  expect(literalBigIntSchema.parse(BigInt(42))).toBe(BigInt(42));
-});
-
-test("literal bigint incorrect", () => {
-  const f = () => literalBigIntSchema.parse(BigInt(43));
-  expect(f).toThrow();
-});
-
-test("literal bigint number", () => {
-  const f = () => literalBigIntSchema.parse("asdf");
-  expect(f).toThrow();
-});
-
-test("literal bigint boolean", () => {
-  const f = () => literalBigIntSchema.parse(123);
-  expect(f).toThrow();
-});
-
-test("literal bigint object", () => {
-  const f = () => literalBigIntSchema.parse({});
-  expect(f).toThrow();
-});
-
-test("literal symbol", () => {
-  util.assertEqual<z.infer<typeof literalSymbolSchema>, typeof MySymbol>(true);
-  literalSymbolSchema.parse(MySymbol);
-  expect(() => literalSymbolSchema.parse(Symbol("asdf"))).toThrow();
-});
-
-test("parse stringSchema string", () => {
-  stringSchema.parse(val.string);
-});
-
-test("parse stringSchema number", () => {
-  const f = () => stringSchema.parse(val.number);
-  expect(f).toThrow();
-});
-
-test("parse stringSchema boolean", () => {
-  const f = () => stringSchema.parse(val.boolean);
-  expect(f).toThrow();
-});
-
-test("parse stringSchema undefined", () => {
-  const f = () => stringSchema.parse(val.undefined);
-  expect(f).toThrow();
-});
-
-test("parse stringSchema null", () => {
-  const f = () => stringSchema.parse(val.null);
-  expect(f).toThrow();
-});
-
-test("parse numberSchema string", () => {
-  const f = () => numberSchema.parse(val.string);
-  expect(f).toThrow();
-});
-
-test("parse numberSchema number", () => {
-  numberSchema.parse(val.number);
-});
-
-test("parse numberSchema bigint", () => {
-  const f = () => numberSchema.parse(val.bigint);
-  expect(f).toThrow();
-});
-
-test("parse numberSchema boolean", () => {
-  const f = () => numberSchema.parse(val.boolean);
-  expect(f).toThrow();
-});
-
-test("parse numberSchema undefined", () => {
-  const f = () => numberSchema.parse(val.undefined);
-  expect(f).toThrow();
-});
-
-test("parse numberSchema null", () => {
-  const f = () => numberSchema.parse(val.null);
-  expect(f).toThrow();
-});
-
-test("parse bigintSchema string", () => {
-  const f = () => bigintSchema.parse(val.string);
-  expect(f).toThrow();
-});
-
-test("parse bigintSchema number", () => {
-  const f = () => bigintSchema.parse(val.number);
-  expect(f).toThrow();
-});
-
-test("parse bigintSchema bigint", () => {
-  bigintSchema.parse(val.bigint);
-});
-
-test("parse bigintSchema boolean", () => {
-  const f = () => bigintSchema.parse(val.boolean);
-  expect(f).toThrow();
-});
-
-test("parse bigintSchema undefined", () => {
-  const f = () => bigintSchema.parse(val.undefined);
-  expect(f).toThrow();
-});
-
-test("parse bigintSchema null", () => {
-  const f = () => bigintSchema.parse(val.null);
-  expect(f).toThrow();
-});
-
-test("parse booleanSchema string", () => {
-  const f = () => booleanSchema.parse(val.string);
-  expect(f).toThrow();
-});
-
-test("parse booleanSchema number", () => {
-  const f = () => booleanSchema.parse(val.number);
-  expect(f).toThrow();
-});
-
-test("parse booleanSchema boolean", () => {
-  booleanSchema.parse(val.boolean);
-});
-
-test("parse booleanSchema undefined", () => {
-  const f = () => booleanSchema.parse(val.undefined);
-  expect(f).toThrow();
-});
-
-test("parse booleanSchema null", () => {
-  const f = () => booleanSchema.parse(val.null);
-  expect(f).toThrow();
-});
-
-// ==============
-
-test("parse dateSchema string", () => {
-  const f = () => dateSchema.parse(val.string);
-  expect(f).toThrow();
-});
-
-test("parse dateSchema number", () => {
-  const f = () => dateSchema.parse(val.number);
-  expect(f).toThrow();
-});
-
-test("parse dateSchema boolean", () => {
-  const f = () => dateSchema.parse(val.boolean);
-  expect(f).toThrow();
-});
-
-test("parse dateSchema date", () => {
-  dateSchema.parse(val.date);
-});
-
-test("parse dateSchema undefined", () => {
-  const f = () => dateSchema.parse(val.undefined);
-  expect(f).toThrow();
-});
-
-test("parse dateSchema null", () => {
-  const f = () => dateSchema.parse(val.null);
-  expect(f).toThrow();
-});
-
-test("parse dateSchema invalid date", async () => {
-  try {
-    await dateSchema.parseAsync(new Date("invalid"));
-  } catch (err) {
-    expect((err as z.ZodError).issues[0].code).toEqual(z.ZodIssueCode.invalid_date);
-  }
-});
-// ==============
-
-test("parse symbolSchema string", () => {
-  const f = () => symbolSchema.parse(val.string);
-  expect(f).toThrow();
-});
-
-test("parse symbolSchema number", () => {
-  const f = () => symbolSchema.parse(val.number);
-  expect(f).toThrow();
-});
-
-test("parse symbolSchema boolean", () => {
-  const f = () => symbolSchema.parse(val.boolean);
-  expect(f).toThrow();
-});
-
-test("parse symbolSchema date", () => {
-  const f = () => symbolSchema.parse(val.date);
-  expect(f).toThrow();
-});
-
-test("parse symbolSchema symbol", () => {
-  symbolSchema.parse(val.symbol);
-});
-
-test("parse symbolSchema undefined", () => {
-  const f = () => symbolSchema.parse(val.undefined);
-  expect(f).toThrow();
-});
-
-test("parse symbolSchema null", () => {
-  const f = () => symbolSchema.parse(val.null);
-  expect(f).toThrow();
-});
-
-// ==============
-
-test("parse undefinedSchema string", () => {
-  const f = () => undefinedSchema.parse(val.string);
-  expect(f).toThrow();
-});
-
-test("parse undefinedSchema number", () => {
-  const f = () => undefinedSchema.parse(val.number);
-  expect(f).toThrow();
-});
-
-test("parse undefinedSchema boolean", () => {
-  const f = () => undefinedSchema.parse(val.boolean);
-  expect(f).toThrow();
-});
-
-test("parse undefinedSchema undefined", () => {
-  undefinedSchema.parse(val.undefined);
-});
-
-test("parse undefinedSchema null", () => {
-  const f = () => undefinedSchema.parse(val.null);
-  expect(f).toThrow();
-});
-
-test("parse nullSchema string", () => {
-  const f = () => nullSchema.parse(val.string);
-  expect(f).toThrow();
-});
-
-test("parse nullSchema number", () => {
-  const f = () => nullSchema.parse(val.number);
-  expect(f).toThrow();
-});
-
-test("parse nullSchema boolean", () => {
-  const f = () => nullSchema.parse(val.boolean);
-  expect(f).toThrow();
-});
-
-test("parse nullSchema undefined", () => {
-  const f = () => nullSchema.parse(val.undefined);
-  expect(f).toThrow();
-});
-
-test("parse nullSchema null", () => {
-  nullSchema.parse(val.null);
-});
-
-test("primitive inference", () => {
-  util.assertEqual<z.TypeOf<typeof literalStringSchema>, "asdf">(true);
-  util.assertEqual<z.TypeOf<typeof literalNumberSchema>, 12>(true);
-  util.assertEqual<z.TypeOf<typeof literalBooleanSchema>, true>(true);
-  util.assertEqual<z.TypeOf<typeof literalBigIntSchema>, bigint>(true);
-  util.assertEqual<z.TypeOf<typeof stringSchema>, string>(true);
-  util.assertEqual<z.TypeOf<typeof numberSchema>, number>(true);
-  util.assertEqual<z.TypeOf<typeof bigintSchema>, bigint>(true);
-  util.assertEqual<z.TypeOf<typeof booleanSchema>, boolean>(true);
-  util.assertEqual<z.TypeOf<typeof dateSchema>, Date>(true);
-  util.assertEqual<z.TypeOf<typeof symbolSchema>, symbol>(true);
-
-  util.assertEqual<z.TypeOf<typeof nullSchema>, null>(true);
-  util.assertEqual<z.TypeOf<typeof undefinedSchema>, undefined>(true);
-  util.assertEqual<z.TypeOf<typeof stringSchemaOptional>, string | undefined>(true);
-  util.assertEqual<z.TypeOf<typeof stringSchemaNullable>, string | null>(true);
-  util.assertEqual<z.TypeOf<typeof numberSchemaOptional>, number | undefined>(true);
-  util.assertEqual<z.TypeOf<typeof numberSchemaNullable>, number | null>(true);
-  util.assertEqual<z.TypeOf<typeof bigintSchemaOptional>, bigint | undefined>(true);
-  util.assertEqual<z.TypeOf<typeof bigintSchemaNullable>, bigint | null>(true);
-  util.assertEqual<z.TypeOf<typeof booleanSchemaOptional>, boolean | undefined>(true);
-  util.assertEqual<z.TypeOf<typeof booleanSchemaNullable>, boolean | null>(true);
-  util.assertEqual<z.TypeOf<typeof dateSchemaOptional>, Date | undefined>(true);
-  util.assertEqual<z.TypeOf<typeof dateSchemaNullable>, Date | null>(true);
-  util.assertEqual<z.TypeOf<typeof symbolSchemaOptional>, symbol | undefined>(true);
-  util.assertEqual<z.TypeOf<typeof symbolSchemaNullable>, symbol | null>(true);
-
-  // [
-  //   literalStringSchemaTest,
-  //   literalNumberSchemaTest,
-  //   literalBooleanSchemaTest,
-  //   literalBigIntSchemaTest,
-  //   stringSchemaTest,
-  //   numberSchemaTest,
-  //   bigintSchemaTest,
-  //   booleanSchemaTest,
-  //   dateSchemaTest,
-  //   symbolSchemaTest,
-
-  //   nullSchemaTest,
-  //   undefinedSchemaTest,
-  //   stringSchemaOptionalTest,
-  //   stringSchemaNullableTest,
-  //   numberSchemaOptionalTest,
-  //   numberSchemaNullableTest,
-  //   bigintSchemaOptionalTest,
-  //   bigintSchemaNullableTest,
-  //   booleanSchemaOptionalTest,
-  //   booleanSchemaNullableTest,
-  //   dateSchemaOptionalTest,
-  //   dateSchemaNullableTest,
-  //   symbolSchemaOptionalTest,
-  //   symbolSchemaNullableTest,
-
-  // ];
-});
-
-test("get literal value", () => {
-  expect(literalStringSchema.value).toEqual("asdf");
-});
-
-test("optional convenience method", () => {
-  z.ostring().parse(undefined);
-  z.onumber().parse(undefined);
-  z.oboolean().parse(undefined);
-});

package/tools-runtime/code-tool/node_modules/zod/src/v3/tests/promise.test.ts

@@ -1,90 +0,0 @@
-// @ts-ignore TS6133
-import { expect, test } from "vitest";
-
-import * as z from "zod/v3";
-import { util } from "../helpers/util.js";
-
-const promSchema = z.promise(
-  z.object({
-    name: z.string(),
-    age: z.number(),
-  })
-);
-
-test("promise inference", () => {
-  type promSchemaType = z.infer<typeof promSchema>;
-  util.assertEqual<promSchemaType, Promise<{ name: string; age: number }>>(true);
-});
-
-test("promise parsing success", async () => {
-  const pr = promSchema.parse(Promise.resolve({ name: "Bobby", age: 10 }));
-  expect(pr).toBeInstanceOf(Promise);
-  const result = await pr;
-  expect(typeof result).toBe("object");
-  expect(typeof result.age).toBe("number");
-  expect(typeof result.name).toBe("string");
-});
-
-test("promise parsing success 2", () => {
-  const fakePromise = {
-    then() {
-      return this;
-    },
-    catch() {
-      return this;
-    },
-  };
-  promSchema.parse(fakePromise);
-});
-
-test("promise parsing fail", async () => {
-  const bad = promSchema.parse(Promise.resolve({ name: "Bobby", age: "10" }));
-  // return await expect(bad).resolves.toBe({ name: 'Bobby', age: '10' });
-  return await expect(bad).rejects.toBeInstanceOf(z.ZodError);
-  // done();
-});
-
-test("promise parsing fail 2", async () => {
-  const failPromise = promSchema.parse(Promise.resolve({ name: "Bobby", age: "10" }));
-  await expect(failPromise).rejects.toBeInstanceOf(z.ZodError);
-  // done();/z
-});
-
-test("promise parsing fail", () => {
-  const bad = () => promSchema.parse({ then: () => {}, catch: {} });
-  expect(bad).toThrow();
-});
-
-// test('sync promise parsing', () => {
-//   expect(() => z.promise(z.string()).parse(Promise.resolve('asfd'))).toThrow();
-// });
-
-const asyncFunction = z.function(z.tuple([]), promSchema);
-
-test("async function pass", async () => {
-  const validatedFunction = asyncFunction.implement(async () => {
-    return { name: "jimmy", age: 14 };
-  });
-  await expect(validatedFunction()).resolves.toEqual({
-    name: "jimmy",
-    age: 14,
-  });
-});
-
-test("async function fail", async () => {
-  const validatedFunction = asyncFunction.implement(() => {
-    return Promise.resolve("asdf" as any);
-  });
-  await expect(validatedFunction()).rejects.toBeInstanceOf(z.ZodError);
-});
-
-test("async promise parsing", () => {
-  const res = z.promise(z.number()).parseAsync(Promise.resolve(12));
-  expect(res).toBeInstanceOf(Promise);
-});
-
-test("resolves", () => {
-  const foo = z.literal("foo");
-  const res = z.promise(foo);
-  expect(res.unwrap()).toEqual(foo);
-});