@loomhelm/multi-task-flow 0.2.7 → 0.2.9

package/toolkit/skills/multi-task-flow/node_modules/zod/src/v3/tests/deepmasking.test.ts

@@ -1,186 +0,0 @@
-// @ts-ignore TS6133
-import { test } from "vitest";
-
-import * as z from "zod/v3";
-
-test("test", () => {
-  z;
-});
-
-// const fish = z.object({
-//   name: z.string(),
-//   props: z.object({
-//     color: z.string(),
-//     numScales: z.number(),
-//   }),
-// });
-
-// const nonStrict = z
-//   .object({
-//     name: z.string(),
-//     color: z.string(),
-//   })
-//   .nonstrict();
-
-// test('object pick type', () => {
-//   const modNonStrictFish = nonStrict.omit({ name: true });
-//   modNonStrictFish.parse({ color: 'asdf' });
-
-//   const bad1 = () => fish.pick({ props: { unknown: true } } as any);
-//   const bad2 = () => fish.omit({ name: true, props: { unknown: true } } as any);
-
-//   expect(bad1).toThrow();
-//   expect(bad2).toThrow();
-// });
-
-// test('f1', () => {
-//   const f1 = fish.pick(true);
-//   f1.parse({ name: 'a', props: { color: 'b', numScales: 3 } });
-// });
-// test('f2', () => {
-//   const f2 = fish.pick({ props: true });
-//   f2.parse({ props: { color: 'asdf', numScales: 1 } });
-//   const badcheck2 = () => f2.parse({ name: 'a', props: { color: 'b', numScales: 3 } } as any);
-//   expect(badcheck2).toThrow();
-// });
-// test('f3', () => {
-//   const f3 = fish.pick({ props: { color: true } });
-//   f3.parse({ props: { color: 'b' } });
-//   const badcheck3 = () => f3.parse({ name: 'a', props: { color: 'b', numScales: 3 } } as any);
-//   expect(badcheck3).toThrow();
-// });
-// test('f4', () => {
-//   const badcheck4 = () => fish.pick({ props: { color: true, unknown: true } });
-//   expect(badcheck4).toThrow();
-// });
-// test('f6', () => {
-//   const f6 = fish.omit({ props: true });
-//   const badcheck6 = () => f6.parse({ name: 'a', props: { color: 'b', numScales: 3 } } as any);
-//   f6.parse({ name: 'adsf' });
-//   expect(badcheck6).toThrow();
-// });
-// test('f7', () => {
-//   const f7 = fish.omit({ props: { color: true } });
-//   f7.parse({ name: 'a', props: { numScales: 3 } });
-//   const badcheck7 = () => f7.parse({ name: 'a', props: { color: 'b', numScales: 3 } } as any);
-//   expect(badcheck7).toThrow();
-// });
-// test('f8', () => {
-//   const badcheck8 = () => fish.omit({ props: { color: true, unknown: true } });
-//   expect(badcheck8).toThrow();
-// });
-// test('f9', () => {
-//   const f9 = nonStrict.pick(true);
-//   f9.parse({ name: 'a', color: 'asdf' });
-// });
-// test('f10', () => {
-//   const f10 = nonStrict.pick({ name: true });
-//   f10.parse({ name: 'a' });
-//   const val = f10.parse({ name: 'a', color: 'b' });
-//   expect(val).toEqual({ name: 'a' });
-// });
-// test('f12', () => {
-//   const badfcheck12 = () => nonStrict.omit({ color: true, asdf: true });
-//   expect(badfcheck12).toThrow();
-// });
-
-// test('array masking', () => {
-//   const fishArray = z.array(fish);
-//   const modFishArray = fishArray.pick({
-//     name: true,
-//     props: {
-//       numScales: true,
-//     },
-//   });
-
-//   modFishArray.parse([{ name: 'fish', props: { numScales: 12 } }]);
-//   const bad1 = () => modFishArray.parse([{ name: 'fish', props: { numScales: 12, color: 'asdf' } }] as any);
-//   expect(bad1).toThrow();
-// });
-
-// test('array masking', () => {
-//   const fishArray = z.array(fish);
-//   const fail = () =>
-//     fishArray.pick({
-//       name: true,
-//       props: {
-//         whatever: true,
-//       },
-//     } as any);
-//   expect(fail).toThrow();
-// });
-
-// test('array masking', () => {
-//   const fishArray = z.array(fish);
-//   const fail = () =>
-//     fishArray.omit({
-//       whateve: true,
-//     } as any);
-//   expect(fail).toThrow();
-// });
-
-// test('array masking', () => {
-//   const fishArray = z.array(fish);
-//   const modFishList = fishArray.omit({
-//     name: true,
-//     props: {
-//       color: true,
-//     },
-//   });
-
-//   modFishList.parse([{ props: { numScales: 12 } }]);
-//   const fail = () => modFishList.parse([{ name: 'hello', props: { numScales: 12 } }] as any);
-//   expect(fail).toThrow();
-// });
-
-// test('primitive array masking', () => {
-//   const fishArray = z.array(z.number());
-//   const fail = () => fishArray.pick({} as any);
-//   expect(fail).toThrow();
-// });
-
-// test('other array masking', () => {
-//   const fishArray = z.array(z.array(z.number()));
-//   const fail = () => fishArray.pick({} as any);
-//   expect(fail).toThrow();
-// });
-
-// test('invalid mask #1', () => {
-//   const fail = () => fish.pick(1 as any);
-//   expect(fail).toThrow();
-// });
-
-// test('invalid mask #2', () => {
-//   const fail = () => fish.pick([] as any);
-//   expect(fail).toThrow();
-// });
-
-// test('invalid mask #3', () => {
-//   const fail = () => fish.pick(false as any);
-//   expect(fail).toThrow();
-// });
-
-// test('invalid mask #4', () => {
-//   const fail = () => fish.pick('asdf' as any);
-//   expect(fail).toThrow();
-// });
-
-// test('invalid mask #5', () => {
-//   const fail = () => fish.omit(1 as any);
-//   expect(fail).toThrow();
-// });
-
-// test('invalid mask #6', () => {
-//   const fail = () => fish.omit([] as any);
-//   expect(fail).toThrow();
-// });
-
-// test('invalid mask #7', () => {
-//   const fail = () => fish.omit(false as any);
-//   expect(fail).toThrow();
-// });
-
-// test('invalid mask #8', () => {
-//   const fail = () => fish.omit('asdf' as any);
-//   expect(fail).toThrow();
-// });

