@undefineds.co/xpod 0.4.19 → 0.4.25

package/node_modules/@undefineds.co/drizzle-solid/node_modules/zod/src/v4/core/tests/locales/hr.test.ts

@@ -1,163 +0,0 @@
-import { expect, test } from "vitest";
-import { z } from "../../../../index.js";
-import hr from "../../../locales/hr.js";
-
-test("Croatian locale - type name translations in too_small errors", () => {
-  z.config(hr());
-
-  // Test string type translation
-  const stringSchema = z.string().min(5);
-  const stringResult = stringSchema.safeParse("abc");
-  expect(stringResult.success).toBe(false);
-  if (!stringResult.success) {
-    expect(stringResult.error.issues[0].message).toBe("Premalo: očekivano da tekst ima >=5 znakova");
-  }
-
-  // Test number type translation
-  const numberSchema = z.number().min(10);
-  const numberResult = numberSchema.safeParse(5);
-  expect(numberResult.success).toBe(false);
-  if (!numberResult.success) {
-    expect(numberResult.error.issues[0].message).toBe("Premalo: očekivano da broj bude >=10");
-  }
-
-  // Test array type translation
-  const arraySchema = z.array(z.string()).min(3);
-  const arrayResult = arraySchema.safeParse(["a", "b"]);
-  expect(arrayResult.success).toBe(false);
-  if (!arrayResult.success) {
-    expect(arrayResult.error.issues[0].message).toBe("Premalo: očekivano da niz ima >=3 stavki");
-  }
-
-  // Test set type translation
-  const setSchema = z.set(z.string()).min(2);
-  const setResult = setSchema.safeParse(new Set(["a"]));
-  expect(setResult.success).toBe(false);
-  if (!setResult.success) {
-    expect(setResult.error.issues[0].message).toBe("Premalo: očekivano da skup ima >=2 stavki");
-  }
-});
-
-test("Croatian locale - type name translations in too_big errors", () => {
-  z.config(hr());
-
-  // Test string type translation
-  const stringSchema = z.string().max(3);
-  const stringResult = stringSchema.safeParse("abcde");
-  expect(stringResult.success).toBe(false);
-  if (!stringResult.success) {
-    expect(stringResult.error.issues[0].message).toBe("Preveliko: očekivano da tekst ima <=3 znakova");
-  }
-
-  // Test number type translation
-  const numberSchema = z.number().max(10);
-  const numberResult = numberSchema.safeParse(15);
-  expect(numberResult.success).toBe(false);
-  if (!numberResult.success) {
-    expect(numberResult.error.issues[0].message).toBe("Preveliko: očekivano da broj bude <=10");
-  }
-
-  // Test array type translation
-  const arraySchema = z.array(z.string()).max(2);
-  const arrayResult = arraySchema.safeParse(["a", "b", "c"]);
-  expect(arrayResult.success).toBe(false);
-  if (!arrayResult.success) {
-    expect(arrayResult.error.issues[0].message).toBe("Preveliko: očekivano da niz ima <=2 stavki");
-  }
-});
-
-test("Croatian locale - type name translations in invalid_type errors", () => {
-  z.config(hr());
-
-  // Test string expected, number received
-  const stringSchema = z.string();
-  const stringResult = stringSchema.safeParse(123);
-  expect(stringResult.success).toBe(false);
-  if (!stringResult.success) {
-    expect(stringResult.error.issues[0].message).toBe("Neispravan unos: očekuje se tekst, a primljeno je broj");
-  }
-
-  // Test number expected, string received
-  const numberSchema = z.number();
-  const numberResult = numberSchema.safeParse("abc");
-  expect(numberResult.success).toBe(false);
-  if (!numberResult.success) {
-    expect(numberResult.error.issues[0].message).toBe("Neispravan unos: očekuje se broj, a primljeno je tekst");
-  }
-
-  // Test boolean expected, null received
-  const booleanSchema = z.boolean();
-  const booleanResult = booleanSchema.safeParse(null);
-  expect(booleanResult.success).toBe(false);
-  if (!booleanResult.success) {
-    expect(booleanResult.error.issues[0].message).toBe("Neispravan unos: očekuje se boolean, a primljeno je null");
-  }
-
-  // Test array expected, object received
-  const arraySchema = z.array(z.string());
-  const arrayResult = arraySchema.safeParse({});
-  expect(arrayResult.success).toBe(false);
-  if (!arrayResult.success) {
-    expect(arrayResult.error.issues[0].message).toBe("Neispravan unos: očekuje se niz, a primljeno je objekt");
-  }
-});
-
-test("Croatian locale - other error cases", () => {
-  z.config(hr());
-
-  // Test invalid_element with tuple
-  const tupleSchema = z.tuple([z.string(), z.number()]);
-  const tupleResult = tupleSchema.safeParse(["abc", "not a number"]);
-  expect(tupleResult.success).toBe(false);
-  if (!tupleResult.success) {
-    expect(tupleResult.error.issues[0].message).toContain("Neispravan unos");
-  }
-
-  // Test invalid_value with enum
-  const enumSchema = z.enum(["a", "b"]);
-  const enumResult = enumSchema.safeParse("c");
-  expect(enumResult.success).toBe(false);
-  if (!enumResult.success) {
-    expect(enumResult.error.issues[0].message).toBe('Neispravna opcija: očekivano jedno od "a"|"b"');
-  }
-
-  // Test not_multiple_of
-  const multipleSchema = z.number().multipleOf(3);
-  const multipleResult = multipleSchema.safeParse(10);
-  expect(multipleResult.success).toBe(false);
-  if (!multipleResult.success) {
-    expect(multipleResult.error.issues[0].message).toBe("Neispravan broj: mora biti višekratnik od 3");
-  }
-
-  // Test unrecognized_keys
-  const strictSchema = z.object({ a: z.string() }).strict();
-  const strictResult = strictSchema.safeParse({ a: "test", b: "extra" });
-  expect(strictResult.success).toBe(false);
-  if (!strictResult.success) {
-    expect(strictResult.error.issues[0].message).toBe('Neprepoznat ključ: "b"');
-  }
-
-  // Test invalid_union
-  const unionSchema = z.union([z.string(), z.number()]);
-  const unionResult = unionSchema.safeParse(true);
-  expect(unionResult.success).toBe(false);
-  if (!unionResult.success) {
-    expect(unionResult.error.issues[0].message).toBe("Neispravan unos");
-  }
-
-  // Test invalid_format with regex
-  const regexSchema = z.string().regex(/^[a-z]+$/);
-  const regexResult = regexSchema.safeParse("ABC123");
-  expect(regexResult.success).toBe(false);
-  if (!regexResult.success) {
-    expect(regexResult.error.issues[0].message).toBe("Neispravan tekst: mora odgovarati uzorku /^[a-z]+$/");
-  }
-
-  // Test invalid_format with startsWith
-  const startsWithSchema = z.string().startsWith("hello");
-  const startsWithResult = startsWithSchema.safeParse("world");
-  expect(startsWithResult.success).toBe(false);
-  if (!startsWithResult.success) {
-    expect(startsWithResult.error.issues[0].message).toBe('Neispravan tekst: mora započinjati s "hello"');
-  }
-});

