zod 3.25.0-canary.20241210T225910 → 4.0.0-beta.0

package/package.json

@@ -1,68 +1,12 @@
 {
   "name": "zod",
-  "version": "3.25.0-canary.20241210T225910",
-  "author": "Colin McDonnell <colin@colinhacks.com>",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/colinhacks/zod.git"
-  },
-  "main": "./lib/index.js",
-  "module": "./lib/index.mjs",
-  "devDependencies": {
-    "@babel/core": "^7.22.5",
-    "@babel/preset-env": "^7.22.5",
-    "@babel/preset-typescript": "^7.22.5",
-    "@jest/globals": "^29.4.3",
-    "@rollup/plugin-typescript": "^8.2.0",
-    "@standard-schema/spec": "^1.0.0-beta.4",
-    "@swc/core": "^1.3.66",
-    "@swc/jest": "^0.2.26",
-    "@types/benchmark": "^2.1.0",
-    "@types/jest": "^29.2.2",
-    "@types/node": "14",
-    "@typescript-eslint/eslint-plugin": "^5.15.0",
-    "@typescript-eslint/parser": "^5.15.0",
-    "babel-jest": "^29.5.0",
-    "benchmark": "^2.1.4",
-    "dependency-cruiser": "^9.19.0",
-    "eslint": "^8.11.0",
-    "eslint-config-prettier": "^8.5.0",
-    "eslint-plugin-ban": "^1.6.0",
-    "eslint-plugin-import": "^2.25.4",
-    "eslint-plugin-simple-import-sort": "^7.0.0",
-    "eslint-plugin-unused-imports": "^2.0.0",
-    "husky": "^7.0.4",
-    "jest": "^29.3.1",
-    "lint-staged": "^12.3.7",
-    "netlify-cli": "^17.26.2",
-    "nodemon": "^2.0.15",
-    "prettier": "^2.6.0",
-    "pretty-quick": "^3.1.3",
-    "rollup": "^2.70.1",
-    "ts-jest": "^29.1.0",
-    "ts-morph": "^14.0.0",
-    "ts-node": "^10.9.1",
-    "tslib": "^2.3.1",
-    "tsx": "^3.8.0",
-    "typescript": "^5.0.0",
-    "vitest": "^0.32.2"
-  },
-  "exports": {
-    ".": {
-      "types": "./index.d.ts",
-      "require": "./lib/index.js",
-      "import": "./lib/index.mjs"
-    },
-    "./package.json": "./package.json",
-    "./locales/*": "./lib/locales/*"
-  },
-  "bugs": {
-    "url": "https://github.com/colinhacks/zod/issues"
-  },
+  "version": "4.0.0-beta.0",
+  "type": "module",
+  "author": "Colin McDonnell <zod@colinhacks.com>",
   "description": "TypeScript-first schema declaration and validation library with static type inference",
   "files": [
-    "/lib",
-    "/index.d.ts"
+    "src",
+    "dist"
   ],
   "funding": "https://github.com/sponsors/colinhacks",
   "homepage": "https://zod.dev",
@@ -74,49 +18,65 @@
     "inference"
   ],
   "license": "MIT",
-  "lint-staged": {
-    "src/*.ts": [
-      "eslint --cache --fix",
-      "prettier --ignore-unknown --write"
-    ],
-    "*.md": [
-      "prettier --ignore-unknown --write"
+  "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"
     ]
   },
-  "scripts": {
-    "prettier:check": "prettier --check src/**/*.ts deno/lib/**/*.ts *.md --no-error-on-unmatched-pattern",
-    "prettier:fix": "prettier --write src/**/*.ts deno/lib/**/*.ts *.md --ignore-unknown --no-error-on-unmatched-pattern",
-    "lint:check": "eslint --cache --ext .ts ./src",
-    "lint:fix": "eslint --cache --fix --ext .ts ./src",
-    "check": "yarn lint:check && yarn prettier:check",
-    "fix": "yarn lint:fix && yarn prettier:fix",
-    "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 && cp ./README.md ./deno/lib",
-    "build:esm": "rollup --config ./configs/rollup.config.js",
-    "build:cjs": "tsc -p ./configs/tsconfig.cjs.json",
-    "build:types": "tsc -p ./configs/tsconfig.types.json",
-    "build:test": "tsc -p ./configs/tsconfig.test.json",
-    "test:watch": "yarn test:ts-jest --watch",
-    "test": "yarn test:ts-jest",
-    "test:babel": "jest --coverage --config ./configs/babel-jest.config.json",
-    "test:bun": "bun test src/",
-    "test:vitest": "npx vitest --config ./configs/vitest.config.ts",
-    "test:ts-jest": "npx jest --config ./configs/ts-jest.config.json",
-    "test:swc": "npx jest --config ./configs/swc-jest.config.json",
-    "test:deno": "cd deno && deno test",
-    "prepublishOnly": "npm run test && npm run build && npm run build:deno",
-    "play": "nodemon -e ts -w . -x tsx playground.ts",
-    "depcruise": "depcruise -c .dependency-cruiser.js src",
-    "benchmark": "tsx src/benchmarks/index.ts",
-    "prepare": "husky install",
-    "docs": "netlify dev"
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/colinhacks/zod.git"
+  },
+  "bugs": {
+    "url": "https://github.com/colinhacks/zod/issues"
   },
-  "sideEffects": false,
   "support": {
     "backing": {
       "npm-funding": true
     }
   },
-  "types": "./index.d.ts"
-}
+  "dependencies": {
+    "@zod/core": "0.1.0"
+  },
+  "scripts": {
+    "clean": "rm -rf dist",
+    "build": "tshy",
+    "postbuild": "pnpm biome check --write .",
+    "test:watch": "pnpm vitest",
+    "test": "pnpm vitest run"
+  }
+}

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,47 @@
+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.formatError(err)` function instead. */
+  format(): core.$ZodFormattedError<T>;
+  format<U>(mapper: (issue: core.$ZodIssue) => U): core.$ZodFormattedError<T, U>;
+  format(mapper?: AnyFunc): any {
+    return core.formatError(this, mapper);
+  }
+
+  /** @deprecated Use the `z.flattenError(err)` function instead. */
+  flatten(): core.$ZodFlattenedError<T>;
+  flatten<U>(mapper: (issue: core.$ZodIssue) => U): core.$ZodFlattenedError<T, U>;
+  flatten(mapper?: AnyFunc): core.$ZodFlattenedError<T> {
+    return core.flattenError(this, mapper);
+  }
+
+  addIssue(issue: core.$ZodIssue): void {
+    this.issues.push(issue);
+  }
+  addIssues(issues: core.$ZodIssue[]): void {
+    this.issues.push(...issues);
+  }
+
+  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;