yt-transcript-strapi-plugin 0.0.15 → 0.0.16

package/node_modules/zod/src/v3/tests/refine.test.ts

@@ -0,0 +1,313 @@
+// @ts-ignore TS6133
+import { expect, test } from "vitest";
+
+import * as z from "zod/v3";
+import { ZodIssueCode } from "../ZodError.js";
+import { util } from "../helpers/util.js";
+
+test("refinement", () => {
+  const obj1 = z.object({
+    first: z.string(),
+    second: z.string(),
+  });
+  const obj2 = obj1.partial().strict();
+
+  const obj3 = obj2.refine((data) => data.first || data.second, "Either first or second should be filled in.");
+
+  expect(obj1 === (obj2 as any)).toEqual(false);
+  expect(obj2 === (obj3 as any)).toEqual(false);
+
+  expect(() => obj1.parse({})).toThrow();
+  expect(() => obj2.parse({ third: "adsf" })).toThrow();
+  expect(() => obj3.parse({})).toThrow();
+  obj3.parse({ first: "a" });
+  obj3.parse({ second: "a" });
+  obj3.parse({ first: "a", second: "a" });
+});
+
+test("refinement 2", () => {
+  const validationSchema = z
+    .object({
+      email: z.string().email(),
+      password: z.string(),
+      confirmPassword: z.string(),
+    })
+    .refine((data) => data.password === data.confirmPassword, "Both password and confirmation must match");
+
+  expect(() =>
+    validationSchema.parse({
+      email: "aaaa@gmail.com",
+      password: "aaaaaaaa",
+      confirmPassword: "bbbbbbbb",
+    })
+  ).toThrow();
+});
+
+test("refinement type guard", () => {
+  const validationSchema = z.object({
+    a: z.string().refine((s): s is "a" => s === "a"),
+  });
+  type Input = z.input<typeof validationSchema>;
+  type Schema = z.infer<typeof validationSchema>;
+
+  util.assertEqual<"a", Input["a"]>(false);
+  util.assertEqual<string, Input["a"]>(true);
+
+  util.assertEqual<"a", Schema["a"]>(true);
+  util.assertEqual<string, Schema["a"]>(false);
+});
+
+test("refinement Promise", async () => {
+  const validationSchema = z
+    .object({
+      email: z.string().email(),
+      password: z.string(),
+      confirmPassword: z.string(),
+    })
+    .refine(
+      (data) => Promise.resolve().then(() => data.password === data.confirmPassword),
+      "Both password and confirmation must match"
+    );
+
+  await validationSchema.parseAsync({
+    email: "aaaa@gmail.com",
+    password: "password",
+    confirmPassword: "password",
+  });
+});
+
+test("custom path", async () => {
+  const result = await z
+    .object({
+      password: z.string(),
+      confirm: z.string(),
+    })
+    .refine((data) => data.confirm === data.password, { path: ["confirm"] })
+    .spa({ password: "asdf", confirm: "qewr" });
+  expect(result.success).toEqual(false);
+  if (!result.success) {
+    expect(result.error.issues[0].path).toEqual(["confirm"]);
+  }
+});
+
+test("use path in refinement context", async () => {
+  const noNested = z.string()._refinement((_val, ctx) => {
+    if (ctx.path.length > 0) {
+      ctx.addIssue({
+        code: ZodIssueCode.custom,
+        message: `schema cannot be nested. path: ${ctx.path.join(".")}`,
+      });
+      return false;
+    } else {
+      return true;
+    }
+  });
+
+  const data = z.object({
+    foo: noNested,
+  });
+
+  const t1 = await noNested.spa("asdf");
+  const t2 = await data.spa({ foo: "asdf" });
+
+  expect(t1.success).toBe(true);
+  expect(t2.success).toBe(false);
+  if (t2.success === false) {
+    expect(t2.error.issues[0].message).toEqual("schema cannot be nested. path: foo");
+  }
+});
+
+test("superRefine", () => {
+  const Strings = z.array(z.string()).superRefine((val, ctx) => {
+    if (val.length > 3) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.too_big,
+        maximum: 3,
+        type: "array",
+        inclusive: true,
+        exact: true,
+        message: "Too many items 😡",
+      });
+    }
+
+    if (val.length !== new Set(val).size) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: `No duplicates allowed.`,
+      });
+    }
+  });
+
+  const result = Strings.safeParse(["asfd", "asfd", "asfd", "asfd"]);
+
+  expect(result.success).toEqual(false);
+  if (!result.success) expect(result.error.issues.length).toEqual(2);
+
+  Strings.parse(["asfd", "qwer"]);
+});
+
+test("superRefine async", async () => {
+  const Strings = z.array(z.string()).superRefine(async (val, ctx) => {
+    if (val.length > 3) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.too_big,
+        maximum: 3,
+        type: "array",
+        inclusive: true,
+        exact: true,
+        message: "Too many items 😡",
+      });
+    }
+
+    if (val.length !== new Set(val).size) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: `No duplicates allowed.`,
+      });
+    }
+  });
+
+  const result = await Strings.safeParseAsync(["asfd", "asfd", "asfd", "asfd"]);
+
+  expect(result.success).toEqual(false);
+  if (!result.success) expect(result.error.issues.length).toEqual(2);
+
+  Strings.parseAsync(["asfd", "qwer"]);
+});
+
+test("superRefine - type narrowing", () => {
+  type NarrowType = { type: string; age: number };
+  const schema = z
+    .object({
+      type: z.string(),
+      age: z.number(),
+    })
+    .nullable()
+    .superRefine((arg, ctx): arg is NarrowType => {
+      if (!arg) {
+        // still need to make a call to ctx.addIssue
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          message: "cannot be null",
+          fatal: true,
+        });
+        return false;
+      }
+      return true;
+    });
+
+  util.assertEqual<z.infer<typeof schema>, NarrowType>(true);
+
+  expect(schema.safeParse({ type: "test", age: 0 }).success).toEqual(true);
+  expect(schema.safeParse(null).success).toEqual(false);
+});
+
+test("chained mixed refining types", () => {
+  type firstRefinement = { first: string; second: number; third: true };
+  type secondRefinement = { first: "bob"; second: number; third: true };
+  type thirdRefinement = { first: "bob"; second: 33; third: true };
+  const schema = z
+    .object({
+      first: z.string(),
+      second: z.number(),
+      third: z.boolean(),
+    })
+    .nullable()
+    .refine((arg): arg is firstRefinement => !!arg?.third)
+    .superRefine((arg, ctx): arg is secondRefinement => {
+      util.assertEqual<typeof arg, firstRefinement>(true);
+      if (arg.first !== "bob") {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          message: "`first` property must be `bob`",
+        });
+        return false;
+      }
+      return true;
+    })
+    .refine((arg): arg is thirdRefinement => {
+      util.assertEqual<typeof arg, secondRefinement>(true);
+      return arg.second === 33;
+    });
+
+  util.assertEqual<z.infer<typeof schema>, thirdRefinement>(true);
+});
+
+test("get inner type", () => {
+  z.string()
+    .refine(() => true)
+    .innerType()
+    .parse("asdf");
+});
+
+test("chained refinements", () => {
+  const objectSchema = z
+    .object({
+      length: z.number(),
+      size: z.number(),
+    })
+    .refine(({ length }) => length > 5, {
+      path: ["length"],
+      message: "length greater than 5",
+    })
+    .refine(({ size }) => size > 7, {
+      path: ["size"],
+      message: "size greater than 7",
+    });
+  const r1 = objectSchema.safeParse({
+    length: 4,
+    size: 9,
+  });
+  expect(r1.success).toEqual(false);
+  if (!r1.success) expect(r1.error.issues.length).toEqual(1);
+
+  const r2 = objectSchema.safeParse({
+    length: 4,
+    size: 3,
+  });
+  expect(r2.success).toEqual(false);
+  if (!r2.success) expect(r2.error.issues.length).toEqual(2);
+});
+
+test("fatal superRefine", () => {
+  const Strings = z
+    .string()
+    .superRefine((val, ctx) => {
+      if (val === "") {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          message: "foo",
+          fatal: true,
+        });
+      }
+    })
+    .superRefine((val, ctx) => {
+      if (val !== " ") {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          message: "bar",
+        });
+      }
+    });
+
+  const result = Strings.safeParse("");
+
+  expect(result.success).toEqual(false);
+  if (!result.success) expect(result.error.issues.length).toEqual(1);
+});
+
+test("superRefine after skipped transform", () => {
+  const schema = z
+    .string()
+    .regex(/^\d+$/)
+    .transform((val) => Number(val))
+    .superRefine((val) => {
+      if (typeof val !== "number") {
+        throw new Error("Called without transform");
+      }
+    });
+
+  const result = schema.safeParse("");
+
+  expect(result.success).toEqual(false);
+});