package/node_modules/@undefineds.co/drizzle-solid/node_modules/zod/src/v4/core/tests/locales/nl.test.ts

@@ -1,46 +0,0 @@
-import { expect, test } from "vitest";
-import nl from "../../../locales/nl.js";
-
-test("Dutch locale error messages", () => {
-  const { localeError } = nl();
-
-  // Test invalid_type
-  expect(
-    localeError({
-      code: "invalid_type",
-      expected: "string",
-      input: 123,
-    })
-  ).toBe("Ongeldige invoer: verwacht string, ontving getal");
-
-  // Test too_big with sizing
-  expect(
-    localeError({
-      code: "too_big",
-      origin: "string",
-      maximum: 10,
-      inclusive: true,
-      input: "test string that is too long",
-    })
-  ).toBe("Te lang: verwacht dat string <=10 tekens heeft");
-
-  // Test too_small with sizing
-  expect(
-    localeError({
-      code: "too_small",
-      origin: "array",
-      minimum: 5,
-      inclusive: false,
-      input: [1, 2],
-    })
-  ).toBe("Te klein: verwacht dat array >5 elementen heeft");
-
-  // Test invalid_format
-  expect(
-    localeError({
-      code: "invalid_format",
-      format: "email",
-      input: "invalid-email",
-    })
-  ).toBe("Ongeldig: emailadres");
-});

package/node_modules/@undefineds.co/drizzle-solid/node_modules/zod/src/v4/core/tests/locales/ru.test.ts