package/toolkit/skills/multi-task-flow/node_modules/zod/src/v3/tests/default.test.ts

@@ -1,112 +0,0 @@
-// @ts-ignore TS6133
-import { expect, test } from "vitest";
-
-import { z } from "zod/v3";
-import { util } from "../helpers/util.js";
-
-test("basic defaults", () => {
-  expect(z.string().default("default").parse(undefined)).toBe("default");
-});
-
-test("default with transform", () => {
-  const stringWithDefault = z
-    .string()
-    .transform((val) => val.toUpperCase())
-    .default("default");
-  expect(stringWithDefault.parse(undefined)).toBe("DEFAULT");
-  expect(stringWithDefault).toBeInstanceOf(z.ZodDefault);
-  expect(stringWithDefault._def.innerType).toBeInstanceOf(z.ZodEffects);
-  expect(stringWithDefault._def.innerType._def.schema).toBeInstanceOf(z.ZodSchema);
-
-  type inp = z.input<typeof stringWithDefault>;
-  util.assertEqual<inp, string | undefined>(true);
-  type out = z.output<typeof stringWithDefault>;
-  util.assertEqual<out, string>(true);
-});
-
-test("default on existing optional", () => {
-  const stringWithDefault = z.string().optional().default("asdf");
-  expect(stringWithDefault.parse(undefined)).toBe("asdf");
-  expect(stringWithDefault).toBeInstanceOf(z.ZodDefault);
-  expect(stringWithDefault._def.innerType).toBeInstanceOf(z.ZodOptional);
-  expect(stringWithDefault._def.innerType._def.innerType).toBeInstanceOf(z.ZodString);
-
-  type inp = z.input<typeof stringWithDefault>;
-  util.assertEqual<inp, string | undefined>(true);
-  type out = z.output<typeof stringWithDefault>;
-  util.assertEqual<out, string>(true);
-});
-
-test("optional on default", () => {
-  const stringWithDefault = z.string().default("asdf").optional();
-
-  type inp = z.input<typeof stringWithDefault>;
-  util.assertEqual<inp, string | undefined>(true);
-  type out = z.output<typeof stringWithDefault>;
-  util.assertEqual<out, string | undefined>(true);
-});
-
-test("complex chain example", () => {
-  const complex = z
-    .string()
-    .default("asdf")
-    .transform((val) => val.toUpperCase())
-    .default("qwer")
-    .removeDefault()
-    .optional()
-    .default("asdfasdf");
-
-  expect(complex.parse(undefined)).toBe("ASDFASDF");
-});
-
-test("removeDefault", () => {
-  const stringWithRemovedDefault = z.string().default("asdf").removeDefault();
-
-  type out = z.output<typeof stringWithRemovedDefault>;
-  util.assertEqual<out, string>(true);
-});
-
-test("nested", () => {
-  const inner = z.string().default("asdf");
-  const outer = z.object({ inner }).default({
-    inner: undefined,
-  });
-  type input = z.input<typeof outer>;
-  util.assertEqual<input, { inner?: string | undefined } | undefined>(true);
-  type out = z.output<typeof outer>;
-  util.assertEqual<out, { inner: string }>(true);
-  expect(outer.parse(undefined)).toEqual({ inner: "asdf" });
-  expect(outer.parse({})).toEqual({ inner: "asdf" });
-  expect(outer.parse({ inner: undefined })).toEqual({ inner: "asdf" });
-});
-
-test("chained defaults", () => {
-  const stringWithDefault = z.string().default("inner").default("outer");
-  const result = stringWithDefault.parse(undefined);
-  expect(result).toEqual("outer");
-});
-
-test("factory", () => {
-  expect(z.ZodDefault.create(z.string(), { default: "asdf" }).parse(undefined)).toEqual("asdf");
-});
-
-test("native enum", () => {
-  enum Fruits {
-    apple = "apple",
-    orange = "orange",
-  }
-
-  const schema = z.object({
-    fruit: z.nativeEnum(Fruits).default(Fruits.apple),
-  });
-
-  expect(schema.parse({})).toEqual({ fruit: Fruits.apple });
-});
-
-test("enum", () => {
-  const schema = z.object({
-    fruit: z.enum(["apple", "orange"]).default("apple"),
-  });
-
-  expect(schema.parse({})).toEqual({ fruit: "apple" });
-});