package/node_modules/zod/src/v3/tests/safeparse.test.ts

@@ -0,0 +1,27 @@
+// @ts-ignore TS6133
+import { expect, test } from "vitest";
+
+import * as z from "zod/v3";
+const stringSchema = z.string();
+
+test("safeparse fail", () => {
+  const safe = stringSchema.safeParse(12);
+  expect(safe.success).toEqual(false);
+  expect(safe.error).toBeInstanceOf(z.ZodError);
+});
+
+test("safeparse pass", () => {
+  const safe = stringSchema.safeParse("12");
+  expect(safe.success).toEqual(true);
+  expect(safe.data).toEqual("12");
+});
+
+test("safeparse unexpected error", () => {
+  expect(() =>
+    stringSchema
+      .refine((data) => {
+        throw new Error(data);
+      })
+      .safeParse("12")
+  ).toThrow();
+});

package/node_modules/zod/src/v3/tests/set.test.ts

@@ -0,0 +1,142 @@
+// @ts-ignore TS6133
+import { expect, test } from "vitest";
+
+import * as z from "zod/v3";
+import { ZodIssueCode } from "zod/v3";
+import { util } from "../helpers/util.js";
+
+const stringSet = z.set(z.string());
+type stringSet = z.infer<typeof stringSet>;
+
+const minTwo = z.set(z.string()).min(2);
+const maxTwo = z.set(z.string()).max(2);
+const justTwo = z.set(z.string()).size(2);
+const nonEmpty = z.set(z.string()).nonempty();
+const nonEmptyMax = z.set(z.string()).nonempty().max(2);
+
+test("type inference", () => {
+  util.assertEqual<stringSet, Set<string>>(true);
+});
+
+test("valid parse", () => {
+  const result = stringSet.safeParse(new Set(["first", "second"]));
+  expect(result.success).toEqual(true);
+  if (result.success) {
+    expect(result.data.has("first")).toEqual(true);
+    expect(result.data.has("second")).toEqual(true);
+    expect(result.data.has("third")).toEqual(false);
+  }
+
+  expect(() => {
+    minTwo.parse(new Set(["a", "b"]));
+    minTwo.parse(new Set(["a", "b", "c"]));
+    maxTwo.parse(new Set(["a", "b"]));
+    maxTwo.parse(new Set(["a"]));
+    justTwo.parse(new Set(["a", "b"]));
+    nonEmpty.parse(new Set(["a"]));
+    nonEmptyMax.parse(new Set(["a"]));
+  }).not.toThrow();
+});
+
+test("valid parse async", async () => {
+  const result = await stringSet.spa(new Set(["first", "second"]));
+  expect(result.success).toEqual(true);
+  if (result.success) {
+    expect(result.data.has("first")).toEqual(true);
+    expect(result.data.has("second")).toEqual(true);
+    expect(result.data.has("third")).toEqual(false);
+  }
+
+  const asyncResult = await stringSet.safeParse(new Set(["first", "second"]));
+  expect(asyncResult.success).toEqual(true);
+  if (asyncResult.success) {
+    expect(asyncResult.data.has("first")).toEqual(true);
+    expect(asyncResult.data.has("second")).toEqual(true);
+    expect(asyncResult.data.has("third")).toEqual(false);
+  }
+});
+
+test("valid parse: size-related methods", () => {
+  expect(() => {
+    minTwo.parse(new Set(["a", "b"]));
+    minTwo.parse(new Set(["a", "b", "c"]));
+    maxTwo.parse(new Set(["a", "b"]));
+    maxTwo.parse(new Set(["a"]));
+    justTwo.parse(new Set(["a", "b"]));
+    nonEmpty.parse(new Set(["a"]));
+    nonEmptyMax.parse(new Set(["a"]));
+  }).not.toThrow();
+
+  const sizeZeroResult = stringSet.parse(new Set());
+  expect(sizeZeroResult.size).toBe(0);
+
+  const sizeTwoResult = minTwo.parse(new Set(["a", "b"]));
+  expect(sizeTwoResult.size).toBe(2);
+});
+
+test("failing when parsing empty set in nonempty ", () => {
+  const result = nonEmpty.safeParse(new Set());
+  expect(result.success).toEqual(false);
+
+  if (result.success === false) {
+    expect(result.error.issues.length).toEqual(1);
+    expect(result.error.issues[0].code).toEqual(ZodIssueCode.too_small);
+  }
+});
+
+test("failing when set is smaller than min() ", () => {
+  const result = minTwo.safeParse(new Set(["just_one"]));
+  expect(result.success).toEqual(false);
+
+  if (result.success === false) {
+    expect(result.error.issues.length).toEqual(1);
+    expect(result.error.issues[0].code).toEqual(ZodIssueCode.too_small);
+  }
+});
+
+test("failing when set is bigger than max() ", () => {
+  const result = maxTwo.safeParse(new Set(["one", "two", "three"]));
+  expect(result.success).toEqual(false);
+
+  if (result.success === false) {
+    expect(result.error.issues.length).toEqual(1);
+    expect(result.error.issues[0].code).toEqual(ZodIssueCode.too_big);
+  }
+});
+
+test("doesn’t throw when an empty set is given", () => {
+  const result = stringSet.safeParse(new Set([]));
+  expect(result.success).toEqual(true);
+});
+
+test("throws when a Map is given", () => {
+  const result = stringSet.safeParse(new Map([]));
+  expect(result.success).toEqual(false);
+  if (result.success === false) {
+    expect(result.error.issues.length).toEqual(1);
+    expect(result.error.issues[0].code).toEqual(ZodIssueCode.invalid_type);
+  }
+});
+
+test("throws when the given set has invalid input", () => {
+  const result = stringSet.safeParse(new Set([Symbol()]));
+  expect(result.success).toEqual(false);
+  if (result.success === false) {
+    expect(result.error.issues.length).toEqual(1);
+    expect(result.error.issues[0].code).toEqual(ZodIssueCode.invalid_type);
+    expect(result.error.issues[0].path).toEqual([0]);
+  }
+});
+
+test("throws when the given set has multiple invalid entries", () => {
+  const result = stringSet.safeParse(new Set([1, 2] as any[]) as Set<any>);
+
+  expect(result.success).toEqual(false);
+  if (result.success === false) {
+    expect(result.error.issues.length).toEqual(2);
+    expect(result.error.issues[0].code).toEqual(ZodIssueCode.invalid_type);
+    expect(result.error.issues[0].path).toEqual([0]);
+    expect(result.error.issues[1].code).toEqual(ZodIssueCode.invalid_type);
+    expect(result.error.issues[1].path).toEqual([1]);
+  }
+});

