zod 4.0.5 → 4.0.6

package/src/v4/core/util.ts

@@ -283,6 +283,12 @@ export function assignProp<T extends object, K extends PropertyKey>(
   });
 }
 
+export function cloneDef(schema: schemas.$ZodType): any {
+  const def: any = {};
+  Object.defineProperties(def, Object.getOwnPropertyDescriptors(schema._zod.def));
+  return def;
+}
+
 export function getElementAtPath(obj: any, path: (string | number)[] | null | undefined): any {
   if (!path) return obj;
   return path.reduce((acc, key) => acc?.[key], obj);
@@ -314,15 +320,16 @@ export function esc(str: string): string {
   return JSON.stringify(str);
 }
 
-export const captureStackTrace: (targetObject: object, constructorOpt?: Function) => void = Error.captureStackTrace
-  ? Error.captureStackTrace
-  : (..._args) => {};
+export const captureStackTrace: (targetObject: object, constructorOpt?: Function) => void = (
+  "captureStackTrace" in Error ? Error.captureStackTrace : (..._args: any[]) => {}
+) as any;
 
 export function isObject(data: any): data is Record<PropertyKey, unknown> {
   return typeof data === "object" && data !== null && !Array.isArray(data);
 }
 
 export const allowsEval: { value: boolean } = cached(() => {
+  // @ts-ignore
   if (typeof navigator !== "undefined" && navigator?.userAgent?.includes("Cloudflare")) {
     return false;
   }
@@ -409,6 +416,7 @@ export const getParsedType = (data: any): ParsedTypes => {
       if (typeof Date !== "undefined" && data instanceof Date) {
         return "date";
       }
+      // @ts-ignore
       if (typeof File !== "undefined" && data instanceof File) {
         return "file";
       }
@@ -535,71 +543,103 @@ export const BIGINT_FORMAT_RANGES: Record<checks.$ZodBigIntFormats, [bigint, big
 };
 
 export function pick(schema: schemas.$ZodObject, mask: Record<string, unknown>): any {
-  const newShape: Writeable<schemas.$ZodShape> = {};
-  const currDef = schema._zod.def; //.shape;
-
-  for (const key in mask) {
-    if (!(key in currDef.shape)) {
-      throw new Error(`Unrecognized key: "${key}"`);
-    }
-    if (!mask[key]) continue;
-
-    // pick key
-    newShape[key] = currDef.shape[key]!;
-  }
+  const currDef = schema._zod.def;
+
+  const def = cloneDef(schema);
+  Object.defineProperties(def, {
+    shape: {
+      get() {
+        const newShape: Writeable<schemas.$ZodShape> = {};
+        for (const key in mask) {
+          if (!(key in currDef.shape)) {
+            throw new Error(`Unrecognized key: "${key}"`);
+          }
+          if (!mask[key]) continue;
+          newShape[key] = currDef.shape[key]!;
+        }
+
+        assignProp(this, "shape", newShape); // self-caching
+        return newShape;
+      },
+    },
+    checks: {
+      value: [],
+    },
+  });
 
-  return clone(schema, {
-    ...schema._zod.def,
-    shape: newShape,
-    checks: [],
-  }) as any;
+  return clone(schema, def) as any;
 }
 
 export function omit(schema: schemas.$ZodObject, mask: object): any {
-  const newShape: Writeable<schemas.$ZodShape> = { ...schema._zod.def.shape };
-  const currDef = schema._zod.def; //.shape;
-  for (const key in mask) {
-    if (!(key in currDef.shape)) {
-      throw new Error(`Unrecognized key: "${key}"`);
-    }
-    if (!(mask as any)[key]) continue;
-
-    delete newShape[key];
-  }
-  return clone(schema, {
-    ...schema._zod.def,
-    shape: newShape,
-    checks: [],
+  const currDef = schema._zod.def;
+
+  const def = cloneDef(schema);
+  Object.defineProperties(def, {
+    shape: {
+      get() {
+        const newShape: Writeable<schemas.$ZodShape> = { ...schema._zod.def.shape };
+        for (const key in mask) {
+          if (!(key in currDef.shape)) {
+            throw new Error(`Unrecognized key: "${key}"`);
+          }
+          if (!(mask as any)[key]) continue;
+
+          delete newShape[key];
+        }
+        assignProp(this, "shape", newShape); // self-caching
+        return newShape;
+      },
+    },
+    checks: {
+      value: [],
+    },
   });
+
+  return clone(schema, def);
 }
 
 export function extend(schema: schemas.$ZodObject, shape: schemas.$ZodShape): any {
   if (!isPlainObject(shape)) {
     throw new Error("Invalid input to extend: expected a plain object");
   }
-  const def = {
-    ...schema._zod.def,
-    get shape() {
-      const _shape = { ...schema._zod.def.shape, ...shape };
-      assignProp(this, "shape", _shape); // self-caching
-      return _shape;
+
+  const def = cloneDef(schema);
+  Object.defineProperties(def, {
+    shape: {
+      get() {
+        const _shape = { ...schema._zod.def.shape, ...shape };
+        assignProp(this, "shape", _shape); // self-caching
+        return _shape;
+      },
+    },
+    checks: {
+      value: [],
     },
-    checks: [], // delete existing checks
-  } as any;
+  });
   return clone(schema, def) as any;
 }
 
 export function merge(a: schemas.$ZodObject, b: schemas.$ZodObject): any {
-  return clone(a, {
-    ...a._zod.def,
-    get shape() {
-      const _shape = { ...a._zod.def.shape, ...b._zod.def.shape };
-      assignProp(this, "shape", _shape); // self-caching
-      return _shape;
+  const def = cloneDef(a);
+  Object.defineProperties(def, {
+    shape: {
+      get() {
+        const _shape = { ...a._zod.def.shape, ...b._zod.def.shape };
+        assignProp(this, "shape", _shape); // self-caching
+        return _shape;
+      },
+    },
+    catchall: {
+      get() {
+        return b._zod.def.catchall;
+      },
+    },
+    checks: {
+      value: [], // delete existing checks
     },
-    catchall: b._zod.def.catchall,
-    checks: [], // delete existing checks
-  }) as any;
+  });
+
+  return clone(a, def) as any;
 }
 
 export function partial(
@@ -607,40 +647,49 @@ export function partial(
   schema: schemas.$ZodObject,
   mask: object | undefined
 ): any {
-  const oldShape = schema._zod.def.shape;
-  const shape: Writeable<schemas.$ZodShape> = { ...oldShape };
-
-  if (mask) {
-    for (const key in mask) {
-      if (!(key in oldShape)) {
-        throw new Error(`Unrecognized key: "${key}"`);
-      }
-      if (!(mask as any)[key]) continue;
-      // if (oldShape[key]!._zod.optin === "optional") continue;
-      shape[key] = Class
-        ? new Class({
-            type: "optional",
-            innerType: oldShape[key]!,
-          })
-        : oldShape[key]!;
-    }
-  } else {
-    for (const key in oldShape) {
-      // if (oldShape[key]!._zod.optin === "optional") continue;
-      shape[key] = Class
-        ? new Class({
-            type: "optional",
-            innerType: oldShape[key]!,
-          })
-        : oldShape[key]!;
-    }
-  }
+  const def = cloneDef(schema);
+  Object.defineProperties(def, {
+    shape: {
+      get() {
+        const oldShape = schema._zod.def.shape;
+        const shape: Writeable<schemas.$ZodShape> = { ...oldShape };
+
+        if (mask) {
+          for (const key in mask) {
+            if (!(key in oldShape)) {
+              throw new Error(`Unrecognized key: "${key}"`);
+            }
+            if (!(mask as any)[key]) continue;
+            // if (oldShape[key]!._zod.optin === "optional") continue;
+            shape[key] = Class
+              ? new Class({
+                  type: "optional",
+                  innerType: oldShape[key]!,
+                })
+              : oldShape[key]!;
+          }
+        } else {
+          for (const key in oldShape) {
+            // if (oldShape[key]!._zod.optin === "optional") continue;
+            shape[key] = Class
+              ? new Class({
+                  type: "optional",
+                  innerType: oldShape[key]!,
+                })
+              : oldShape[key]!;
+          }
+        }
+
+        assignProp(this, "shape", shape); // self-caching
+        return shape;
+      },
+    },
+    checks: {
+      value: [],
+    },
+  });
 
-  return clone(schema, {
-    ...schema._zod.def,
-    shape,
-    checks: [],
-  }) as any;
+  return clone(schema, def) as any;
 }
 
 export function required(
@@ -648,44 +697,54 @@ export function required(
   schema: schemas.$ZodObject,
   mask: object | undefined
 ): any {
-  const oldShape = schema._zod.def.shape;
-  const shape: Writeable<schemas.$ZodShape> = { ...oldShape };
-
-  if (mask) {
-    for (const key in mask) {
-      if (!(key in shape)) {
-        throw new Error(`Unrecognized key: "${key}"`);
-      }
-      if (!(mask as any)[key]) continue;
-      // overwrite with non-optional
-      shape[key] = new Class({
-        type: "nonoptional",
-        innerType: oldShape[key]!,
-      });
-    }
-  } else {
-    for (const key in oldShape) {
-      // overwrite with non-optional
-      shape[key] = new Class({
-        type: "nonoptional",
-        innerType: oldShape[key]!,
-      });
-    }
-  }
+  const def = cloneDef(schema);
+  Object.defineProperties(def, {
+    shape: {
+      get() {
+        const oldShape = schema._zod.def.shape;
+        const shape: Writeable<schemas.$ZodShape> = { ...oldShape };
+
+        if (mask) {
+          for (const key in mask) {
+            if (!(key in shape)) {
+              throw new Error(`Unrecognized key: "${key}"`);
+            }
+            if (!(mask as any)[key]) continue;
+            // overwrite with non-optional
+            shape[key] = new Class({
+              type: "nonoptional",
+              innerType: oldShape[key]!,
+            });
+          }
+        } else {
+          for (const key in oldShape) {
+            // overwrite with non-optional
+            shape[key] = new Class({
+              type: "nonoptional",
+              innerType: oldShape[key]!,
+            });
+          }
+        }
+
+        assignProp(this, "shape", shape); // self-caching
+        return shape;
+      },
+    },
+    checks: {
+      value: [],
+    },
+  });
 
-  return clone(schema, {
-    ...schema._zod.def,
-    shape,
-    // optional: [],
-    checks: [],
-  }) as any;
+  return clone(schema, def) as any;
 }
 
 export type Constructor<T, Def extends any[] = any[]> = new (...args: Def) => T;
 
 export function aborted(x: schemas.ParsePayload, startIndex = 0): boolean {
   for (let i = startIndex; i < x.issues.length; i++) {
-    if (x.issues[i]?.continue !== true) return true;
+    if (x.issues[i]?.continue !== true) {
+      return true;
+    }
   }
   return false;
 }
@@ -733,6 +792,7 @@ export function finalizeIssue(
 export function getSizableOrigin(input: any): "set" | "map" | "file" | "unknown" {
   if (input instanceof Set) return "set";
   if (input instanceof Map) return "map";
+  // @ts-ignore
   if (input instanceof File) return "file";
   return "unknown";
 }

package/src/v4/core/versions.ts

@@ -1,5 +1,5 @@
 export const version = {
   major: 4,
   minor: 0,
-  patch: 5 as number,
+  patch: 6 as number,
 } as const;

package/src/v4/locales/bg.ts

@@ -0,0 +1,136 @@
+import type { $ZodStringFormats } from "../core/checks.js";
+import type * as errors from "../core/errors.js";
+import * as util from "../core/util.js";
+
+export const parsedType = (data: any): string => {
+  const t = typeof data;
+
+  switch (t) {
+    case "number": {
+      return Number.isNaN(data) ? "NaN" : "число";
+    }
+    case "object": {
+      if (Array.isArray(data)) {
+        return "масив";
+      }
+      if (data === null) {
+        return "null";
+      }
+
+      if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
+        return data.constructor.name;
+      }
+    }
+  }
+  return t;
+};
+
+const error: () => errors.$ZodErrorMap = () => {
+  const Sizable: Record<string, { unit: string; verb: string }> = {
+    string: { unit: "символа", verb: "да съдържа" },
+    file: { unit: "байта", verb: "да съдържа" },
+    array: { unit: "елемента", verb: "да съдържа" },
+    set: { unit: "елемента", verb: "да съдържа" },
+  };
+
+  function getSizing(origin: string): { unit: string; verb: string } | null {
+    return Sizable[origin] ?? null;
+  }
+
+  const Nouns: {
+    [k in $ZodStringFormats | (string & {})]?: string;
+  } = {
+    regex: "вход",
+    email: "имейл адрес",
+    url: "URL",
+    emoji: "емоджи",
+    uuid: "UUID",
+    uuidv4: "UUIDv4",
+    uuidv6: "UUIDv6",
+    nanoid: "nanoid",
+    guid: "GUID",
+    cuid: "cuid",
+    cuid2: "cuid2",
+    ulid: "ULID",
+    xid: "XID",
+    ksuid: "KSUID",
+    datetime: "ISO време",
+    date: "ISO дата",
+    time: "ISO време",
+    duration: "ISO продължителност",
+    ipv4: "IPv4 адрес",
+    ipv6: "IPv6 адрес",
+    cidrv4: "IPv4 диапазон",
+    cidrv6: "IPv6 диапазон",
+    base64: "base64-кодиран низ",
+    base64url: "base64url-кодиран низ",
+    json_string: "JSON низ",
+    e164: "E.164 номер",
+    jwt: "JWT",
+    template_literal: "вход",
+  };
+
+  return (issue) => {
+    switch (issue.code) {
+      case "invalid_type":
+        return `Невалиден вход: очакван ${issue.expected}, получен ${parsedType(issue.input)}`;
+
+      case "invalid_value":
+        if (issue.values.length === 1) return `Невалиден вход: очакван ${util.stringifyPrimitive(issue.values[0])}`;
+        return `Невалидна опция: очаквано едно от ${util.joinValues(issue.values, "|")}`;
+      case "too_big": {
+        const adj = issue.inclusive ? "<=" : "<";
+        const sizing = getSizing(issue.origin);
+        if (sizing)
+          return `Твърде голямо: очаква се ${issue.origin ?? "стойност"} да съдържа ${adj}${issue.maximum.toString()} ${sizing.unit ?? "елемента"}`;
+        return `Твърде голямо: очаква се ${issue.origin ?? "стойност"} да бъде ${adj}${issue.maximum.toString()}`;
+      }
+      case "too_small": {
+        const adj = issue.inclusive ? ">=" : ">";
+        const sizing = getSizing(issue.origin);
+        if (sizing) {
+          return `Твърде малко: очаква се ${issue.origin} да съдържа ${adj}${issue.minimum.toString()} ${sizing.unit}`;
+        }
+
+        return `Твърде малко: очаква се ${issue.origin} да бъде ${adj}${issue.minimum.toString()}`;
+      }
+      case "invalid_format": {
+        const _issue = issue as errors.$ZodStringFormatIssues;
+        if (_issue.format === "starts_with") {
+          return `Невалиден низ: трябва да започва с "${_issue.prefix}"`;
+        }
+        if (_issue.format === "ends_with") return `Невалиден низ: трябва да завършва с "${_issue.suffix}"`;
+        if (_issue.format === "includes") return `Невалиден низ: трябва да включва "${_issue.includes}"`;
+        if (_issue.format === "regex") return `Невалиден низ: трябва да съвпада с ${_issue.pattern}`;
+
+        let invalid_adj = "Невалиден";
+
+        if (_issue.format === "emoji") invalid_adj = "Невалидно";
+        if (_issue.format === "datetime") invalid_adj = "Невалидно";
+        if (_issue.format === "date") invalid_adj = "Невалидна";
+        if (_issue.format === "time") invalid_adj = "Невалидно";
+        if (_issue.format === "duration") invalid_adj = "Невалидна";
+
+        return `${invalid_adj} ${Nouns[_issue.format] ?? issue.format}`;
+      }
+      case "not_multiple_of":
+        return `Невалидно число: трябва да бъде кратно на ${issue.divisor}`;
+      case "unrecognized_keys":
+        return `Неразпознат${issue.keys.length > 1 ? "и" : ""} ключ${issue.keys.length > 1 ? "ове" : ""}: ${util.joinValues(issue.keys, ", ")}`;
+      case "invalid_key":
+        return `Невалиден ключ в ${issue.origin}`;
+      case "invalid_union":
+        return "Невалиден вход";
+      case "invalid_element":
+        return `Невалидна стойност в ${issue.origin}`;
+      default:
+        return `Невалиден вход`;
+    }
+  };
+};
+
+export default function (): { localeError: errors.$ZodErrorMap } {
+  return {
+    localeError: error(),
+  };
+}

package/src/v4/locales/da.ts

@@ -0,0 +1,141 @@
+import type { $ZodStringFormats } from "../core/checks.js";
+import type * as errors from "../core/errors.js";
+import * as util from "../core/util.js";
+
+const error: () => errors.$ZodErrorMap = () => {
+  const Sizable: Record<string, { unit: string; verb: string }> = {
+    string: { unit: "tegn", verb: "havde" },
+    file: { unit: "bytes", verb: "havde" },
+    array: { unit: "elementer", verb: "indeholdt" },
+    set: { unit: "elementer", verb: "indeholdt" },
+  };
+
+  const TypeNames: Record<string, string> = {
+    string: "streng",
+    number: "tal",
+    boolean: "boolean",
+    array: "liste",
+    object: "objekt",
+    set: "sæt",
+    file: "fil",
+  };
+
+  function getSizing(origin: string): { unit: string; verb: string } | null {
+    return Sizable[origin] ?? null;
+  }
+
+  function getTypeName(type: string): string {
+    return TypeNames[type] ?? type;
+  }
+
+  const parsedType = (data: any): string => {
+    const t = typeof data;
+
+    switch (t) {
+      case "number": {
+        return Number.isNaN(data) ? "NaN" : "tal";
+      }
+      case "object": {
+        if (Array.isArray(data)) {
+          return "liste";
+        }
+        if (data === null) {
+          return "null";
+        }
+
+        if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
+          return data.constructor.name;
+        }
+        return "objekt";
+      }
+    }
+    return t;
+  };
+
+  const Nouns: {
+    [k in $ZodStringFormats | (string & {})]?: string;
+  } = {
+    regex: "input",
+    email: "e-mailadresse",
+    url: "URL",
+    emoji: "emoji",
+    uuid: "UUID",
+    uuidv4: "UUIDv4",
+    uuidv6: "UUIDv6",
+    nanoid: "nanoid",
+    guid: "GUID",
+    cuid: "cuid",
+    cuid2: "cuid2",
+    ulid: "ULID",
+    xid: "XID",
+    ksuid: "KSUID",
+    datetime: "ISO dato- og klokkeslæt",
+    date: "ISO-dato",
+    time: "ISO-klokkeslæt",
+    duration: "ISO-varighed",
+    ipv4: "IPv4-område",
+    ipv6: "IPv6-område",
+    cidrv4: "IPv4-spektrum",
+    cidrv6: "IPv6-spektrum",
+    base64: "base64-kodet streng",
+    base64url: "base64url-kodet streng",
+    json_string: "JSON-streng",
+    e164: "E.164-nummer",
+    jwt: "JWT",
+    template_literal: "input",
+  };
+
+  return (issue) => {
+    switch (issue.code) {
+      case "invalid_type":
+        return `Ugyldigt input: forventede ${getTypeName(issue.expected)}, fik ${getTypeName(parsedType(issue.input))}`;
+      case "invalid_value":
+        if (issue.values.length === 1) return `Ugyldig værdi: forventede ${util.stringifyPrimitive(issue.values[0])}`;
+        return `Ugyldigt valg: forventede en af følgende ${util.joinValues(issue.values, "|")}`;
+      case "too_big": {
+        const adj = issue.inclusive ? "<=" : "<";
+        const sizing = getSizing(issue.origin);
+        const origin = getTypeName(issue.origin);
+        if (sizing)
+          return `For stor: forventede ${origin ?? "value"} ${sizing.verb} ${adj} ${issue.maximum.toString()} ${sizing.unit ?? "elementer"}`;
+        return `For stor: forventede ${origin ?? "value"} havde ${adj} ${issue.maximum.toString()}`;
+      }
+      case "too_small": {
+        const adj = issue.inclusive ? ">=" : ">";
+        const sizing = getSizing(issue.origin);
+        const origin = getTypeName(issue.origin);
+        if (sizing) {
+          return `For lille: forventede ${origin} ${sizing.verb} ${adj} ${issue.minimum.toString()} ${sizing.unit}`;
+        }
+
+        return `For lille: forventede ${origin} havde ${adj} ${issue.minimum.toString()}`;
+      }
+      case "invalid_format": {
+        const _issue = issue as errors.$ZodStringFormatIssues;
+        if (_issue.format === "starts_with") return `Ugyldig streng: skal starte med "${_issue.prefix}"`;
+        if (_issue.format === "ends_with") return `Ugyldig streng: skal ende med "${_issue.suffix}"`;
+        if (_issue.format === "includes") return `Ugyldig streng: skal indeholde "${_issue.includes}"`;
+        if (_issue.format === "regex") return `Ugyldig streng: skal matche mønsteret ${_issue.pattern}`;
+        return `Ugyldig ${Nouns[_issue.format] ?? issue.format}`;
+      }
+      case "not_multiple_of":
+        return `Ugyldigt tal: skal være deleligt med ${issue.divisor}`;
+      case "unrecognized_keys":
+        return `${issue.keys.length > 1 ? "Ukendte nøgler" : "Ukendt nøgle"}: ${util.joinValues(issue.keys, ", ")}`;
+      case "invalid_key":
+        return `Ugyldig nøgle i ${issue.origin}`;
+      case "invalid_union":
+        return "Ugyldigt input: matcher ingen af de tilladte typer";
+      case "invalid_element":
+        return `Ugyldig værdi i ${issue.origin}`;
+      default:
+        return `Ugyldigt input`;
+    }
+  };
+};
+
+export default function (): { localeError: errors.$ZodErrorMap } {
+  return {
+    localeError: error(),
+  };
+}

package/src/v4/locales/index.ts

@@ -3,6 +3,7 @@ export { default as az } from "./az.js";
 export { default as be } from "./be.js";
 export { default as ca } from "./ca.js";
 export { default as cs } from "./cs.js";
+export { default as da } from "./da.js";
 export { default as de } from "./de.js";
 export { default as en } from "./en.js";
 export { default as eo } from "./eo.js";
@@ -14,6 +15,7 @@ export { default as frCA } from "./fr-CA.js";
 export { default as he } from "./he.js";
 export { default as hu } from "./hu.js";
 export { default as id } from "./id.js";
+export { default as is } from "./is.js";
 export { default as it } from "./it.js";
 export { default as ja } from "./ja.js";
 export { default as kh } from "./kh.js";