@deriv-com/fe-mcp-servers 0.0.4 → 0.0.5

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

@@ -1,91 +0,0 @@
-// @ts-ignore
-import { File as WebFile } from "@web-std/file";
-
-import { afterEach, beforeEach, expect, test } from "vitest";
-
-import * as z from "zod/v4";
-
-const minCheck = z.file().min(5);
-const maxCheck = z.file().max(8);
-const mimeCheck = z.file().mime(["text/plain", "application/json"]);
-
-const originalFile = global.File;
-beforeEach(async () => {
-  if (!globalThis.File) globalThis.File = WebFile;
-});
-afterEach(() => {
-  if (globalThis.File !== originalFile) {
-    globalThis.File = originalFile;
-  }
-});
-
-test("passing validations", () => {
-  minCheck.safeParse(new File(["12345"], "test.txt"));
-  maxCheck.safeParse(new File(["12345678"], "test.txt"));
-  mimeCheck.safeParse(new File([""], "test.csv", { type: "text/plain" }));
-  expect(() => mimeCheck.parse(new File([""], "test.txt"))).toThrow();
-  expect(() => mimeCheck.parse(new File([""], "test.txt", { type: "text/csv" }))).toThrow();
-});
-
-test("failing validations", () => {
-  expect(minCheck.safeParse(new File(["1234"], "test.txt"))).toMatchInlineSnapshot(`
-    {
-      "error": [ZodError: [
-      {
-        "origin": "file",
-        "code": "too_small",
-        "minimum": 5,
-        "path": [],
-        "message": "Too small: expected file to have >5 bytes"
-      }
-    ]],
-      "success": false,
-    }
-  `);
-  expect(maxCheck.safeParse(new File(["123456789"], "test.txt"))).toMatchInlineSnapshot(`
-    {
-      "error": [ZodError: [
-      {
-        "origin": "file",
-        "code": "too_big",
-        "maximum": 8,
-        "path": [],
-        "message": "Too big: expected file to have <8 bytes"
-      }
-    ]],
-      "success": false,
-    }
-  `);
-  expect(mimeCheck.safeParse(new File([""], "test.csv"))).toMatchInlineSnapshot(`
-    {
-      "error": [ZodError: [
-      {
-        "code": "invalid_value",
-        "values": [
-          "text/plain",
-          "application/json"
-        ],
-        "path": [],
-        "message": "Invalid option: expected one of \\"text/plain\\"|\\"application/json\\""
-      }
-    ]],
-      "success": false,
-    }
-  `);
-  expect(mimeCheck.safeParse(new File([""], "test.csv", { type: "text/csv" }))).toMatchInlineSnapshot(`
-    {
-      "error": [ZodError: [
-      {
-        "code": "invalid_value",
-        "values": [
-          "text/plain",
-          "application/json"
-        ],
-        "path": [],
-        "message": "Invalid option: expected one of \\"text/plain\\"|\\"application/json\\""
-      }
-    ]],
-      "success": false,
-    }
-  `);
-});

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

@@ -1,175 +0,0 @@
-import { expectTypeOf, test } from "vitest";
-import * as z from "zod/v4";
-import type * as core from "zod/v4/core";
-
-test("first party switch", () => {
-  const myType = z.string() as core.$ZodTypes;
-  const def = myType._zod.def;
-  switch (def.type) {
-    case "string":
-      break;
-    case "number":
-      break;
-    case "bigint":
-      break;
-    case "boolean":
-      break;
-    case "date":
-      break;
-    case "symbol":
-      break;
-    case "undefined":
-      break;
-    case "null":
-      break;
-    case "any":
-      break;
-    case "unknown":
-      break;
-    case "never":
-      break;
-    case "void":
-      break;
-    case "array":
-      break;
-    case "object":
-      break;
-    case "union":
-      break;
-    case "intersection":
-      break;
-    case "tuple":
-      break;
-    case "record":
-      break;
-    case "map":
-      break;
-    case "set":
-      break;
-    case "literal":
-      break;
-    case "enum":
-      break;
-    case "promise":
-      break;
-    case "optional":
-      break;
-    case "nonoptional":
-      break;
-    case "nullable":
-      break;
-    case "default":
-      break;
-    case "prefault":
-      break;
-    case "template_literal":
-      break;
-    case "custom":
-      break;
-    case "transform":
-      break;
-    case "readonly":
-      break;
-    case "nan":
-      break;
-    case "pipe":
-      break;
-    case "success":
-      break;
-    case "catch":
-      break;
-    case "file":
-      break;
-    case "lazy":
-      break;
-    default:
-      expectTypeOf(def).toEqualTypeOf<never>();
-  }
-});
-
-test("$ZodSchemaTypes", () => {
-  const type = "string" as core.$ZodTypeDef["type"];
-  switch (type) {
-    case "string":
-      break;
-    case "number":
-      break;
-    case "int":
-      break;
-    case "bigint":
-      break;
-    case "boolean":
-      break;
-    case "date":
-      break;
-    case "symbol":
-      break;
-    case "undefined":
-      break;
-    case "null":
-      break;
-    case "any":
-      break;
-    case "unknown":
-      break;
-    case "never":
-      break;
-    case "void":
-      break;
-    case "array":
-      break;
-    case "object":
-      break;
-    case "union":
-      break;
-    case "intersection":
-      break;
-    case "tuple":
-      break;
-    case "record":
-      break;
-    case "map":
-      break;
-    case "set":
-      break;
-    case "literal":
-      break;
-    case "enum":
-      break;
-    case "promise":
-      break;
-    case "optional":
-      break;
-    case "nonoptional":
-      break;
-    case "nullable":
-      break;
-    case "default":
-      break;
-    case "prefault":
-      break;
-    case "template_literal":
-      break;
-    case "custom":
-      break;
-    case "transform":
-      break;
-    case "readonly":
-      break;
-    case "nan":
-      break;
-    case "pipe":
-      break;
-    case "success":
-      break;
-    case "catch":
-      break;
-    case "file":
-      break;
-    case "lazy":
-      break;
-
-    default:
-      expectTypeOf(type).toEqualTypeOf<never>();
-  }
-});

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

