aws-runtime-bridge 1.9.70 → 1.9.72

package/package/cc-switch-sdk/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/package/cc-switch-sdk/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/package/cc-switch-sdk/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/package/cc-switch-sdk/node_modules/zod/src/v4/classic/tests/map.test.ts

@@ -1,330 +0,0 @@
-import { expect, expectTypeOf, test } from "vitest";
-import * as z from "zod/v4";
-
-const stringMap = z.map(z.string(), z.string());
-type stringMap = z.infer<typeof stringMap>;
-
-const minTwo = stringMap.min(2);
-const maxTwo = stringMap.max(2);
-const justTwo = stringMap.size(2);
-const nonEmpty = stringMap.nonempty();
-const nonEmptyMax = stringMap.nonempty().max(2);
-
-test("type inference", () => {
-  expectTypeOf<stringMap>().toEqualTypeOf<Map<string, string>>();
-});
-
-test("valid parse", () => {
-  const result = stringMap.safeParse(
-    new Map([
-      ["first", "foo"],
-      ["second", "bar"],
-    ])
-  );
-  expect(result.success).toEqual(true);
-  expect(result.data).toMatchInlineSnapshot(`
-    Map {
-      "first" => "foo",
-      "second" => "bar",
-    }
-  `);
-});
-
-test("valid parse: size-related methods", () => {
-  expect(() => {
-    minTwo.parse(
-      new Map([
-        ["a", "b"],
-        ["c", "d"],
-      ])
-    );
-    minTwo.parse(
-      new Map([
-        ["a", "b"],
-        ["c", "d"],
-        ["e", "f"],
-      ])
-    );
-    maxTwo.parse(
-      new Map([
-        ["a", "b"],
-        ["c", "d"],
-      ])
-    );
-    maxTwo.parse(new Map([["a", "b"]]));
-    justTwo.parse(
-      new Map([
-        ["a", "b"],
-        ["c", "d"],
-      ])
-    );
-    nonEmpty.parse(new Map([["a", "b"]]));
-    nonEmptyMax.parse(
-      new Map([
-        ["a", "b"],
-        ["c", "d"],
-      ])
-    );
-  }).not.toThrow();
-
-  const sizeZeroResult = stringMap.parse(new Map());
-  expect(sizeZeroResult.size).toBe(0);
-
-  const sizeTwoResult = minTwo.parse(
-    new Map([
-      ["a", "b"],
-      ["c", "d"],
-    ])
-  );
-  expect(sizeTwoResult.size).toBe(2);
-});
-
-test("failing when parsing empty map in nonempty ", () => {
-  const result = nonEmpty.safeParse(new Map());
-  expect(result.success).toEqual(false);
-  expect(result.error!.issues.length).toEqual(1);
-  expect(result.error!.issues[0].code).toEqual("too_small");
-});
-
-test("failing when map is bigger than max() ", () => {
-  const result = maxTwo.safeParse(
-    new Map([
-      ["a", "b"],
-      ["c", "d"],
-      ["e", "f"],
-    ])
-  );
-  expect(result.success).toEqual(false);
-  expect(result.error!.issues.length).toEqual(1);
-  expect(result.error!.issues[0].code).toEqual("too_big");
-});
-
-test("valid parse async", async () => {
-  const asyncMap = z.map(
-    z.string().refine(async () => false, "bad key"),
-    z.string().refine(async () => false, "bad value")
-  );
-  const result = await asyncMap.safeParseAsync(new Map([["first", "foo"]]));
-  expect(result.success).toEqual(false);
-  expect(result.error).toMatchInlineSnapshot(`
-    [ZodError: [
-      {
-        "code": "custom",
-        "path": [
-          "first"
-        ],
-        "message": "bad key"
-      },
-      {
-        "code": "custom",
-        "path": [
-          "first"
-        ],
-        "message": "bad value"
-      }
-    ]]
-  `);
-});
-
-test("throws when a Set is given", () => {
-  const result = stringMap.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("invalid_type");
-  }
-});
-
-test("throws when the given map has invalid key and invalid input", () => {
-  const result = stringMap.safeParse(new Map([[42, Symbol()]]));
-  expect(result.success).toEqual(false);
-  if (result.success === false) {
-    expect(result.error.issues.length).toEqual(2);
-    expect(result.error).toMatchInlineSnapshot(`
-      [ZodError: [
-        {
-          "expected": "string",
-          "code": "invalid_type",
-          "path": [
-            42
-          ],
-          "message": "Invalid input: expected string, received number"
-        },
-        {
-          "expected": "string",
-          "code": "invalid_type",
-          "path": [
-            42
-          ],
-          "message": "Invalid input: expected string, received symbol"
-        }
-      ]]
-    `);
-  }
-});
-
-test("throws when the given map has multiple invalid entries", () => {
-  // const result = stringMap.safeParse(new Map([[42, Symbol()]]));
-
-  const result = stringMap.safeParse(
-    new Map([
-      [1, "foo"],
-      ["bar", 2],
-    ] as [any, any][]) as Map<any, any>
-  );
-
-  // const result = stringMap.safeParse(new Map([[42, Symbol()]]));
-  expect(result.success).toEqual(false);
-  if (result.success === false) {
-    expect(result.error.issues.length).toEqual(2);
-    expect(result.error.issues).toMatchInlineSnapshot(`
-      [
-        {
-          "code": "invalid_type",
-          "expected": "string",
-          "message": "Invalid input: expected string, received number",
-          "path": [
-            1,
-          ],
-        },
-        {
-          "code": "invalid_type",
-          "expected": "string",
-          "message": "Invalid input: expected string, received number",
-          "path": [
-            "bar",
-          ],
-        },
-      ]
-    `);
-  }
-});
-
-test("dirty", async () => {
-  const map = z.map(
-    z.string().refine((val) => val === val.toUpperCase(), {
-      message: "Keys must be uppercase",
-    }),
-    z.string()
-  );
-  const result = await map.spa(
-    new Map([
-      ["first", "foo"],
-      ["second", "bar"],
-    ])
-  );
-  expect(result.success).toEqual(false);
-  if (!result.success) {
-    expect(result.error.issues.length).toEqual(2);
-    expect(result.error).toMatchInlineSnapshot(`
-      [ZodError: [
-        {
-          "code": "custom",
-          "path": [
-            "first"
-          ],
-          "message": "Keys must be uppercase"
-        },
-        {
-          "code": "custom",
-          "path": [
-            "second"
-          ],
-          "message": "Keys must be uppercase"
-        }
-      ]]
-    `);
-  }
-});
-
-test("map with object keys", () => {
-  const map = z.map(
-    z.object({
-      name: z.string(),
-      age: z.number(),
-    }),
-    z.string()
-  );
-  const data = new Map([
-    [{ name: "John", age: 30 }, "foo"],
-    [{ name: "Jane", age: 25 }, "bar"],
-  ]);
-  const result = map.safeParse(data);
-  expect(result.success).toEqual(true);
-  expect(result.data!).toEqual(data);
-
-  const badData = new Map([["bad", "foo"]]);
-  const badResult = map.safeParse(badData);
-  expect(badResult.success).toEqual(false);
-  expect(badResult.error).toMatchInlineSnapshot(`
-    [ZodError: [
-      {
-        "expected": "object",
-        "code": "invalid_type",
-        "path": [
-          "bad"
-        ],
-        "message": "Invalid input: expected object, received string"
-      }
-    ]]
-  `);
-});
-
-test("min/max", async () => {
-  const schema = stringMap.min(4).max(5);
-
-  const r1 = schema.safeParse(
-    new Map([
-      ["a", "a"],
-      ["b", "b"],
-      ["c", "c"],
-      ["d", "d"],
-    ])
-  );
-  expect(r1.success).toEqual(true);
-
-  const r2 = schema.safeParse(
-    new Map([
-      ["a", "a"],
-      ["b", "b"],
-      ["c", "c"],
-    ])
-  );
-  expect(r2.success).toEqual(false);
-  expect(r2.error!.issues).toMatchInlineSnapshot(`
-    [
-      {
-        "code": "too_small",
-        "inclusive": true,
-        "message": "Too small: expected map to have >=4 entries",
-        "minimum": 4,
-        "origin": "map",
-        "path": [],
-      },
-    ]
-  `);
-
-  const r3 = schema.safeParse(
-    new Map([
-      ["a", "a"],
-      ["b", "b"],
-      ["c", "c"],
-      ["d", "d"],
-      ["e", "e"],
-      ["f", "f"],
-    ])
-  );
-  expect(r3.success).toEqual(false);
-  expect(r3.error!.issues).toMatchInlineSnapshot(`
-    [
-      {
-        "code": "too_big",
-        "inclusive": true,
-        "maximum": 5,
-        "message": "Too big: expected map to have <=5 entries",
-        "origin": "map",
-        "path": [],
-      },
-    ]
-  `);
-});