dimcode-darwin-x64 0.1.0-alpha.15 → 0.1.0-alpha.16

package/plugins/workflow/node_modules/zod/src/v4/mini/tests/apply.test.ts

@@ -0,0 +1,24 @@
+import { expect, expectTypeOf, test } from "vitest";
+import * as z from "../index.js";
+
+test("basic apply (number)", () => {
+  const setCommonNumberChecks = <T extends z.ZodMiniNumber>(schema: T) => {
+    return schema.check(z.minimum(0), z.maximum(100));
+  };
+
+  const schema = z.nullable(z.number().apply(setCommonNumberChecks));
+
+  expect(() => z.parse(schema, -1)).toThrowError();
+  expect(() => z.parse(schema, 101)).toThrowError();
+  expect(z.parse(schema, 0)).toBe(0);
+  expect(z.parse(schema, null)).toBe(null);
+  expectTypeOf<z.infer<typeof schema>>().toEqualTypeOf<number | null>();
+});
+
+test("The callback's return value becomes the apply's return value.", () => {
+  const symbol = Symbol();
+  const result = z.number().apply(() => symbol);
+
+  expect(result).toBe(symbol);
+  expectTypeOf<typeof result>().toEqualTypeOf<symbol>();
+});

package/plugins/workflow/node_modules/zod/src/v4/mini/tests/assignability.test.ts

@@ -0,0 +1,129 @@
+import { test } from "vitest";
+
+import * as z from "zod/mini";
+
+test("assignability", () => {
+  // $ZodString
+  z.string() satisfies z.core.$ZodString;
+
+  // $ZodNumber
+  z.number() satisfies z.core.$ZodNumber;
+
+  // $ZodBigInt
+  z.bigint() satisfies z.core.$ZodBigInt;
+
+  // $ZodBoolean
+  z.boolean() satisfies z.core.$ZodBoolean;
+
+  // $ZodDate
+  z.date() satisfies z.core.$ZodDate;
+
+  // $ZodSymbol
+  z.symbol() satisfies z.core.$ZodSymbol;
+
+  // $ZodUndefined
+  z.undefined() satisfies z.core.$ZodUndefined;
+
+  // $ZodNullable
+  z.nullable(z.string()) satisfies z.core.$ZodNullable;
+
+  // $ZodNull
+  z.null() satisfies z.core.$ZodNull;
+
+  // $ZodAny
+  z.any() satisfies z.core.$ZodAny;
+
+  // $ZodUnknown
+  z.unknown() satisfies z.core.$ZodUnknown;
+
+  // $ZodNever
+  z.never() satisfies z.core.$ZodNever;
+
+  // $ZodVoid
+  z.void() satisfies z.core.$ZodVoid;
+
+  // $ZodArray
+  z.array(z.string()) satisfies z.core.$ZodArray;
+
+  // $ZodObject
+  z.object({ key: z.string() }) satisfies z.core.$ZodObject;
+
+  // $ZodUnion
+  z.union([z.string(), z.number()]) satisfies z.core.$ZodUnion;
+
+  // $ZodIntersection
+  z.intersection(z.string(), z.number()) satisfies z.core.$ZodIntersection;
+
+  // $ZodTuple
+  z.tuple([z.string(), z.number()]) satisfies z.core.$ZodTuple;
+
+  // $ZodRecord
+  z.record(z.string(), z.number()) satisfies z.core.$ZodRecord;
+
+  // $ZodMap
+  z.map(z.string(), z.number()) satisfies z.core.$ZodMap;
+
+  // $ZodSet
+  z.set(z.string()) satisfies z.core.$ZodSet;
+
+  // $ZodLiteral
+  z.literal("example") satisfies z.core.$ZodLiteral;
+
+  // $ZodEnum
+  z.enum(["a", "b", "c"]) satisfies z.core.$ZodEnum;
+
+  // $ZodPromise
+  z.promise(z.string()) satisfies z.core.$ZodPromise;
+
+  // $ZodLazy
+  const lazySchema = z.lazy(() => z.string());
+  lazySchema satisfies z.core.$ZodLazy;
+
+  // $ZodOptional
+  z.optional(z.string()) satisfies z.core.$ZodOptional;
+
+  // $ZodDefault
+  z._default(z.string(), "default") satisfies z.core.$ZodDefault;
+
+  // $ZodTemplateLiteral
+  z.templateLiteral([z.literal("a"), z.literal("b")]) satisfies z.core.$ZodTemplateLiteral;
+
+  // $ZodCustom
+  z.custom<string>((val) => typeof val === "string") satisfies z.core.$ZodCustom;
+
+  // $ZodTransform
+  z.transform((val) => val as string) satisfies z.core.$ZodTransform;
+
+  // $ZodNonOptional
+  z.nonoptional(z.optional(z.string())) satisfies z.core.$ZodNonOptional;
+
+  // $ZodReadonly
+  z.readonly(z.object({ key: z.string() })) satisfies z.core.$ZodReadonly;
+
+  // $ZodNaN
+  z.nan() satisfies z.core.$ZodNaN;
+
+  // $ZodPipe
+  z.pipe(z.unknown(), z.number()) satisfies z.core.$ZodPipe;
+
+  // $ZodSuccess
+  z.success(z.string()) satisfies z.core.$ZodSuccess;
+
+  // $ZodCatch
+  z.catch(z.string(), "fallback") satisfies z.core.$ZodCatch;
+
+  // $ZodFile
+  z.file() satisfies z.core.$ZodFile;
+});
+
+test("assignability with type narrowing", () => {
+  type _RefinedSchema<T extends z.ZodMiniType<object> | z.ZodMiniUnion> = T extends z.ZodMiniUnion
+    ? RefinedUnionSchema<T> // <-- Type instantiation is excessively deep and possibly infinite.
+    : T extends z.ZodMiniType<object>
+      ? RefinedTypeSchema<z.output<T>> // <-- Type instantiation is excessively deep and possibly infinite.
+      : never;
+
+  type RefinedTypeSchema<T extends object> = T;
+
+  type RefinedUnionSchema<T extends z.ZodMiniUnion> = T;
+});

