@rho-workspace/rho 0.5.2 → 0.5.3

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

@@ -1,26 +0,0 @@
-import { expect, expectTypeOf, test } from "vitest";
-
-import * as z from "zod/v4";
-
-test("check any inference", () => {
-  const t1 = z.any();
-  t1.optional();
-  t1.nullable();
-  type t1 = z.infer<typeof t1>;
-  expectTypeOf<t1>().toEqualTypeOf<any>();
-});
-
-test("check unknown inference", () => {
-  const t1 = z.unknown();
-  t1.optional();
-  t1.nullable();
-  type t1 = z.infer<typeof t1>;
-  expectTypeOf<t1>().toEqualTypeOf<unknown>();
-});
-
-test("check never inference", () => {
-  const t1 = z.never();
-  expect(() => t1.parse(undefined)).toThrow();
-  expect(() => t1.parse("asdf")).toThrow();
-  expect(() => t1.parse(null)).toThrow();
-});

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

@@ -1,86 +0,0 @@
-import { expect, expectTypeOf, test } from "vitest";
-
-import * as z from "zod/v4";
-
-test("basic apply (object)", () => {
-  const schema = z
-    .object({
-      a: z.number(),
-      b: z.string(),
-    })
-    .apply((s) => s.omit({ b: true }))
-    .apply((s) => s.extend({ c: z.boolean() }));
-
-  expect(z.toJSONSchema(schema)).toMatchInlineSnapshot(`
-    {
-      "$schema": "https://json-schema.org/draft/2020-12/schema",
-      "additionalProperties": false,
-      "properties": {
-        "a": {
-          "type": "number",
-        },
-        "c": {
-          "type": "boolean",
-        },
-      },
-      "required": [
-        "a",
-        "c",
-      ],
-      "type": "object",
-    }
-  `);
-  expectTypeOf<z.infer<typeof schema>>().toEqualTypeOf<{
-    a: number;
-    c: boolean;
-  }>();
-});
-
-test("basic apply (number)", () => {
-  const setCommonNumberChecks = <T extends z.ZodNumber>(schema: T) => {
-    return schema.min(0).max(100);
-  };
-
-  const schema = z.number().apply(setCommonNumberChecks).nullable();
-
-  expect(() => schema.parse(-1)).toThrowError();
-  expect(() => schema.parse(101)).toThrowError();
-  expect(schema.parse(0)).toBe(0);
-  expect(schema.parse(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>();
-});
-
-test("apply forwards extra args to the callback", () => {
-  const withDefault = <TSchema extends z.ZodType>(schema: TSchema, defaultValue: z.output<TSchema>) => {
-    return schema.nullish().transform((x) => x ?? defaultValue);
-  };
-
-  const schema = z.string().apply(withDefault, "default-id");
-
-  expect(schema.parse(undefined)).toBe("default-id");
-  expect(schema.parse(null)).toBe("default-id");
-  expect(schema.parse("value")).toBe("value");
-  expectTypeOf<z.infer<typeof schema>>().toEqualTypeOf<string>();
-});
-
-test("apply type-checks the extra args", () => {
-  const withMin = (schema: z.ZodString, n: number) => schema.min(n);
-
-  expect(z.string().apply(withMin, 3).parse("abcd")).toBe("abcd");
-  expectTypeOf(z.number().apply<z.ZodNumber>((schema) => schema.min(0))).toEqualTypeOf<z.ZodNumber>();
-
-  // @ts-expect-error wrong arg type
-  z.string().apply(withMin, "3");
-  // @ts-expect-error missing arg
-  z.string().apply(withMin);
-  // @ts-expect-error extra arg for a single-parameter callback
-  z.string().apply((schema: z.ZodString) => schema, 3);
-});

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

@@ -1,291 +0,0 @@
-import { expect, expectTypeOf, test } from "vitest";
-import * as z from "zod/v4";
-
-test("type inference", () => {
-  const schema = z.string().array();
-  expectTypeOf<z.infer<typeof schema>>().toEqualTypeOf<string[]>();
-});
-
-test("array min/max", () => {
-  const schema = z.array(z.string()).min(2).max(2);
-  const r1 = schema.safeParse(["asdf"]);
-  expect(r1.success).toEqual(false);
-  expect(r1.error!.issues).toMatchInlineSnapshot(`
-    [
-      {
-        "code": "too_small",
-        "inclusive": true,
-        "message": "Too small: expected array to have >=2 items",
-        "minimum": 2,
-        "origin": "array",
-        "path": [],
-      },
-    ]
-  `);
-
-  const r2 = schema.safeParse(["asdf", "asdf", "asdf"]);
-  expect(r2.success).toEqual(false);
-  expect(r2.error!.issues).toMatchInlineSnapshot(`
-    [
-      {
-        "code": "too_big",
-        "inclusive": true,
-        "maximum": 2,
-        "message": "Too big: expected array to have <=2 items",
-        "origin": "array",
-        "path": [],
-      },
-    ]
-  `);
-});
-
-test("array length", () => {
-  const schema = z.array(z.string()).length(2);
-  schema.parse(["asdf", "asdf"]);
-
-  const r1 = schema.safeParse(["asdf"]);
-  expect(r1.success).toEqual(false);
-  expect(r1.error!.issues).toMatchInlineSnapshot(`
-    [
-      {
-        "code": "too_small",
-        "exact": true,
-        "inclusive": true,
-        "message": "Too small: expected array to have exactly 2 items",
-        "minimum": 2,
-        "origin": "array",
-        "path": [],
-      },
-    ]
-  `);
-
-  const r2 = schema.safeParse(["asdf", "asdf", "asdf"]);
-  expect(r2.success).toEqual(false);
-  expect(r2.error!.issues).toMatchInlineSnapshot(`
-    [
-      {
-        "code": "too_big",
-        "exact": true,
-        "inclusive": true,
-        "maximum": 2,
-        "message": "Too big: expected array to have exactly 2 items",
-        "origin": "array",
-        "path": [],
-      },
-    ]
-  `);
-});
-
-test("array.nonempty()", () => {
-  const schema = z.string().array().nonempty();
-  schema.parse(["a"]);
-  expect(() => schema.parse([])).toThrow();
-});
-
-test("array.nonempty().max()", () => {
-  const schema = z.string().array().nonempty().max(2);
-  schema.parse(["a"]);
-  expect(() => schema.parse([])).toThrow();
-  expect(() => schema.parse(["a", "a", "a"])).toThrow();
-});
-
-test("parse empty array in nonempty", () => {
-  expect(() =>
-    z
-      .array(z.string())
-      .nonempty()
-      .parse([] as any)
-  ).toThrow();
-});
-
-test("get element", () => {
-  const schema = z.string().array();
-  schema.element.parse("asdf");
-  expect(() => schema.element.parse(12)).toThrow();
-});
-
-test("continue parsing despite array size error", () => {
-  const schema = z.object({
-    people: z.string().array().min(2),
-  });
-
-  const result = schema.safeParse({
-    people: [123],
-  });
-  expect(result).toMatchInlineSnapshot(`
-    {
-      "error": [ZodError: [
-      {
-        "expected": "string",
-        "code": "invalid_type",
-        "path": [
-          "people",
-          0
-        ],
-        "message": "Invalid input: expected string, received number"
-      },
-      {
-        "origin": "array",
-        "code": "too_small",
-        "minimum": 2,
-        "inclusive": true,
-        "path": [
-          "people"
-        ],
-        "message": "Too small: expected array to have >=2 items"
-      }
-    ]],
-      "success": false,
-    }
-  `);
-});
-
-test("an upper size bound fails before any element is parsed", () => {
-  let parsed = 0;
-  const el = z.string().refine(() => ++parsed);
-  let refined = 0;
-  const schema = z
-    .array(el)
-    .max(2, "too many")
-    .refine(() => ++refined);
-  expect(schema.safeParse([1, 2, 3]).error!.issues).toMatchObject([{ code: "too_big", path: [], message: "too many" }]);
-  expect(z.array(el).length(2).safeParse(["a", "b", "c"]).error!.issues).toMatchObject([
-    { code: "too_big", exact: true },
-  ]);
-  expect(z.object({ a: z.array(el).max(1) }).safeParse({ a: [1, 2] }).error!.issues).toMatchObject([
-    { code: "too_big", path: ["a"] },
-  ]);
-  expect([parsed, refined]).toEqual([0, 0]);
-
-  // a check that may rewrite the value ends the gate
-  expect(
-    z
-      .array(z.number())
-      .overwrite((a) => a.slice(0, 2))
-      .max(2)
-      .parse([1, 2, 3])
-  ).toEqual([1, 2]);
-});
-
-test("parse should fail given sparse array", () => {
-  const schema = z.array(z.string()).nonempty().min(1).max(3);
-  const result = schema.safeParse(new Array(3));
-  expect(result.success).toEqual(false);
-  expect(result).toMatchInlineSnapshot(`
-    {
-      "error": [ZodError: [
-      {
-        "expected": "string",
-        "code": "invalid_type",
-        "path": [
-          0
-        ],
-        "message": "Invalid input: expected string, received undefined"
-      },
-      {
-        "expected": "string",
-        "code": "invalid_type",
-        "path": [
-          1
-        ],
-        "message": "Invalid input: expected string, received undefined"
-      },
-      {
-        "expected": "string",
-        "code": "invalid_type",
-        "path": [
-          2
-        ],
-        "message": "Invalid input: expected string, received undefined"
-      }
-    ]],
-      "success": false,
-    }
-  `);
-});
-
-// const unique = z.string().array().unique();
-// const uniqueArrayOfObjects = z.array(z.object({ name: z.string() })).unique({ identifier: (item) => item.name });
-
-// test("passing unique validation", () => {
-//   unique.parse(["a", "b", "c"]);
-//   uniqueArrayOfObjects.parse([{ name: "Leo" }, { name: "Joe" }]);
-// });
-
-// test("failing unique validation", () => {
-//   expect(() => unique.parse(["a", "a", "b"])).toThrow();
-//   expect(() => uniqueArrayOfObjects.parse([{ name: "Leo" }, { name: "Leo" }])).toThrow();
-// });
-
-// test("continue parsing despite array of primitives uniqueness error", () => {
-//   const schema = z.number().array().unique();
-
-//   const result = schema.safeParse([1, 1, 2, 2, 3]);
-
-//   expect(result.success).toEqual(false);
-//   if (!result.success) {
-//     const issue = result.error.issues.find(({ code }) => code === "not_unique");
-//     expect(issue?.message).toEqual("Values must be unique");
-//   }
-// });
-
-// test("continue parsing despite array of objects not_unique error", () => {
-//   const schema = z.array(z.object({ name: z.string() })).unique({
-//     identifier: (item) => item.name,
-//     showDuplicates: true,
-//   });
-
-//   const result = schema.safeParse([
-//     { name: "Leo" },
-//     { name: "Joe" },
-//     { name: "Leo" },
-//   ]);
-
-//   expect(result.success).toEqual(false);
-//   if (!result.success) {
-//     const issue = result.error.issues.find(({ code }) => code === "not_unique");
-//     expect(issue?.message).toEqual("Element(s): 'Leo' not unique");
-//   }
-// });
-
-// test("returns custom error message without duplicate elements", () => {
-//   const schema = z.number().array().unique({ message: "Custom message" });
-
-//   const result = schema.safeParse([1, 1, 2, 2, 3]);
-
-//   expect(result.success).toEqual(false);
-//   if (!result.success) {
-//     const issue = result.error.issues.find(({ code }) => code === "not_unique");
-//     expect(issue?.message).toEqual("Custom message");
-//   }
-// });
-
-// test("returns error message with duplicate elements", () => {
-//   const schema = z.number().array().unique({ showDuplicates: true });
-
-//   const result = schema.safeParse([1, 1, 2, 2, 3]);
-
-//   expect(result.success).toEqual(false);
-//   if (!result.success) {
-//     const issue = result.error.issues.find(({ code }) => code === "not_unique");
-//     expect(issue?.message).toEqual("Element(s): '1,2' not unique");
-//   }
-// });
-
-// test("returns custom error message with duplicate elements", () => {
-//   const schema = z
-//     .number()
-//     .array()
-//     .unique({
-//       message: (item) => `Custom message: '${item}' are not unique`,
-//       showDuplicates: true,
-//     });
-
-//   const result = schema.safeParse([1, 1, 2, 2, 3]);
-
-//   expect(result.success).toEqual(false);
-//   if (!result.success) {
-//     const issue = result.error.issues.find(({ code }) => code === "not_unique");
-//     expect(issue?.message).toEqual("Custom message: '1,2' are not unique");
-//   }
-// });