@@ -1,268 +0,0 @@
-import { expect, expectTypeOf, test } from "vitest";
-import * as z from "zod/v4";
-
-const args1 = z.tuple([z.string()]);
-const returns1 = z.number();
-const func1 = z.function({
-  input: args1,
-
-  output: returns1,
-});
-
-test("function parsing", () => {
-  const parsed = func1.implement((arg: any) => arg.length);
-  const result = parsed("asdf");
-  expect(result).toBe(4);
-});
-
-test("parsed function fail 1", () => {
-  // @ts-expect-error
-  const parsed = func1.implement((x: string) => x);
-  expect(() => parsed("asdf")).toThrow();
-});
-
-test("parsed function fail 2", () => {
-  // @ts-expect-error
-  const parsed = func1.implement((x: string) => x);
-  expect(() => parsed(13 as any)).toThrow();
-});
-
-test("function inference 1", () => {
-  type func1 = (typeof func1)["_input"];
-  expectTypeOf<func1>().toEqualTypeOf<(k: string) => number>();
-});
-
-// test("method parsing", () => {
-//   const methodObject = z.object({
-//     property: z.number(),
-//     method: z
-//       .function()
-//       .input(z.tuple([z.string()]))
-//       .output(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().input(z.string()).output(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 = (typeof t1)["_input"];
-  expectTypeOf<t1>().toEqualTypeOf<(...args_1: never[]) => unknown>();
-  t1._input;
-
-  const t2args = z.tuple([z.string()], z.unknown());
-
-  const t2 = t1.input(t2args);
-  type t2 = (typeof t2)["_input"];
-  expectTypeOf<t2>().toEqualTypeOf<(arg: string, ...args_1: unknown[]) => unknown>();
-
-  const t3 = t2.output(z.boolean());
-  type t3 = (typeof t3)["_input"];
-  expectTypeOf<t3>().toEqualTypeOf<(arg: string, ...args_1: unknown[]) => boolean>();
-});
-
-// test("custom args", () => {
-//   const fn = z.function().implement((_a: string, _b: number) => {
-//     return new Date();
-//   });
-
-//   expectTypeOf(fn).toEqualTypeOf<(a: string, b: number) => Date>();
-// });
-
-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({
-  input: args2,
-  output: returns2,
-});
-
-test("function inference 2", () => {
-  type func2 = (typeof func2)["_input"];
-
-  expectTypeOf<func2>().toEqualTypeOf<
-    (arg: {
-      f3?: (boolean | undefined)[] | undefined;
-      f1: number;
-      f2: string | null;
-    }) => string | number
-  >();
-});
-
-test("valid function run", () => {
-  const validFunc2Instance = func2.implement((_x) => {
-    _x.f2;
-    _x.f3![0];
-    return "adf" as any;
-  });
-
-  validFunc2Instance({
-    f1: 21,
-    f2: "asdf",
-    f3: [true, false],
-  });
-});
-
-test("input validation error", () => {
-  const schema = z.function({
-    input: z.tuple([z.string()]),
-    output: z.void(),
-  });
-  const fn = schema.implement(() => 1234 as any);
-
-  // @ts-expect-error
-  const checker = () => fn();
-
-  try {
-    checker();
-  } catch (e: any) {
-    expect(e.issues).toMatchInlineSnapshot(`
-      [
-        {
-          "code": "invalid_type",
-          "expected": "string",
-          "message": "Invalid input: expected string, received undefined",
-          "path": [
-            0,
-          ],
-        },
-      ]
-    `);
-  }
-});
-
-test("array inputs", () => {
-  const a = z.function({
-    input: [
-      z.object({
-        name: z.string(),
-        age: z.number().int(),
-      }),
-    ],
-    output: z.string(),
-  });
-
-  a.implement((args) => {
-    return `${args.age}`;
-  });
-
-  const b = z.function({
-    input: [
-      z.object({
-        name: z.string(),
-        age: z.number().int(),
-      }),
-    ],
-  });
-  b.implement((args) => {
-    return `${args.age}`;
-  });
-});
-
-test("output validation error", () => {
-  const schema = z.function({
-    input: z.tuple([]),
-    output: z.string(),
-  });
-  const fn = schema.implement(() => 1234 as any);
-  try {
-    fn();
-  } catch (e: any) {
-    expect(e.issues).toMatchInlineSnapshot(`
-      [
-        {
-          "code": "invalid_type",
-          "expected": "string",
-          "message": "Invalid input: expected string, received number",
-          "path": [],
-        },
-      ]
-    `);
-  }
-});
-
-test("function with async refinements", async () => {
-  const schema = z
-    .function()
-    .input([z.string().refine(async (val) => val.length > 10)])
-    .output(z.promise(z.number().refine(async (val) => val > 10)));
-
-  const func = schema.implementAsync(async (val) => {
-    return val.length;
-  });
-  const results = [];
-  try {
-    await func("asdfasdf");
-    results.push("success");
-  } catch (_) {
-    results.push("fail");
-  }
-  try {
-    await func("asdflkjasdflkjsf");
-    results.push("success");
-  } catch (_) {
-    results.push("fail");
-  }
-
-  expect(results).toEqual(["fail", "success"]);
-});
-
-test("non async function with async refinements should fail", async () => {
-  const func = z
-    .function()
-    .input([z.string().refine(async (val) => val.length > 10)])
-    .output(z.number().refine(async (val) => val > 10))
-    .implement((val) => {
-      return val.length;
-    });
-
-  const results = [];
-  try {
-    await func("asdasdfasdffasdf");
-    results.push("success");
-  } catch (_) {
-    results.push("fail");
-  }
-
-  expect(results).toEqual(["fail"]);
-});
-
-test("extra parameters with rest", () => {
-  const maxLength5 = z
-    .function()
-    .input([z.string()], z.unknown())
-    .output(z.boolean())
-    .implement((str, _arg, _qewr) => {
-      return str.length <= 5;
-    });
-
-  const filteredList = ["apple", "orange", "pear", "banana", "strawberry"].filter(maxLength5);
-  expect(filteredList.length).toEqual(2);
-});

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

