zod 4.0.0-beta.1 → 4.0.0-beta.20250409T222615

package/package.json

@@ -1,34 +1,15 @@
 {
   "name": "zod",
-  "version": "4.0.0-beta.1",
+  "version": "4.0.0-beta.20250409T222615",
+  "type": "module",
+  "author": "Colin McDonnell <zod@colinhacks.com>",
   "description": "TypeScript-first schema declaration and validation library with static type inference",
-  "main": "./lib/index.js",
-  "types": "./lib/index.d.ts",
-  "module": "./lib/index.mjs",
-  "exports": {
-    "require": "./lib/index.js",
-    "import": "./lib/index.mjs"
-  },
   "files": [
-    "/lib"
+    "src",
+    "dist"
   ],
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/colinhacks/zod"
-  },
-  "author": "Colin McDonnell <colin@colinhacks.com>",
-  "license": "MIT",
-  "sideEffects": false,
-  "bugs": {
-    "url": "https://github.com/colinhacks/zod/issues"
-  },
-  "homepage": "https://github.com/colinhacks/zod",
   "funding": "https://github.com/sponsors/colinhacks",
-  "support": {
-    "backing": {
-      "npm-funding": true
-    }
-  },
+  "homepage": "https://zod.dev",
   "keywords": [
     "typescript",
     "schema",
@@ -36,65 +17,68 @@
     "type",
     "inference"
   ],
-  "scripts": {
-    "check:format": "prettier --check \"src/**/*.ts\" \"deno/lib/**/*.ts\"",
-    "fix:format": "prettier --write \"src/**/*.ts\" \"deno/lib/**/*.ts\"",
-    "check:lint": "eslint --ext .ts ./src",
-    "fix:lint": "eslint --fix --ext .ts ./src",
-    "check": "yarn check:lint && yarn check:format",
-    "fix": "yarn fix:lint && yarn fix:format",
-    "clean": "rm -rf lib/* deno/lib/*",
-    "build": "yarn run clean && npm run build:cjs && npm run build:esm && npm run build:deno",
-    "build:deno": "node ./deno/build.mjs",
-    "build:esm": "rollup --config rollup.config.js",
-    "build:cjs": "tsc --p tsconfig.cjs.json",
-    "build:types": "tsc --p tsconfig.types.json",
-    "rollup": "rollup --config rollup.config.js",
-    "test": "node --trace-warnings node_modules/.bin/jest --coverage && yarn run badge",
-    "testone": "jest",
-    "badge": "make-coverage-badge --output-path ./coverage.svg",
-    "prepublishOnly": "npm run test && npm run build && npm run build:deno",
-    "play": "nodemon -e ts -w . -x ts-node src/playground.ts --project tsconfig.json --trace-warnings",
-    "depcruise": "depcruise -c .dependency-cruiser.js src",
-    "benchmark": "ts-node src/benchmarks/index.ts"
+  "license": "MIT",
+  "sideEffects": false,
+  "main": "./dist/commonjs/index.js",
+  "module": "./dist/esm/index.js",
+  "types": "./dist/commonjs/index.d.ts",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "import": {
+        "@zod/source": "./src/index.ts",
+        "types": "./dist/esm/index.d.ts",
+        "default": "./dist/esm/index.js"
+      },
+      "require": {
+        "types": "./dist/commonjs/index.d.ts",
+        "default": "./dist/commonjs/index.js"
+      }
+    },
+    "./locales/*": {
+      "import": {
+        "@zod/source": "./src/locales/*",
+        "types": "./dist/esm/locales/*",
+        "default": "./dist/esm/locales/*"
+      },
+      "require": {
+        "types": "./dist/commonjs/locales/*",
+        "default": "./dist/commonjs/locales/*"
+      }
+    }
+  },
+  "tshy": {
+    "exports": {
+      "./package.json": "./package.json",
+      ".": "./src/index.ts",
+      "./locales/*": "./src/locales/*"
+    },
+    "sourceDialects": [
+      "@zod/source"
+    ]
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/colinhacks/zod.git"
   },