@@ -1,128 +0,0 @@
-import { describe, expect, it } from "vitest";
-import ru from "../../../locales/ru.js";
-
-describe("Russian localization", () => {
-  const localeError = ru().localeError;
-
-  describe("pluralization rules", () => {
-    for (const { type, cases } of TEST_CASES) {
-      describe(`${type} pluralization`, () => {
-        for (const { count, expected } of cases) {
-          it(`correctly pluralizes ${count} ${type}`, () => {
-            const error = localeError({
-              code: "too_small",
-              minimum: count,
-              type: "number",
-              inclusive: true,
-              path: [],
-              origin: type,
-              input: count - 1,
-            });
-
-            expect(error).toContain(expected);
-          });
-        }
-      });
-    }
-
-    it("handles negative numbers correctly", () => {
-      const error = localeError({
-        code: "too_small",
-        minimum: -2,
-        type: "number",
-        inclusive: true,
-        path: [],
-        origin: "array",
-        input: -3,
-      });
-
-      expect(error).toContain("-2 элемента");
-    });
-
-    it("handles zero correctly", () => {
-      const error = localeError({
-        code: "too_small",
-        minimum: 0,
-        type: "number",
-        inclusive: true,
-        path: [],
-        origin: "array",
-        input: -1,
-      });
-
-      expect(error).toContain("0 элементов");
-    });
-
-    it("handles bigint values correctly", () => {
-      const error = localeError({
-        code: "too_small",
-        minimum: BigInt(21),
-        type: "number",
-        inclusive: true,
-        path: [],
-        origin: "array",
-        input: BigInt(20),
-      });
-
-      expect(error).toContain("21 элемент");
-    });
-  });
-});
-
-const TEST_CASES = [
-  {
-    type: "array",
-    cases: [
-      { count: 1, expected: "1 элемент" },
-      { count: 2, expected: "2 элемента" },
-      { count: 5, expected: "5 элементов" },
-      { count: 11, expected: "11 элементов" },
-      { count: 21, expected: "21 элемент" },
-      { count: 22, expected: "22 элемента" },
-      { count: 25, expected: "25 элементов" },
-      { count: 101, expected: "101 элемент" },
-      { count: 111, expected: "111 элементов" },
-    ],
-  },
-  {
-    type: "set",
-    cases: [
-      { count: 1, expected: "1 элемент" },
-      { count: 2, expected: "2 элемента" },
-      { count: 5, expected: "5 элементов" },
-      { count: 11, expected: "11 элементов" },
-      { count: 21, expected: "21 элемент" },
-      { count: 22, expected: "22 элемента" },
-      { count: 25, expected: "25 элементов" },
-      { count: 101, expected: "101 элемент" },
-      { count: 111, expected: "111 элементов" },
-    ],
-  },
-  {
-    type: "string",
-    cases: [
-      { count: 1, expected: "1 символ" },
-      { count: 2, expected: "2 символа" },
-      { count: 5, expected: "5 символов" },
-      { count: 11, expected: "11 символов" },
-      { count: 21, expected: "21 символ" },
-      { count: 22, expected: "22 символа" },
-      { count: 25, expected: "25 символов" },
-    ],
-  },
-  {
-    type: "file",
-    cases: [
-      { count: 0, expected: "0 байт" },
-      { count: 1, expected: "1 байт" },
-      { count: 2, expected: "2 байта" },
-      { count: 5, expected: "5 байт" },
-      { count: 11, expected: "11 байт" },
-      { count: 21, expected: "21 байт" },
-      { count: 22, expected: "22 байта" },
-      { count: 25, expected: "25 байт" },
-      { count: 101, expected: "101 байт" },
-      { count: 110, expected: "110 байт" },
-    ],
-  },
-] as const;

package/node_modules/@undefineds.co/drizzle-solid/node_modules/zod/src/v4/core/tests/locales/tr.test.ts