package/node_modules/zod/src/v3/tests/standard-schema.test.ts

@@ -0,0 +1,83 @@
+// import type { StandardSchemaV1 } from "@standard-schema/spec";
+// @ts-ignore TS6133
+import { expect, test } from "vitest";
+
+import * as z from "zod/v3";
+import { util } from "../helpers/util.js";
+import type { StandardSchemaV1 } from "../standard-schema.js";
+
+test("assignability", () => {
+  const _s1: StandardSchemaV1 = z.string();
+  const _s2: StandardSchemaV1<string> = z.string();
+  const _s3: StandardSchemaV1<string, string> = z.string();
+  const _s4: StandardSchemaV1<unknown, string> = z.string();
+  [_s1, _s2, _s3, _s4];
+});
+
+test("type inference", () => {
+  const stringToNumber = z.string().transform((x) => x.length);
+  type input = StandardSchemaV1.InferInput<typeof stringToNumber>;
+  util.assertEqual<input, string>(true);
+  type output = StandardSchemaV1.InferOutput<typeof stringToNumber>;
+  util.assertEqual<output, number>(true);
+});
+
+test("valid parse", () => {
+  const schema = z.string();
+  const result = schema["~standard"].validate("hello");
+  if (result instanceof Promise) {
+    throw new Error("Expected sync result");
+  }
+  expect(result.issues).toEqual(undefined);
+  if (result.issues) {
+    throw new Error("Expected no issues");
+  } else {
+    expect(result.value).toEqual("hello");
+  }
+});
+
+test("invalid parse", () => {
+  const schema = z.string();
+  const result = schema["~standard"].validate(1234);
+  if (result instanceof Promise) {
+    throw new Error("Expected sync result");
+  }
+  expect(result.issues).toBeDefined();
+  if (!result.issues) {
+    throw new Error("Expected issues");
+  }
+  expect(result.issues.length).toEqual(1);
+  expect(result.issues[0].path).toEqual([]);
+});
+
+test("valid parse async", async () => {
+  const schema = z.string().refine(async () => true);
+  const _result = schema["~standard"].validate("hello");
+  if (_result instanceof Promise) {
+    const result = await _result;
+    expect(result.issues).toEqual(undefined);
+    if (result.issues) {
+      throw new Error("Expected no issues");
+    } else {
+      expect(result.value).toEqual("hello");
+    }
+  } else {
+    throw new Error("Expected async result");
+  }
+});
+
+test("invalid parse async", async () => {
+  const schema = z.string().refine(async () => false);
+  const _result = schema["~standard"].validate("hello");
+  if (_result instanceof Promise) {
+    const result = await _result;
+    expect(result.issues).toBeDefined();
+    if (!result.issues) {
+      throw new Error("Expected issues");
+    }
+    expect(result.issues.length).toEqual(1);
+    expect(result.issues[0].path).toEqual([]);
+  } else {
+    throw new Error("Expected async result");
+  }
+});