package/toolkit/skills/multi-task-flow/node_modules/zod/src/v3/tests/description.test.ts

@@ -1,33 +0,0 @@
-// @ts-ignore TS6133
-import { expect, test } from "vitest";
-
-import * as z from "zod/v3";
-
-const description = "a description";
-
-test("passing `description` to schema should add a description", () => {
-  expect(z.string({ description }).description).toEqual(description);
-  expect(z.number({ description }).description).toEqual(description);
-  expect(z.boolean({ description }).description).toEqual(description);
-});
-
-test("`.describe` should add a description", () => {
-  expect(z.string().describe(description).description).toEqual(description);
-  expect(z.number().describe(description).description).toEqual(description);
-  expect(z.boolean().describe(description).description).toEqual(description);
-});
-
-test("description should carry over to chained schemas", () => {
-  const schema = z.string({ description });
-  expect(schema.description).toEqual(description);
-  expect(schema.optional().description).toEqual(description);
-  expect(schema.optional().nullable().default("default").description).toEqual(description);
-});
-
-test("description should not carry over to chained array schema", () => {
-  const schema = z.string().describe(description);
-
-  expect(schema.description).toEqual(description);
-  expect(schema.array().description).toEqual(undefined);
-  expect(z.array(schema).description).toEqual(undefined);
-});

package/toolkit/skills/multi-task-flow/node_modules/zod/src/v3/tests/discriminated-unions.test.ts