@@ -1,69 +0,0 @@
-import { expect, test } from "vitest";
-import * as z from "zod/v4";
-import { parsedType } from "../../util.js";
-
-test("parsedType", () => {
-  expect(parsedType("string")).toBe("string");
-  expect(parsedType(1)).toBe("number");
-  expect(parsedType(true)).toBe("boolean");
-  expect(parsedType(null)).toBe("null");
-  expect(parsedType(undefined)).toBe("undefined");
-  expect(parsedType([])).toBe("array");
-  expect(parsedType({})).toBe("object");
-  expect(parsedType(new Date())).toBe("Date");
-  expect(parsedType(new Map())).toBe("Map");
-  expect(parsedType(new Set())).toBe("Set");
-  expect(parsedType(new Error())).toBe("Error");
-
-  const nullPrototype = Object.create(null);
-  expect(parsedType(nullPrototype)).toBe("object");
-
-  const doubleNullPrototype = Object.create(Object.create(null));
-  expect(parsedType(doubleNullPrototype)).toBe("object");
-
-  expect(parsedType(Number.NaN)).toBe("nan");
-});
-
-test("locales - tr", () => {
-  z.config(z.locales.tr());
-
-  const invalidType = z.number().safeParse("a");
-  expect(invalidType.error!.issues[0].code).toBe("invalid_type");
-  expect(invalidType.error!.issues[0].message).toBe("Geçersiz değer: beklenen number, alınan string");
-
-  const invalidType2 = z.string().safeParse(1);
-  expect(invalidType2.error!.issues[0].code).toBe("invalid_type");
-  expect(invalidType2.error!.issues[0].message).toBe("Geçersiz değer: beklenen string, alınan number");
-
-  const invalidValue = z.enum(["a", "b"]).safeParse(1);
-  expect(invalidValue.error!.issues[0].code).toBe("invalid_value");
-  expect(invalidValue.error!.issues[0].message).toBe('Geçersiz seçenek: aşağıdakilerden biri olmalı: "a"|"b"');
-
-  const tooBig = z.number().max(10).safeParse(15);
-  expect(tooBig.error!.issues[0].code).toBe("too_big");
-  expect(tooBig.error!.issues[0].message).toBe("Çok büyük: beklenen number <=10");
-
-  const tooSmall = z.number().min(10).safeParse(5);
-  expect(tooSmall.error!.issues[0].code).toBe("too_small");
-  expect(tooSmall.error!.issues[0].message).toBe("Çok küçük: beklenen number >=10");
-
-  const invalidFormatRegex = z.string().regex(/abcd/).safeParse("invalid-string");
-  expect(invalidFormatRegex.error!.issues[0].code).toBe("invalid_format");
-  expect(invalidFormatRegex.error!.issues[0].message).toBe("Geçersiz metin: /abcd/ desenine uymalı");
-
-  const invalidFormatStartsWith = z.string().startsWith("abcd").safeParse("invalid-string");
-  expect(invalidFormatStartsWith.error!.issues[0].code).toBe("invalid_format");
-  expect(invalidFormatStartsWith.error!.issues[0].message).toBe('Geçersiz metin: "abcd" ile başlamalı');
-
-  const notMultipleOf = z.number().multipleOf(3).safeParse(10);
-  expect(notMultipleOf.error!.issues[0].code).toBe("not_multiple_of");
-  expect(notMultipleOf.error!.issues[0].message).toBe("Geçersiz sayı: 3 ile tam bölünebilmeli");
-
-  const unrecognizedKeys = z.object({ a: z.string(), b: z.number() }).strict().safeParse({ a: "a", b: 1, c: 2 });
-  expect(unrecognizedKeys.error!.issues[0].code).toBe("unrecognized_keys");
-  expect(unrecognizedKeys.error!.issues[0].message).toBe('Tanınmayan anahtar: "c"');
-
-  const invalidUnion = z.union([z.string(), z.number()]).safeParse(true);
-  expect(invalidUnion.error!.issues[0].code).toBe("invalid_union");
-  expect(invalidUnion.error!.issues[0].message).toBe("Geçersiz değer");
-});

package/node_modules/@undefineds.co/drizzle-solid/node_modules/zod/src/v4/core/tests/locales/uz.test.ts