package/plugins/workflow/node_modules/zod/src/v4/mini/tests/brand.test.ts

@@ -0,0 +1,94 @@
+import { expectTypeOf, test } from "vitest";
+import * as z from "../index.js";
+
+test("branded types", () => {
+  const mySchema = z
+    .object({
+      name: z.string(),
+    })
+    .brand<"superschema">();
+
+  // simple branding
+  type MySchema = z.infer<typeof mySchema>;
+  // Using true for type equality assertion
+  expectTypeOf<MySchema>().toEqualTypeOf<{ name: string } & z.$brand<"superschema">>();
+
+  const doStuff = (arg: MySchema) => arg;
+  doStuff(z.parse(mySchema, { name: "hello there" }));
+
+  // inheritance
+  const extendedSchema = mySchema.brand<"subschema">();
+  type ExtendedSchema = z.infer<typeof extendedSchema>;
+  expectTypeOf<ExtendedSchema>().toEqualTypeOf<{ name: string } & z.$brand<"superschema"> & z.$brand<"subschema">>();
+
+  doStuff(z.parse(extendedSchema, { name: "hello again" }));
+
+  // number branding
+  const numberSchema = z.number().brand<42>();
+  type NumberSchema = z.infer<typeof numberSchema>;
+  expectTypeOf<NumberSchema>().toEqualTypeOf<number & { [z.$brand]: { 42: true } }>();
+
+  // symbol branding
+  const MyBrand: unique symbol = Symbol("hello");
+  type MyBrand = typeof MyBrand;
+  const symbolBrand = z.number().brand<"sup">().brand<typeof MyBrand>();
+  type SymbolBrand = z.infer<typeof symbolBrand>;
+  // number & { [z.$brand]: { sup: true, [MyBrand]: true } }
+  expectTypeOf<SymbolBrand>().toEqualTypeOf<number & z.$brand<"sup"> & z.$brand<MyBrand>>();
+
+  // keeping brands out of input types
+  const age = z.number().brand<"age">();
+  type Age1 = z.infer<typeof age>;
+  type AgeInput1 = z.input<typeof age>;
+
+  // Using not for type inequality assertion
+  expectTypeOf<AgeInput1>().not.toEqualTypeOf<Age1>();
+  expectTypeOf<number>().toEqualTypeOf<AgeInput1>();
+  expectTypeOf<number & z.$brand<"age">>().toEqualTypeOf<Age1>();
+
+  // @ts-expect-error
+  doStuff({ name: "hello there!" });
+});
+
+test("brand direction: out (default)", () => {
+  const schema = z.string().brand<"A">();
+  type Input = z.input<typeof schema>;
+  type Output = z.output<typeof schema>;
+
+  // output is branded
+  expectTypeOf<Output>().toEqualTypeOf<string & z.$brand<"A">>();
+  // input is NOT branded (default behavior)
+  expectTypeOf<Input>().toEqualTypeOf<string>();
+});
+
+test("brand direction: out (explicit)", () => {
+  const schema = z.string().brand<"A", "out">();
+  type Input = z.input<typeof schema>;
+  type Output = z.output<typeof schema>;
+
+  // output is branded
+  expectTypeOf<Output>().toEqualTypeOf<string & z.$brand<"A">>();
+  // input is NOT branded
+  expectTypeOf<Input>().toEqualTypeOf<string>();
+});
+
+test("brand direction: in", () => {
+  const schema = z.string().brand<"A", "in">();
+  type Input = z.input<typeof schema>;
+  type Output = z.output<typeof schema>;
+
+  // input is branded
+  expectTypeOf<Input>().toEqualTypeOf<string & z.$brand<"A">>();
+  // output is NOT branded
+  expectTypeOf<Output>().toEqualTypeOf<string>();
+});
+
+test("brand direction: inout", () => {
+  const schema = z.string().brand<"A", "inout">();
+  type Input = z.input<typeof schema>;
+  type Output = z.output<typeof schema>;
+
+  // both are branded
+  expectTypeOf<Input>().toEqualTypeOf<string & z.$brand<"A">>();
+  expectTypeOf<Output>().toEqualTypeOf<string & z.$brand<"A">>();
+});