@@ -1,72 +0,0 @@
-import { expect, expectTypeOf, test } from "vitest";
-import * as z from "zod/v4";
-
-function nest<TData extends z.ZodType>(schema: TData) {
-  return z.object({
-    nested: schema,
-  });
-}
-
-test("generics", () => {
-  const a = nest(z.object({ a: z.string() }));
-  type a = z.infer<typeof a>;
-  expectTypeOf<a>().toEqualTypeOf<{ nested: { a: string } }>();
-
-  const b = nest(z.object({ a: z.string().optional() }));
-  type b = z.infer<typeof b>;
-  expectTypeOf<b>().toEqualTypeOf<{ nested: { a?: string | undefined } }>();
-});
-
-test("generics with optional", () => {
-  async function stripOuter<TData extends z.ZodType>(schema: TData, data: unknown) {
-    return z
-      .object({
-        nested: schema.optional(),
-      })
-      .transform((data) => {
-        return data.nested;
-      })
-      .parse({ nested: data });
-  }
-
-  const result = stripOuter(z.object({ a: z.string() }), { a: "asdf" });
-  expectTypeOf<typeof result>().toEqualTypeOf<Promise<{ a: string } | undefined>>();
-});
-
-// test("assignability", () => {
-//   const createSchemaAndParse = <K extends string, VS extends z.ZodString>(key: K, valueSchema: VS, data: unknown) => {
-//     const schema = z.object({
-//       [key]: valueSchema,
-//     });
-//     // 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: "" });
-//   expectTypeOf<typeof parsed>().toEqualTypeOf<{ foo: string }>();
-// });
-
-test("nested no undefined", () => {
-  const inner = z.string().or(z.array(z.string()));
-  const outer = z.object({ inner });
-  type outerSchema = z.infer<typeof outer>;
-  expectTypeOf<outerSchema>().toEqualTypeOf<{ inner: string | string[] }>();
-
-  expect(outer.safeParse({ inner: undefined }).success).toEqual(false);
-});
-
-test("generic on output type", () => {
-  const createV4Schema = <Output>(opts: {
-    schema: z.ZodType<Output>;
-  }) => {
-    return opts.schema;
-  };
-
-  createV4Schema({
-    schema: z.object({
-      name: z.string(),
-    }),
-  })?._zod?.output?.name;
-});