@@ -1,105 +0,0 @@
-import { expect, test } from "vitest";
-import * as z from "zod/v4";
-
-test("locales - uz", () => {
-  z.config(z.locales.uz());
-
-  const invalidType = z.number().safeParse("a");
-  expect(invalidType.error!.issues[0].code).toBe("invalid_type");
-  expect(invalidType.error!.issues[0].message).toBe("Noto‘g‘ri kirish: kutilgan raqam, qabul qilingan string");
-
-  const invalidType2 = z.string().safeParse(1);
-  expect(invalidType2.error!.issues[0].code).toBe("invalid_type");
-  expect(invalidType2.error!.issues[0].message).toBe("Noto‘g‘ri kirish: kutilgan string, qabul qilingan raqam");
-
-  const invalidValue = z.enum(["a", "b"]).safeParse(1);
-  expect(invalidValue.error!.issues[0].code).toBe("invalid_value");
-  expect(invalidValue.error!.issues[0].message).toBe('Noto‘g‘ri variant: quyidagilardan biri kutilgan "a"|"b"');
-
-  const tooBig = z.number().max(10).safeParse(15);
-  expect(tooBig.error!.issues[0].code).toBe("too_big");
-  expect(tooBig.error!.issues[0].message).toBe("Juda katta: kutilgan number <=10");
-
-  const tooSmall = z.number().min(10).safeParse(5);
-  expect(tooSmall.error!.issues[0].code).toBe("too_small");
-  expect(tooSmall.error!.issues[0].message).toBe("Juda kichik: kutilgan number >=10");
-
-  const invalidFormatRegex = z.string().regex(/abcd/).safeParse("invalid-string");
-  expect(invalidFormatRegex.error!.issues[0].code).toBe("invalid_format");
-  expect(invalidFormatRegex.error!.issues[0].message).toContain("shabloniga mos kelishi kerak");
-
-  const invalidFormatStartsWith = z.string().startsWith("abcd").safeParse("invalid-string");
-  expect(invalidFormatStartsWith.error!.issues[0].code).toBe("invalid_format");
-  expect(invalidFormatStartsWith.error!.issues[0].message).toContain('"abcd" bilan boshlanishi kerak');
-
-  const notMultipleOf = z.number().multipleOf(3).safeParse(10);
-  expect(notMultipleOf.error!.issues[0].code).toBe("not_multiple_of");
-  expect(notMultipleOf.error!.issues[0].message).toContain("3 ning karralisi bo‘lishi kerak");
-
-  const unrecognizedKeys = z.object({ a: z.string(), b: z.number() }).strict().safeParse({ a: "a", b: 1, c: 2 });
-  expect(unrecognizedKeys.error!.issues[0].code).toBe("unrecognized_keys");
-  expect(unrecognizedKeys.error!.issues[0].message).toContain('Noma’lum kalit: "c"');
-
-  const invalidUnion = z.union([z.string(), z.number()]).safeParse(true);
-  expect(invalidUnion.error!.issues[0].code).toBe("invalid_union");
-  expect(invalidUnion.error!.issues[0].message).toBe("Noto‘g‘ri kirish");
-
-  const tooBigString = z.string().max(5).safeParse("too long string");
-  expect(tooBigString.error!.issues[0].code).toBe("too_big");
-  expect(tooBigString.error!.issues[0].message).toContain("belgi");
-  expect(tooBigString.error!.issues[0].message).toContain("bo‘lishi kerak");
-
-  const tooSmallArray = z.array(z.string()).min(3).safeParse(["a", "b"]);
-  expect(tooSmallArray.error!.issues[0].code).toBe("too_small");
-  expect(tooSmallArray.error!.issues[0].message).toContain("element");
-  expect(tooSmallArray.error!.issues[0].message).toContain("bo‘lishi kerak");
-
-  const invalidFormatEndsWith = z.string().endsWith("xyz").safeParse("invalid-string");
-  expect(invalidFormatEndsWith.error!.issues[0].code).toBe("invalid_format");
-  expect(invalidFormatEndsWith.error!.issues[0].message).toContain('"xyz" bilan tugashi kerak');
-
-  const invalidFormatIncludes = z.string().includes("test").safeParse("invalid-string");
-  expect(invalidFormatIncludes.error!.issues[0].code).toBe("invalid_format");
-  expect(invalidFormatIncludes.error!.issues[0].message).toContain('"test" ni o‘z ichiga olishi kerak');
-
-  const invalidFormatEmail = z.string().email().safeParse("invalid-email");
-  expect(invalidFormatEmail.error!.issues[0].code).toBe("invalid_format");
-  expect(invalidFormatEmail.error!.issues[0].message).toContain("elektron pochta manzili");
-
-  const invalidFormatUrl = z.string().url().safeParse("invalid-url");
-  expect(invalidFormatUrl.error!.issues[0].code).toBe("invalid_format");
-  expect(invalidFormatUrl.error!.issues[0].message).toContain("URL");
-
-  const unrecognizedKeysMultiple = z
-    .object({ a: z.string(), b: z.number() })
-    .strict()
-    .safeParse({ a: "a", b: 1, c: 2, d: 3 });
-  expect(unrecognizedKeysMultiple.error!.issues[0].code).toBe("unrecognized_keys");
-  expect(unrecognizedKeysMultiple.error!.issues[0].message).toContain("Noma’lum kalitlar");
-
-  const invalidElement = z.array(z.string()).safeParse([1, 2, 3]);
-  expect(invalidElement.error!.issues[0].code).toBe("invalid_type");
-  expect(invalidElement.error!.issues[0].message).toContain("raqam");
-
-  const tooSmallMap = z
-    .map(z.string(), z.string())
-    .min(3)
-    .safeParse(new Map([["a", "b"]]));
-  expect(tooSmallMap.error!.issues[0].code).toBe("too_small");
-  expect(tooSmallMap.error!.issues[0].message).toContain("yozuv");
-  expect(tooSmallMap.error!.issues[0].message).toContain("bo‘lishi kerak");
-
-  const tooBigMap = z
-    .map(z.string(), z.string())
-    .max(2)
-    .safeParse(
-      new Map([
-        ["a", "b"],
-        ["c", "d"],
-        ["e", "f"],
-      ])
-    );
-  expect(tooBigMap.error!.issues[0].code).toBe("too_big");
-  expect(tooBigMap.error!.issues[0].message).toContain("yozuv");
-  expect(tooBigMap.error!.issues[0].message).toContain("bo‘lishi kerak");
-});