-  "devDependencies": {
-    "@rollup/plugin-typescript": "^8.2.0",
-    "@types/benchmark": "^2.1.0",
-    "@types/jest": "^26.0.17",
-    "@types/node": "^14.14.10",
-    "@typescript-eslint/eslint-plugin": "^4.11.1",
-    "@typescript-eslint/parser": "^4.11.1",
-    "benchmark": "^2.1.4",
-    "dependency-cruiser": "^9.19.0",
-    "eslint": "^7.15.0",
-    "eslint-config-prettier": "^7.1.0",
-    "eslint-plugin-import": "^2.22.1",
-    "eslint-plugin-simple-import-sort": "^7.0.0",
-    "eslint-plugin-unused-imports": "^1.1.0",
-    "husky": "^4.3.4",
-    "jest": "^26.6.3",
-    "lint-staged": "^10.5.3",
-    "make-coverage-badge": "^1.2.0",
-    "nodemon": "^2.0.2",
-    "prettier": "^2.2.1",
-    "rollup": "^2.42.1",
-    "ts-jest": "^26.4.4",
-    "ts-node": "^9.1.0",
-    "tslib": "^2.1.0",
-    "typescript": "^4.3.2"
+  "bugs": {
+    "url": "https://github.com/colinhacks/zod/issues"
   },
-  "husky": {
-    "hooks": {
-      "pre-commit": "lint-staged && yarn build:deno && git add .",
-      "pre-push": "lint-staged && yarn build && yarn test"
+  "support": {
+    "backing": {
+      "npm-funding": true
     }
   },
-  "lint-staged": {
-    "*.ts": [
-      "yarn fix:lint",
-      "yarn fix:format"
-    ]
+  "dependencies": {
+    "@zod/core": "0.1.2"
   },
-  "dependencies": {}
-}
+  "scripts": {
+    "clean": "rm -rf dist",
+    "build": "tshy",
+    "postbuild": "pnpm biome check --write .",
+    "test:watch": "pnpm vitest",
+    "test": "pnpm vitest run",
+    "bump:beta": "pnpm version v4.0.0-beta.$(date +%Y%m%dT%H%M%S)",
+    "pub:beta": "pnpm bump:beta && pnpm publish --tag next --publish-branch v4 --no-git-checks"
+  }
+}

package/src/checks.ts

@@ -0,0 +1,30 @@
+export {
+  _lt as lt,
+  _lte as lte,
+  _gt as gt,
+  _gte as gte,
+  _positive as positive,
+  _negative as negative,
+  _nonpositive as nonpositive,
+  _nonnegative as nonnegative,
+  _multipleOf as multipleOf,
+  _maxSize as maxSize,
+  _minSize as minSize,
+  _size as size,
+  _maxLength as maxLength,
+  _minLength as minLength,
+  _length as length,
+  _regex as regex,
+  _lowercase as lowercase,
+  _uppercase as uppercase,
+  _includes as includes,
+  _startsWith as startsWith,
+  _endsWith as endsWith,
+  _property as property,
+  _mime as mime,
+  _overwrite as overwrite,
+  _normalize as normalize,
+  _trim as trim,
+  _toLowerCase as toLowerCase,
+  _toUpperCase as toUpperCase,
+} from "@zod/core";

package/src/coerce.ts

@@ -0,0 +1,27 @@
+import * as core from "@zod/core";
+import * as schemas from "./schemas.js";
+
+export interface ZodCoercedString extends schemas._ZodString<unknown> {}
+export function string(params?: string | core.$ZodStringParams): ZodCoercedString {
+  return core._coercedString(schemas.ZodString, params);
+}
+
+export interface ZodCoercedNumber extends schemas._ZodNumber<unknown> {}
+export function number(params?: string | core.$ZodNumberParams): ZodCoercedNumber {
+  return core._coercedNumber(schemas.ZodNumber, params);
+}
+
+export interface ZodCoercedBoolean extends schemas._ZodBoolean<unknown> {}
+export function boolean(params?: string | core.$ZodBooleanParams): ZodCoercedBoolean {
+  return core._coercedBoolean(schemas.ZodBoolean, params);
+}
+
+export interface ZodCoercedBigInt extends schemas._ZodBigInt<unknown> {}
+export function bigint(params?: string | core.$ZodBigIntParams): ZodCoercedBigInt {
+  return core._coercedBigint(schemas.ZodBigInt, params);
+}
+
+export interface ZodCoercedDate extends schemas._ZodDate<unknown> {}
+export function date(params?: string | core.$ZodDateParams): ZodCoercedDate {
+  return core._coercedDate(schemas.ZodDate, params);
+}

package/src/compat.ts

@@ -0,0 +1,74 @@
+// Zod 3 compat layer
+
+import * as core from "@zod/core";
+import type { ZodType } from "./schemas.js";
+
+export type {
+  /** @deprecated Use `z.output<T>` instead. */
+  output as TypeOf,
+  /** @deprecated Use `z.output<T>` instead. */
+  output as Infer,
+  /** @deprecated Use `z.core.$$ZodFirstPartyTypes` instead */
+  $ZodTypes as ZodFirstPartySchemaTypes,
+} from "@zod/core";
+
+/** @deprecated Use the raw string literal codes instead, e.g. "invalid_type". */
+export const ZodIssueCode = {
+  invalid_type: "invalid_type",
+  too_big: "too_big",
+  too_small: "too_small",
+  invalid_format: "invalid_format",
+  not_multiple_of: "not_multiple_of",
+  unrecognized_keys: "unrecognized_keys",
+  invalid_union: "invalid_union",
+  invalid_key: "invalid_key",
+  invalid_element: "invalid_element",
+  invalid_value: "invalid_value",
+  custom: "custom",
+} as const;
+
+/** @deprecated Not necessary in Zod 4. */
+type INVALID = { status: "aborted" };
+/** @deprecated Not necessary in Zod 4. */
+const INVALID: INVALID = Object.freeze({
+  status: "aborted",
+});
+
+/** A special constant with type `never` */
+export const NEVER = INVALID as never;
+
+/** @deprecated Use `z.$ZodFlattenedError` */
+export type inferFlattenedErrors<T extends core.$ZodType, U = string> = core.$ZodFlattenedError<core.output<T>, U>;
+
+/** @deprecated Use `z.$ZodFormattedError` */
+export type inferFormattedError<T extends core.$ZodType<any, any>, U = string> = core.$ZodFormattedError<
+  core.output<T>,
+  U
+>;
+
+/** Use `z.$brand` instead */
+export type BRAND<T extends string | number | symbol = string | number | symbol> = {
+  [core.$brand]: { [k in T]: true };
+};
+export { $brand, config } from "@zod/core";
+
+/** @deprecated Use `z.config(params)` instead. */
+export function setErrorMap(map: core.$ZodErrorMap): void {
+  core.config({
+    customError: map,
+  });
+}
+
+/** @deprecated Use `z.config()` instead. */
+export function getErrorMap(): core.$ZodErrorMap<core.$ZodIssue> | undefined {
+  return core.config().customError;
+}
+
+export type {
+  /** @deprecated Use z.ZodType (without generics) instead. */
+  ZodType as ZodTypeAny,
+  /** @deprecated Use `z.ZodType` */
+  ZodType as ZodSchema,
+  /** @deprecated Use `z.ZodType` */
+  ZodType as Schema,
+};

package/src/errors.ts

@@ -0,0 +1,52 @@
+import * as core from "@zod/core";
+import type { AnyFunc } from "@zod/core/util";
+
+/** @deprecated Use `z.core.$ZodIssue` from `@zod/core` instead, especially if you are building a library on top of Zod. */
+export type ZodIssue = core.$ZodIssue;
+
+export class ZodError<T = unknown> extends core.$ZodError<T> {
+  /** @deprecated Use the `z.treeifyError(err)` function instead. */
+  format(): core.$ZodFormattedError<T>;
+  /** @deprecated Use the `z.treeifyError(err)` function instead. */
+  format<U>(mapper: (issue: core.$ZodIssue) => U): core.$ZodFormattedError<T, U>;
+  format(mapper?: AnyFunc): any {
+    return core.formatError(this, mapper);
+  }
+
+  /** @deprecated Use the `z.treeifyError(err)` function instead. */
+  flatten(): core.$ZodFlattenedError<T>;
+  /** @deprecated Use the `z.treeifyError(err)` function instead. */
+  flatten<U>(mapper: (issue: core.$ZodIssue) => U): core.$ZodFlattenedError<T, U>;
+  flatten(mapper?: AnyFunc): core.$ZodFlattenedError<T> {
+    return core.flattenError(this, mapper);
+  }
+
+  /** @deprecated Push directly to `.issues` instead. */
+  addIssue(issue: core.$ZodIssue): void {
+    this.issues.push(issue);
+  }
+  /** @deprecated Push directly to `.issues` instead. */
+  addIssues(issues: core.$ZodIssue[]): void {
+    this.issues.push(...issues);
+  }
+
+  /** @deprecated Check `err.issues.length === 0` instead. */
+  get isEmpty(): boolean {
+    return this.issues.length === 0;
+  }
+}
+
+export type {
+  /** @deprecated Use `z.core.$ZodFlattenedError` instead. */
+  $ZodFlattenedError as ZodFlattenedError,
+  /** @deprecated Use `z.core.$ZodFormattedError` instead. */
+  $ZodFormattedError as ZodFormattedError,
+  /** @deprecated Use `z.core.$ZodErrorMap` instead. */
+  $ZodErrorMap as ZodErrorMap,
+} from "@zod/core";
+
+/** @deprecated Use `z.core.$ZodRawIssue` instead. */
+export type IssueData = core.$ZodRawIssue;
+
+// /** @deprecated Use `z.core.$ZodErrorMapCtx` instead. */
+// export type ErrorMapCtx = core.$ZodErrorMapCtx;

package/src/external.ts

@@ -0,0 +1,29 @@
+export * as core from "@zod/core";
+export * from "./schemas.js";
+export * from "./checks.js";
+export * from "./errors.js";
+export * from "./parse.js";
+export * from "./compat.js";
+
+// zod-specified
+import { config } from "@zod/core";
+import en from "@zod/core/locales/en.js";
+config(en());
+
+export type { infer, output, input } from "@zod/core";
+export {
+  globalRegistry,
+  registry,
+  config,
+  $output,
+  $input,
+  $brand,
+  function,
+  clone,
+  regexes,
+  // flattenError,
+  // formatError,
+  treeifyError,
+  prettifyError,
+  toJSONSchema,
+} from "@zod/core";

package/src/index.ts

@@ -0,0 +1,5 @@
+import * as z from "./external.js";
+
+export { z };
+export * from "./external.js";
+export default z;

package/src/iso.ts

@@ -0,0 +1,90 @@
+import * as core from "@zod/core";
+import * as schemas from "./schemas.js";
+
+//////////////////////////////////////////////
+//////////////////////////////////////////////
+//////////                          //////////
+//////////      ZodISODateTime      //////////
+//////////                          //////////
+//////////////////////////////////////////////
+//////////////////////////////////////////////
+
+export interface ZodISODateTime extends schemas.ZodStringFormat {
+  _zod: core.$ZodISODateTimeInternals;
+}
+export const ZodISODateTime: core.$constructor<ZodISODateTime> = /*@__PURE__*/ core.$constructor(
+  "ZodISODateTime",
+  (inst, def) => {
+    core.$ZodISODateTime.init(inst, def);
+    schemas.ZodStringFormat.init(inst, def);
+  }
+);
+
+export function datetime(params?: string | core.$ZodISODateTimeParams): ZodISODateTime {
+  return core._isoDateTime(ZodISODateTime, params);
+}
+
+//////////////////////////////////////////
+//////////////////////////////////////////
+//////////                      //////////
+//////////      ZodISODate      //////////
+//////////                      //////////
+//////////////////////////////////////////
+//////////////////////////////////////////
+
+export interface ZodISODate extends schemas.ZodStringFormat {
+  _zod: core.$ZodISODateInternals;
+}
+export const ZodISODate: core.$constructor<ZodISODate> = /*@__PURE__*/ core.$constructor("ZodISODate", (inst, def) => {
+  core.$ZodISODate.init(inst, def);
+  schemas.ZodStringFormat.init(inst, def);
+});
+
+export function date(params?: string | core.$ZodISODateParams): ZodISODate {
+  return core._isoDate(ZodISODate, params);
+}
+
+// ZodISOTime
+
+//////////////////////////////////////////
+//////////////////////////////////////////
+//////////                      //////////
+//////////      ZodISOTime      //////////
+//////////                      //////////
+//////////////////////////////////////////
+//////////////////////////////////////////
+
+export interface ZodISOTime extends schemas.ZodStringFormat {
+  _zod: core.$ZodISOTimeInternals;
+}
+export const ZodISOTime: core.$constructor<ZodISOTime> = /*@__PURE__*/ core.$constructor("ZodISOTime", (inst, def) => {
+  core.$ZodISOTime.init(inst, def);
+  schemas.ZodStringFormat.init(inst, def);
+});
+
+export function time(params?: string | core.$ZodISOTimeParams): ZodISOTime {
+  return core._isoTime(ZodISOTime, params);
+}
+
+//////////////////////////////////////////////
+//////////////////////////////////////////////
+//////////                          //////////
+//////////      ZodISODuration      //////////
+//////////                          //////////
+//////////////////////////////////////////////
+//////////////////////////////////////////////
+
+export interface ZodISODuration extends schemas.ZodStringFormat {
+  _zod: core.$ZodISODurationInternals;
+}
+export const ZodISODuration: core.$constructor<ZodISODuration> = /*@__PURE__*/ core.$constructor(
+  "ZodISODuration",
+  (inst, def) => {
+    core.$ZodISODuration.init(inst, def);
+    schemas.ZodStringFormat.init(inst, def);
+  }
+);
+
+export function duration(params?: string | core.$ZodISODurationParams): ZodISODuration {
+  return core._isoDuration(ZodISODuration, params);
+}

package/src/parse.ts

@@ -0,0 +1,32 @@
+import * as core from "@zod/core";
+import { ZodError } from "./errors.js";
+
+export type ZodSafeParseResult<T> = ZodSafeParseSuccess<T> | ZodSafeParseError<T>;
+export type ZodSafeParseSuccess<T> = { success: true; data: T; error?: never };
+export type ZodSafeParseError<T> = { success: false; data?: never; error: ZodError<T> };
+
+export const parse: <T extends core.$ZodType>(
+  schema: T,
+  value: unknown,
+  _ctx?: core.ParseContext<core.$ZodIssue>
+) => core.output<T> = /* @__PURE__ */ core._parse.bind({ Error: ZodError }) as any;
+
+export const safeParse: <T extends core.$ZodType>(
+  schema: T,
+  value: unknown,
+  _ctx?: core.ParseContext<core.$ZodIssue>
+) => ZodSafeParseResult<core.output<T>> = /* @__PURE__ */ core._safeParse.bind({ Error: ZodError }) as any;
+
+export const parseAsync: <T extends core.$ZodType>(
+  schema: T,
+  value: unknown,
+  _ctx?: core.ParseContext<core.$ZodIssue>
+) => Promise<core.output<T>> = /* @__PURE__ */ core._parseAsync.bind({ Error: ZodError }) as any;
+
+export const safeParseAsync: <T extends core.$ZodType>(
+  schema: T,
+  value: unknown,
+  _ctx?: core.ParseContext<core.$ZodIssue>
+) => Promise<ZodSafeParseResult<core.output<T>>> = /* @__PURE__ */ core._safeParseAsync.bind({
+  Error: ZodError,
+}) as any;