@@ -1,315 +0,0 @@
-// @ts-ignore TS6133
-import { expect, test } from "vitest";
-
-import * as z from "zod/v3";
-
-test("valid", () => {
-  expect(
-    z
-      .discriminatedUnion("type", [
-        z.object({ type: z.literal("a"), a: z.string() }),
-        z.object({ type: z.literal("b"), b: z.string() }),
-      ])
-      .parse({ type: "a", a: "abc" })
-  ).toEqual({ type: "a", a: "abc" });
-});
-
-test("valid - discriminator value of various primitive types", () => {
-  const schema = z.discriminatedUnion("type", [
-    z.object({ type: z.literal("1"), val: z.literal(1) }),
-    z.object({ type: z.literal(1), val: z.literal(2) }),
-    z.object({ type: z.literal(BigInt(1)), val: z.literal(3) }),
-    z.object({ type: z.literal("true"), val: z.literal(4) }),
-    z.object({ type: z.literal(true), val: z.literal(5) }),
-    z.object({ type: z.literal("null"), val: z.literal(6) }),
-    z.object({ type: z.literal(null), val: z.literal(7) }),
-    z.object({ type: z.literal("undefined"), val: z.literal(8) }),
-    z.object({ type: z.literal(undefined), val: z.literal(9) }),
-    z.object({ type: z.literal("transform"), val: z.literal(10) }),
-    z.object({ type: z.literal("refine"), val: z.literal(11) }),
-    z.object({ type: z.literal("superRefine"), val: z.literal(12) }),
-  ]);
-
-  expect(schema.parse({ type: "1", val: 1 })).toEqual({ type: "1", val: 1 });
-  expect(schema.parse({ type: 1, val: 2 })).toEqual({ type: 1, val: 2 });
-  expect(schema.parse({ type: BigInt(1), val: 3 })).toEqual({
-    type: BigInt(1),
-    val: 3,
-  });
-  expect(schema.parse({ type: "true", val: 4 })).toEqual({
-    type: "true",
-    val: 4,
-  });
-  expect(schema.parse({ type: true, val: 5 })).toEqual({
-    type: true,
-    val: 5,
-  });
-  expect(schema.parse({ type: "null", val: 6 })).toEqual({
-    type: "null",
-    val: 6,
-  });
-  expect(schema.parse({ type: null, val: 7 })).toEqual({
-    type: null,
-    val: 7,
-  });
-  expect(schema.parse({ type: "undefined", val: 8 })).toEqual({
-    type: "undefined",
-    val: 8,
-  });
-  expect(schema.parse({ type: undefined, val: 9 })).toEqual({
-    type: undefined,
-    val: 9,
-  });
-});
-
-test("invalid - null", () => {
-  try {
-    z.discriminatedUnion("type", [
-      z.object({ type: z.literal("a"), a: z.string() }),
-      z.object({ type: z.literal("b"), b: z.string() }),
-    ]).parse(null);
-    throw new Error();
-  } catch (e: any) {
-    expect(JSON.parse(e.message)).toEqual([
-      {
-        code: z.ZodIssueCode.invalid_type,
-        expected: z.ZodParsedType.object,
-        message: "Expected object, received null",
-        received: z.ZodParsedType.null,
-        path: [],
-      },
-    ]);
-  }
-});
-
-test("invalid discriminator value", () => {
-  try {
-    z.discriminatedUnion("type", [
-      z.object({ type: z.literal("a"), a: z.string() }),
-      z.object({ type: z.literal("b"), b: z.string() }),
-    ]).parse({ type: "x", a: "abc" });
-    throw new Error();
-  } catch (e: any) {
-    expect(JSON.parse(e.message)).toEqual([
-      {
-        code: z.ZodIssueCode.invalid_union_discriminator,
-        options: ["a", "b"],
-        message: "Invalid discriminator value. Expected 'a' | 'b'",
-        path: ["type"],
-      },
-    ]);
-  }
-});
-
-test("valid discriminator value, invalid data", () => {
-  try {
-    z.discriminatedUnion("type", [
-      z.object({ type: z.literal("a"), a: z.string() }),
-      z.object({ type: z.literal("b"), b: z.string() }),
-    ]).parse({ type: "a", b: "abc" });
-    throw new Error();
-  } catch (e: any) {
-    expect(JSON.parse(e.message)).toEqual([
-      {
-        code: z.ZodIssueCode.invalid_type,
-        expected: z.ZodParsedType.string,
-        message: "Required",
-        path: ["a"],
-        received: z.ZodParsedType.undefined,
-      },
-    ]);
-  }
-});
-
-test("wrong schema - missing discriminator", () => {
-  try {
-    z.discriminatedUnion("type", [
-      z.object({ type: z.literal("a"), a: z.string() }),
-      z.object({ b: z.string() }) as any,
-    ]);
-    throw new Error();
-  } catch (e: any) {
-    expect(e.message.includes("could not be extracted")).toBe(true);
-  }
-});
-
-test("wrong schema - duplicate discriminator values", () => {
-  try {
-    z.discriminatedUnion("type", [
-      z.object({ type: z.literal("a"), a: z.string() }),
-      z.object({ type: z.literal("a"), b: z.string() }),
-    ]);
-    throw new Error();
-  } catch (e: any) {
-    expect(e.message.includes("has duplicate value")).toEqual(true);
-  }
-});
-
-test("async - valid", async () => {
-  expect(
-    await z
-      .discriminatedUnion("type", [
-        z.object({
-          type: z.literal("a"),
-          a: z
-            .string()
-            .refine(async () => true)
-            .transform(async (val) => Number(val)),
-        }),
-        z.object({
-          type: z.literal("b"),
-          b: z.string(),
-        }),
-      ])
-      .parseAsync({ type: "a", a: "1" })
-  ).toEqual({ type: "a", a: 1 });
-});
-
-test("async - invalid", async () => {
-  try {
-    await z
-      .discriminatedUnion("type", [
-        z.object({
-          type: z.literal("a"),
-          a: z
-            .string()
-            .refine(async () => true)
-            .transform(async (val) => val),
-        }),
-        z.object({
-          type: z.literal("b"),
-          b: z.string(),
-        }),
-      ])
-      .parseAsync({ type: "a", a: 1 });
-    throw new Error();
-  } catch (e: any) {
-    expect(JSON.parse(e.message)).toEqual([
-      {
-        code: "invalid_type",
-        expected: "string",
-        received: "number",
-        path: ["a"],
-        message: "Expected string, received number",
-      },
-    ]);
-  }
-});
-
-test("valid - literals with .default or .preprocess", () => {
-  const schema = z.discriminatedUnion("type", [
-    z.object({
-      type: z.literal("foo").default("foo"),
-      a: z.string(),
-    }),
-    z.object({
-      type: z.literal("custom"),
-      method: z.string(),
-    }),
-    z.object({
-      type: z.preprocess((val) => String(val), z.literal("bar")),
-      c: z.string(),
-    }),
-  ]);
-  expect(schema.parse({ type: "foo", a: "foo" })).toEqual({
-    type: "foo",
-    a: "foo",
-  });
-});
-
-test("enum and nativeEnum", () => {
-  enum MyEnum {
-    d = 0,
-    e = "e",
-  }
-
-  const schema = z.discriminatedUnion("key", [
-    z.object({
-      key: z.literal("a"),
-      // Add other properties specific to this option
-    }),
-    z.object({
-      key: z.enum(["b", "c"]),
-      // Add other properties specific to this option
-    }),
-    z.object({
-      key: z.nativeEnum(MyEnum),
-      // Add other properties specific to this option
-    }),
-  ]);
-
-  // type schema = z.infer<typeof schema>;
-
-  schema.parse({ key: "a" });
-  schema.parse({ key: "b" });
-  schema.parse({ key: "c" });
-  schema.parse({ key: MyEnum.d });
-  schema.parse({ key: MyEnum.e });
-  schema.parse({ key: "e" });
-});
-
-test("branded", () => {
-  const schema = z.discriminatedUnion("key", [
-    z.object({
-      key: z.literal("a"),
-      // Add other properties specific to this option
-    }),
-    z.object({
-      key: z.literal("b").brand("asdfaf"),
-      // Add other properties specific to this option
-    }),
-  ]);
-
-  // type schema = z.infer<typeof schema>;
-
-  schema.parse({ key: "a" });
-  schema.parse({ key: "b" });
-  expect(() => {
-    schema.parse({ key: "c" });
-  }).toThrow();
-});
-
-test("optional and nullable", () => {
-  const schema = z.discriminatedUnion("key", [
-    z.object({
-      key: z.literal("a").optional(),
-      a: z.literal(true),
-    }),
-    z.object({
-      key: z.literal("b").nullable(),
-      b: z.literal(true),
-      // Add other properties specific to this option
-    }),
-  ]);
-
-  type schema = z.infer<typeof schema>;
-  z.util.assertEqual<schema, { key?: "a" | undefined; a: true } | { key: "b" | null; b: true }>(true);
-
-  schema.parse({ key: "a", a: true });
-  schema.parse({ key: undefined, a: true });
-  schema.parse({ key: "b", b: true });
-  schema.parse({ key: null, b: true });
-  expect(() => {
-    schema.parse({ key: null, a: true });
-  }).toThrow();
-  expect(() => {
-    schema.parse({ key: "b", a: true });
-  }).toThrow();
-
-  const value = schema.parse({ key: null, b: true });
-
-  if (!("key" in value)) value.a;
-  if (value.key === undefined) value.a;
-  if (value.key === "a") value.a;
-  if (value.key === "b") value.b;
-  if (value.key === null) value.b;
-});
-
-test("readonly array of options", () => {
-  const options = [
-    z.object({ type: z.literal("x"), val: z.literal(1) }),
-    z.object({ type: z.literal("y"), val: z.literal(2) }),
-  ] as const;
-
-  expect(z.discriminatedUnion("type", options).parse({ type: "x", val: 1 })).toEqual({ type: "x", val: 1 });
-});