package/node_modules/@undefineds.co/drizzle-solid/node_modules/zod/src/v4/core/tests/record-constructor.test.ts

@@ -1,125 +0,0 @@
-import { expect, test } from "vitest";
-import * as z from "zod/v4";
-
-test("record should parse objects with non-function constructor field", () => {
-  const schema = z.record(z.string(), z.any());
-
-  expect(() => schema.parse({ constructor: "string", key: "value" })).not.toThrow();
-
-  const result1 = schema.parse({ constructor: "string", key: "value" });
-  expect(result1).toEqual({ constructor: "string", key: "value" });
-
-  expect(() => schema.parse({ constructor: 123, key: "value" })).not.toThrow();
-
-  const result2 = schema.parse({ constructor: 123, key: "value" });
-  expect(result2).toEqual({ constructor: 123, key: "value" });
-
-  expect(() => schema.parse({ constructor: null, key: "value" })).not.toThrow();
-
-  const result3 = schema.parse({ constructor: null, key: "value" });
-  expect(result3).toEqual({ constructor: null, key: "value" });
-
-  expect(() => schema.parse({ constructor: {}, key: "value" })).not.toThrow();
-
-  const result4 = schema.parse({ constructor: {}, key: "value" });
-  expect(result4).toEqual({ constructor: {}, key: "value" });
-
-  expect(() => schema.parse({ constructor: [], key: "value" })).not.toThrow();
-
-  const result5 = schema.parse({ constructor: [], key: "value" });
-  expect(result5).toEqual({ constructor: [], key: "value" });
-
-  expect(() => schema.parse({ constructor: true, key: "value" })).not.toThrow();
-
-  const result6 = schema.parse({ constructor: true, key: "value" });
-  expect(result6).toEqual({ constructor: true, key: "value" });
-});
-
-test("record should still work with normal objects", () => {
-  const schema = z.record(z.string(), z.string());
-
-  expect(() => schema.parse({ normalKey: "value" })).not.toThrow();
-
-  const result1 = schema.parse({ normalKey: "value" });
-  expect(result1).toEqual({ normalKey: "value" });
-
-  expect(() => schema.parse({ key1: "value1", key2: "value2" })).not.toThrow();
-
-  const result2 = schema.parse({ key1: "value1", key2: "value2" });
-  expect(result2).toEqual({ key1: "value1", key2: "value2" });
-});
-
-test("record should validate values according to schema even with constructor field", () => {
-  const stringSchema = z.record(z.string(), z.string());
-
-  expect(() => stringSchema.parse({ constructor: "string", key: "value" })).not.toThrow();
-
-  expect(() => stringSchema.parse({ constructor: 123, key: "value" })).toThrow();
-});
-
-test("record should work with different key types and constructor field", () => {
-  const enumSchema = z.record(z.enum(["constructor", "key"]), z.string());
-
-  expect(() => enumSchema.parse({ constructor: "value1", key: "value2" })).not.toThrow();
-
-  const result = enumSchema.parse({ constructor: "value1", key: "value2" });
-  expect(result).toEqual({ constructor: "value1", key: "value2" });
-});
-
-test("record should skip non-enumerable own properties", () => {
-  const schema = z.record(z.string(), z.string());
-
-  const input = { key: "value" };
-  Object.defineProperty(input, "~standard", {
-    value: { validate: () => {}, vendor: "zod", version: 1 },
-    enumerable: false,
-    writable: false,
-    configurable: false,
-  });
-
-  const result = schema.safeParse(input);
-  expect(result.success).toBe(true);
-  if (result.success) {
-    expect(result.data).toEqual({ key: "value" });
-    expect("~standard" in result.data).toBe(false);
-  }
-});
-
-test("record fails on enumerable invalid values even when non-enumerable properties are present", () => {
-  const schema = z.record(z.string(), z.string());
-
-  const input = { key: "value", bad: 123 };
-  Object.defineProperty(input, "hidden", {
-    value: "should be ignored",
-    enumerable: false,
-  });
-
-  const result = schema.safeParse(input);
-  expect(result.success).toBe(false);
-});
-
-test("record validates enumerable Symbol keys and skips non-enumerable Symbol keys", () => {
-  const enumerableSym = Symbol.for("included");
-  const nonEnumerableSym = Symbol.for("hidden");
-  const schema = z.record(z.symbol(), z.string());
-
-  const input: Record<symbol, unknown> = { [enumerableSym]: "value" };
-  Object.defineProperty(input, nonEnumerableSym, {
-    value: 123,
-    enumerable: false,
-  });
-
-  const result = schema.safeParse(input);
-  expect(result.success).toBe(true);
-  if (result.success) {
-    expect(result.data[enumerableSym]).toBe("value");
-    expect(Object.prototype.hasOwnProperty.call(result.data, nonEnumerableSym)).toBe(false);
-  }
-});
-
-test("z.json() accepts z.toJSONSchema() output (issue #5714)", () => {
-  const schema = z.object({ name: z.string() });
-  const jsonSchema = z.toJSONSchema(schema);
-
-  expect(z.json().safeParse(jsonSchema).success).toBe(true);
-});

