cross-seed 7.0.0-21 → 7.0.0-23

package/node_modules/zod/src/v4/classic/tests/codec-examples.test.ts

@@ -554,8 +554,7 @@ test("codec transform error handling", () => {
     expect(validResult.data).toEqual({ valid: "json" });
   }
 
-  // Test invalid JSON that should create a single "invalid_format" issue
-  // Verifies that the transform error aborts before reaching the output schema
+  // Test invalid JSON that should create a single "invalid_format" issue. Verifies that the transform error aborts before reaching the output schema
   const invalidResult = z.safeDecode(anyJSON, '{"invalid":,}');
   expect(invalidResult.success).toBe(false);
   if (!invalidResult.success) {

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

@@ -1,4 +1,4 @@
-import { expect, expectTypeOf, test } from "vitest";
+import { describe, expect, expectTypeOf, test } from "vitest";
 import * as z from "zod/v4";
 
 const isoDateCodec = z.codec(
@@ -100,7 +100,7 @@ test("safe codec operations", () => {
           "message": "Invalid ISO datetime",
           "origin": "string",
           "path": [],
-          "pattern": "/^(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))T(?:(?:[01]\\d|2[0-3]):[0-5]\\d(?::[0-5]\\d(?:\\.\\d+)?)?(?:Z))$/",
+          "pattern": "/^(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))T(?:(?:[01]\\d|2[0-3]):[0-5]\\d:[0-5]\\d(?:\\.\\d+)?(?:Z))$/",
         },
       ]
     `);
@@ -241,6 +241,7 @@ test("nested codec with object containing codec property", () => {
   `);
 
   // Test refinements at all levels
+
   // String validation (empty waypoint name)
   const emptyNameResult = z.safeDecode(waypointSchema, {
     name: "",
@@ -560,3 +561,144 @@ test("async codec functionality", async () => {
   const mixedResult = await z.decodeAsync(mixedCodec, "123");
   expect(mixedResult).toBe(123);
 });
+
+test("invertCodec basic", () => {
+  const inverted = z.invertCodec(isoDateCodec);
+
+  const testDate = new Date("2024-01-15T10:30:00.000Z");
+  const decoded = z.decode(inverted, testDate);
+  expect(typeof decoded).toBe("string");
+  expect(decoded).toBe("2024-01-15T10:30:00.000Z");
+
+  const encoded = z.encode(inverted, "2024-01-15T10:30:00.000Z");
+  expect(encoded).toBeInstanceOf(Date);
+  expect(encoded.toISOString()).toBe("2024-01-15T10:30:00.000Z");
+});
+
+test("invertCodec round trip", () => {
+  const inverted = z.invertCodec(isoDateCodec);
+  const testDate = new Date("2024-06-01T12:00:00.000Z");
+
+  const toStr = z.decode(inverted, testDate);
+  const backToDate = z.encode(inverted, toStr);
+  expect(backToDate.toISOString()).toBe(testDate.toISOString());
+});
+
+test("invertCodec types", () => {
+  const inverted = z.invertCodec(isoDateCodec);
+
+  type InvIn = z.input<typeof inverted>;
+  type InvOut = z.output<typeof inverted>;
+  expectTypeOf<InvIn>().toEqualTypeOf<Date>();
+  expectTypeOf<InvOut>().toEqualTypeOf<string>();
+});
+
+test("invertCodec is its own inverse", () => {
+  const doubleInverted = z.invertCodec(z.invertCodec(isoDateCodec));
+  const testIsoString = "2024-03-10T08:00:00.000Z";
+
+  const decoded = z.decode(doubleInverted, testIsoString);
+  expect(decoded).toBeInstanceOf(Date);
+  expect(decoded.toISOString()).toBe(testIsoString);
+
+  const encoded = z.encode(doubleInverted, decoded);
+  expect(encoded).toBe(testIsoString);
+});
+
+test("invertCodec with custom codec", () => {
+  const intToString = z.codec(z.int(), z.string().regex(/^\d+$/), {
+    decode: (num) => num.toString(),
+    encode: (str) => Number.parseInt(str, 10),
+  });
+
+  const stringToInt = z.invertCodec(intToString);
+  const result = z.decode(stringToInt, "42");
+  expect(result).toBe(42);
+
+  const back = z.encode(stringToInt, 42);
+  expect(back).toBe("42");
+});
+
+describe("context immutability", () => {
+  test("decode/encode", () => {
+    const stringToDateCodec = z.codec(z.iso.datetime(), z.date(), {
+      decode: (isoString) => new Date(isoString),
+      encode: (date) => date.toISOString(),
+    });
+
+    const ctx = { reportInput: true } as const;
+
+    const result1 = z.decode(stringToDateCodec, "2024-01-15T10:30:00.000Z", ctx);
+    expect(result1).toBeInstanceOf(Date);
+
+    expect(ctx).toEqual({ reportInput: true });
+    expect("async" in ctx).toBe(false);
+    expect("direction" in ctx).toBe(false);
+
+    const result2 = z.decode(stringToDateCodec, "2024-12-25T15:45:30.123Z", ctx);
+    expect(result2).toBeInstanceOf(Date);
+
+    expect(ctx).toEqual({ reportInput: true });
+    expect("async" in ctx).toBe(false);
+    expect("direction" in ctx).toBe(false);
+
+    z.encode(stringToDateCodec, new Date("2024-01-01T00:00:00.000Z"), ctx);
+    expect(ctx).toEqual({ reportInput: true });
+    expect("direction" in ctx).toBe(false);
+
+    z.safeEncode(stringToDateCodec, new Date("2024-01-01T00:00:00.000Z"), ctx);
+    expect(ctx).toEqual({ reportInput: true });
+    expect("direction" in ctx).toBe(false);
+  });
+
+  test("parse functions", () => {
+    const schema = z.string().min(1);
+    const ctx = { reportInput: true } as const;
+
+    z.parse(schema, "asdf", ctx);
+    expect(ctx).toEqual({ reportInput: true });
+    expect("async" in ctx).toBe(false);
+
+    z.safeParse(schema, "asdf", ctx);
+    expect(ctx).toEqual({ reportInput: true });
+    expect("async" in ctx).toBe(false);
+  });
+
+  test("async functions", async () => {
+    const stringToDateCodec = z.codec(z.iso.datetime(), z.date(), {
+      decode: (isoString) => new Date(isoString),
+      encode: (date) => date.toISOString(),
+    });
+
+    const ctx = { reportInput: true } as const;
+
+    const schema = z.string();
+    await z.parseAsync(schema, "asdf", ctx);
+    expect(ctx).toEqual({ reportInput: true });
+    expect("async" in ctx).toBe(false);
+
+    await z.safeParseAsync(schema, "asdf", ctx);
+    expect(ctx).toEqual({ reportInput: true });
+    expect("async" in ctx).toBe(false);
+
+    await z.decodeAsync(stringToDateCodec, "2024-01-15T10:30:00.000Z", ctx);
+    expect(ctx).toEqual({ reportInput: true });
+    expect("async" in ctx).toBe(false);
+    expect("direction" in ctx).toBe(false);
+
+    await z.encodeAsync(stringToDateCodec, new Date("2024-01-01T00:00:00.000Z"), ctx);
+    expect(ctx).toEqual({ reportInput: true });
+    expect("async" in ctx).toBe(false);
+    expect("direction" in ctx).toBe(false);
+
+    await z.safeDecodeAsync(stringToDateCodec, "2024-01-15T10:30:00.000Z", ctx);
+    expect(ctx).toEqual({ reportInput: true });
+    expect("async" in ctx).toBe(false);
+    expect("direction" in ctx).toBe(false);
+
+    await z.safeEncodeAsync(stringToDateCodec, new Date("2024-01-01T00:00:00.000Z"), ctx);
+    expect(ctx).toEqual({ reportInput: true });
+    expect("async" in ctx).toBe(false);
+    expect("direction" in ctx).toBe(false);
+  });
+});

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

@@ -40,7 +40,7 @@ test("continuability", () => {
         "message": "Invalid email address",
         "origin": "string",
         "path": [],
-        "pattern": "/^(?!\\.)(?!.*\\.\\.)([A-Za-z0-9_'+\\-\\.]*)[A-Za-z0-9_+-]@([A-Za-z0-9][A-Za-z0-9\\-]*\\.)+[A-Za-z]{2,}$/",
+        "pattern": "/^(?:[A-Za-z0-9_'+\\-]+\\.)*[A-Za-z0-9_'+\\-]*[A-Za-z0-9_+-]@(?:[A-Za-z0-9][A-Za-z0-9\\-]*\\.)+[A-Za-z]{2,}$/",
       },
       {
         "code": "custom",
@@ -230,7 +230,7 @@ test("continuability", () => {
         "message": "Invalid emoji",
         "origin": "string",
         "path": [],
-        "pattern": "/^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$/u",
+        "pattern": "/^(?=[\\s\\S]*[\\p{Extended_Pictographic}\\p{Regional_Indicator}\\u20E3])[\\p{Extended_Pictographic}\\p{Emoji_Component}]+$/u",
       },
       {
         "code": "custom",
@@ -274,7 +274,7 @@ test("continuability", () => {
         "message": "Invalid cuid",
         "origin": "string",
         "path": [],
-        "pattern": "/^[cC][^\\s-]{8,}$/",
+        "pattern": "/^[cC][0-9a-z]{6,}$/",
       },
       {
         "code": "custom",
@@ -318,7 +318,7 @@ test("continuability", () => {
         "message": "Invalid ULID",
         "origin": "string",
         "path": [],
-        "pattern": "/^[0-9A-HJKMNP-TV-Za-hjkmnp-tv-z]{26}$/",
+        "pattern": "/^[0-7][0-9A-HJKMNP-TV-Za-hjkmnp-tv-z]{25}$/",
       },
       {
         "code": "custom",

package/node_modules/zod/src/v4/classic/tests/credit-card.test.ts

@@ -0,0 +1,76 @@
+import { describe, expect, test } from "vitest";
+import * as z from "zod";
+
+describe("z.creditCard", () => {
+  // Luhn-valid PANs. The last four are the schemes an issuer allowlist would turn away — validation is shape plus Luhn only, so the BIN is never consulted.
+  const valid: [string, string][] = [
+    ["Visa", "4111111111111111"],
+    ["Visa (13)", "4007000000027"],
+    ["Mastercard", "5555555555554444"],
+    ["AmEx", "378282246310005"],
+    ["Discover", "6011111111111117"],
+    ["JCB", "3530111333300000"],
+    ["Diners Club", "30569309025904"],
+    ["UnionPay", "6200000000000005"],
+    ["Mir", "2200000000000004"],
+    ["Elo", "6362000000000009"],
+    ["Discover 644-649", "6450000000000002"],
+    ["Troy", "9792000000000003"],
+  ];
+
+  test.each(valid)("accepts %s", (_label, n) => {
+    expect(z.creditCard().parse(n)).toBe(n);
+  });
+
+  test("accepts single space or hyphen separators", () => {
+    expect(z.creditCard().parse("4111 1111 1111 1111")).toBe("4111 1111 1111 1111");
+    expect(z.creditCard().parse("4111-1111-1111-1111")).toBe("4111-1111-1111-1111");
+  });
+
+  test("rejects other separator shapes", () => {
+    for (const n of ["4111  1111 1111 1111", " 4111111111111111", "4111111111111111 ", "4111.1111.1111.1111"]) {
+      expect(() => z.creditCard().parse(n)).toThrow();
+    }
+  });
+
+  test("accepts the 12- and 19-digit length bounds", () => {
+    expect(z.creditCard().parse("400000000002")).toBe("400000000002");
+    expect(z.creditCard().parse("6250000000000000005")).toBe("6250000000000000005");
+  });
+
+  test("rejects Luhn-valid input outside 12-19 digits", () => {
+    expect(() => z.creditCard().parse("40000000006")).toThrow();
+    expect(() => z.creditCard().parse("40000000000000000002")).toThrow();
+  });
+
+  test("rejects when Luhn fails (right shape, wrong checksum)", () => {
+    expect(() => z.creditCard().parse("4111111111111112")).toThrow();
+  });
+
+  test("rejects non-digit input", () => {
+    expect(() => z.creditCard().parse("not-a-card")).toThrow();
+    expect(() => z.creditCard().parse("")).toThrow();
+  });
+
+  test("carries the shape regex as its JSON Schema pattern", () => {
+    // Luhn is not expressible as a pattern, so `pattern` covers length and separators only.
+    expect(z.toJSONSchema(z.creditCard())).toMatchObject({
+      format: "credit_card",
+      pattern: z.regexes.creditCard.source,
+    });
+  });
+
+  test("round-trips through JSON Schema with the checksum intact", () => {
+    const schema = z.fromJSONSchema(z.toJSONSchema(z.creditCard()));
+    expect(schema.safeParse("4111111111111111").success).toBe(true);
+    expect(schema.safeParse("4111111111111112").success).toBe(false);
+  });
+
+  test("error message references credit card", () => {
+    const result = z.creditCard().safeParse("not-a-card");
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.error.issues[0]?.message).toMatch(/credit card/i);
+    }
+  });
+});