package/plugins/workflow/node_modules/zod/src/v4/mini/tests/checks.test.ts

@@ -0,0 +1,144 @@
+import { expect, test } from "vitest";
+import * as z from "../index.js";
+
+// lt;
+test("z.lt", () => {
+  const a = z.number().check(z.lt(10));
+  expect(z.safeParse(a, 9).success).toEqual(true);
+  expect(z.safeParse(a, 9).data).toEqual(9);
+  expect(z.safeParse(a, 10).success).toEqual(false);
+});
+
+// lte;
+test("z.lte", () => {
+  const a = z.number().check(z.lte(10));
+  expect(z.safeParse(a, 10).success).toEqual(true);
+  expect(z.safeParse(a, 10).data).toEqual(10);
+  expect(z.safeParse(a, 11).success).toEqual(false);
+});
+
+// min;
+test("z.max", () => {
+  const a = z.number().check(z.maximum(10));
+  expect(z.safeParse(a, 10).success).toEqual(true);
+  expect(z.safeParse(a, 10).data).toEqual(10);
+  expect(z.safeParse(a, 11).success).toEqual(false);
+});
+
+// gt;
+test("z.gt", () => {
+  const a = z.number().check(z.gt(10));
+  expect(z.safeParse(a, 11).success).toEqual(true);
+  expect(z.safeParse(a, 11).data).toEqual(11);
+  expect(z.safeParse(a, 10).success).toEqual(false);
+});
+
+// gte;
+test("z.gte", () => {
+  const a = z.number().check(z.gte(10));
+  expect(z.safeParse(a, 10).success).toEqual(true);
+  expect(z.safeParse(a, 10).data).toEqual(10);
+  expect(z.safeParse(a, 9).success).toEqual(false);
+});
+
+// min;
+test("z.min", () => {
+  const a = z.number().check(z.minimum(10));
+  expect(z.safeParse(a, 10).success).toEqual(true);
+  expect(z.safeParse(a, 10).data).toEqual(10);
+  expect(z.safeParse(a, 9).success).toEqual(false);
+});
+
+// maxSize;
+test("z.maxLength", () => {
+  const a = z.array(z.string()).check(z.maxLength(3));
+  expect(z.safeParse(a, ["a", "b", "c"]).success).toEqual(true);
+  expect(z.safeParse(a, ["a", "b", "c", "d"]).success).toEqual(false);
+});
+
+// minSize;
+test("z.minLength", () => {
+  const a = z.array(z.string()).check(z.minLength(3));
+  expect(z.safeParse(a, ["a", "b"]).success).toEqual(false);
+  expect(z.safeParse(a, ["a", "b", "c"]).success).toEqual(true);
+});
+
+// size;
+test("z.length", () => {
+  const a = z.array(z.string()).check(z.length(3));
+  expect(z.safeParse(a, ["a", "b"]).success).toEqual(false);
+  expect(z.safeParse(a, ["a", "b", "c"]).success).toEqual(true);
+  expect(z.safeParse(a, ["a", "b", "c", "d"]).success).toEqual(false);
+});
+
+// regex;
+test("z.regex", () => {
+  const a = z.string().check(z.regex(/^aaa$/));
+  expect(z.safeParse(a, "aaa")).toMatchObject({ success: true, data: "aaa" });
+  expect(z.safeParse(a, "aa")).toMatchObject({ success: false });
+});
+
+// includes;
+test("z.includes", () => {
+  const a = z.string().check(z.includes("asdf"));
+  z.parse(a, "qqqasdfqqq");
+  z.parse(a, "asdf");
+  z.parse(a, "qqqasdf");
+  z.parse(a, "asdfqqq");
+  expect(z.safeParse(a, "qqq")).toMatchObject({ success: false });
+});
+
+// startsWith;
+test("z.startsWith", () => {
+  const a = z.string().check(z.startsWith("asdf"));
+  z.parse(a, "asdf");
+  z.parse(a, "asdfqqq");
+  expect(z.safeParse(a, "qqq")).toMatchObject({ success: false });
+});
+
+// endsWith;
+test("z.endsWith", () => {
+  const a = z.string().check(z.endsWith("asdf"));
+  z.parse(a, "asdf");
+  z.parse(a, "qqqasdf");
+  expect(z.safeParse(a, "asdfqqq")).toMatchObject({ success: false });
+});
+
+// lowercase;
+test("z.lowercase", () => {
+  const a = z.string().check(z.lowercase());
+  z.parse(a, "asdf");
+  expect(z.safeParse(a, "ASDF")).toMatchObject({ success: false });
+});
+
+// uppercase;
+test("z.uppercase", () => {
+  const a = z.string().check(z.uppercase());
+  z.parse(a, "ASDF");
+  expect(z.safeParse(a, "asdf")).toMatchObject({ success: false });
+});
+
+// filename;
+// fileType;
+// overwrite;
+test("z.overwrite", () => {
+  const a = z.string().check(z.overwrite((val) => val.toUpperCase()));
+  expect(z.safeParse(a, "asdf")).toMatchObject({ data: "ASDF" });
+});
+
+// normalize;
+// trim;
+// toLowerCase;
+// toUpperCase;
+// property
+
+test("abort early", () => {
+  const schema = z.string().check(
+    z.refine((val) => val.length > 1),
+    z.refine((val) => val.length > 2, { abort: true }),
+    z.refine((val) => val.length > 3)
+  );
+  const data = "";
+  const result = z.safeParse(schema, data);
+  expect(result.error!.issues.length).toEqual(2);
+});