package/node_modules/@undefineds.co/drizzle-solid/node_modules/zod/src/v4/core/tests/recursive-tuples.test.ts

@@ -1,45 +0,0 @@
-import { describe, expect, it } from "vitest";
-import * as z from "zod/v4";
-
-describe("Recursive Tuples Regression #5089", () => {
-  it("creates recursive tuple without crash", () => {
-    expect(() => {
-      const y = z.lazy((): any => z.tuple([y, y]).or(z.string()));
-    }).not.toThrow();
-  });
-
-  it("parses recursive tuple data correctly", () => {
-    const y = z.lazy((): any => z.tuple([y, y]).or(z.string()));
-
-    // Base case
-    expect(y.parse("hello")).toBe("hello");
-
-    // Recursive cases
-    expect(() => y.parse(["a", "b"])).not.toThrow();
-    expect(() => y.parse(["a", ["b", "c"]])).not.toThrow();
-  });
-
-  it("matches #5089 expected behavior", () => {
-    // Exact code from the issue
-    expect(() => {
-      const y = z.lazy((): any => z.tuple([y, y]).or(z.string()));
-      y.parse(["a", ["b", "c"]]);
-    }).not.toThrow();
-  });
-
-  it("handles workaround pattern", () => {
-    // Alternative pattern from issue discussion
-    expect(() => {
-      const y = z.lazy((): any => z.string().or(z.lazy(() => z.tuple([y, y]))));
-      y.parse(["a", ["b", "c"]]);
-    }).not.toThrow();
-  });
-
-  it("recursive arrays still work (comparison)", () => {
-    const y = z.lazy((): any => z.array(y).or(z.string()));
-
-    expect(y.parse("hello")).toBe("hello");
-    expect(y.parse(["hello", "world"])).toEqual(["hello", "world"]);
-    expect(y.parse(["a", ["b", "c"]])).toEqual(["a", ["b", "c"]]);
-  });
-});