zod 4.1.0-canary.20250821T014930 → 4.1.0-canary.20250823T064644

package/v4/core/function.cjs

@@ -1,102 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.$ZodFunction = void 0;
-exports.function = _function;
-const api_js_1 = require("./api.cjs");
-const parse_js_1 = require("./parse.cjs");
-const schemas = __importStar(require("./schemas.cjs"));
-const schemas_js_1 = require("./schemas.cjs");
-class $ZodFunction {
-    constructor(def) {
-        this._def = def;
-        this.def = def;
-    }
-    implement(func) {
-        if (typeof func !== "function") {
-            throw new Error("implement() must be called with a function");
-        }
-        const impl = ((...args) => {
-            const parsedArgs = this._def.input ? (0, parse_js_1.parse)(this._def.input, args, undefined, { callee: impl }) : args;
-            if (!Array.isArray(parsedArgs)) {
-                throw new Error("Invalid arguments schema: not an array or tuple schema.");
-            }
-            const output = func(...parsedArgs);
-            return this._def.output ? (0, parse_js_1.parse)(this._def.output, output, undefined, { callee: impl }) : output;
-        });
-        return impl;
-    }
-    implementAsync(func) {
-        if (typeof func !== "function") {
-            throw new Error("implement() must be called with a function");
-        }
-        const impl = (async (...args) => {
-            const parsedArgs = this._def.input ? await (0, parse_js_1.parseAsync)(this._def.input, args, undefined, { callee: impl }) : args;
-            if (!Array.isArray(parsedArgs)) {
-                throw new Error("Invalid arguments schema: not an array or tuple schema.");
-            }
-            const output = await func(...parsedArgs);
-            return this._def.output ? (0, parse_js_1.parseAsync)(this._def.output, output, undefined, { callee: impl }) : output;
-        });
-        return impl;
-    }
-    input(...args) {
-        const F = this.constructor;
-        if (Array.isArray(args[0])) {
-            return new F({
-                type: "function",
-                input: new schemas_js_1.$ZodTuple({
-                    type: "tuple",
-                    items: args[0],
-                    rest: args[1],
-                }),
-                output: this._def.output,
-            });
-        }
-        return new F({
-            type: "function",
-            input: args[0],
-            output: this._def.output,
-        });
-    }
-    output(output) {
-        const F = this.constructor;
-        return new F({
-            type: "function",
-            input: this._def.input,
-            output,
-        });
-    }
-}
-exports.$ZodFunction = $ZodFunction;
-function _function(params) {
-    return new $ZodFunction({
-        type: "function",
-        input: Array.isArray(params?.input)
-            ? (0, api_js_1._tuple)(schemas.$ZodTuple, params?.input)
-            : (params?.input ?? (0, api_js_1._array)(schemas.$ZodArray, (0, api_js_1._unknown)(schemas.$ZodUnknown))),
-        output: params?.output ?? (0, api_js_1._unknown)(schemas.$ZodUnknown),
-    });
-}

package/v4/core/function.d.cts

@@ -1,52 +0,0 @@
-import type * as core from "./core.cjs";
-import * as schemas from "./schemas.cjs";
-import { $ZodTuple } from "./schemas.cjs";
-import type * as util from "./util.cjs";
-export interface $ZodFunctionDef<In extends $ZodFunctionIn = $ZodFunctionIn, Out extends $ZodFunctionOut = $ZodFunctionOut> {
-    type: "function";
-    input: In;
-    output: Out;
-}
-export type $ZodFunctionArgs = schemas.$ZodType<unknown[], unknown[]>;
-export type $ZodFunctionIn = $ZodFunctionArgs;
-export type $ZodFunctionOut = schemas.$ZodType;
-export type $InferInnerFunctionType<Args extends $ZodFunctionIn, Returns extends $ZodFunctionOut> = (...args: $ZodFunctionIn extends Args ? never[] : core.output<Args>) => core.input<Returns>;
-export type $InferInnerFunctionTypeAsync<Args extends $ZodFunctionIn, Returns extends $ZodFunctionOut> = (...args: $ZodFunctionIn extends Args ? never[] : core.output<Args>) => util.MaybeAsync<core.input<Returns>>;
-export type $InferOuterFunctionType<Args extends $ZodFunctionIn, Returns extends $ZodFunctionOut> = (...args: $ZodFunctionIn extends Args ? never[] : core.input<Args>) => core.output<Returns>;
-export type $InferOuterFunctionTypeAsync<Args extends $ZodFunctionIn, Returns extends $ZodFunctionOut> = (...args: $ZodFunctionIn extends Args ? never[] : core.input<Args>) => util.MaybeAsync<core.output<Returns>>;
-export declare class $ZodFunction<Args extends $ZodFunctionIn = $ZodFunctionIn, Returns extends $ZodFunctionOut = $ZodFunctionOut> {
-    def: $ZodFunctionDef<Args, Returns>;
-    /** @deprecated */
-    _def: $ZodFunctionDef<Args, Returns>;
-    _input: $InferInnerFunctionType<Args, Returns>;
-    _output: $InferOuterFunctionType<Args, Returns>;
-    constructor(def: $ZodFunctionDef<Args, Returns>);
-    implement<F extends $InferInnerFunctionType<Args, Returns>>(func: F): (...args: Parameters<this["_output"]>) => ReturnType<F> extends ReturnType<this["_output"]> ? ReturnType<F> : ReturnType<this["_output"]>;
-    implementAsync<F extends $InferInnerFunctionTypeAsync<Args, Returns>>(func: F): F extends $InferOuterFunctionTypeAsync<Args, Returns> ? F : $InferOuterFunctionTypeAsync<Args, Returns>;
-    input<const Items extends util.TupleItems, const Rest extends $ZodFunctionOut = $ZodFunctionOut>(args: Items, rest?: Rest): $ZodFunction<schemas.$ZodTuple<Items, Rest>, Returns>;
-    input<NewArgs extends $ZodFunctionIn>(args: NewArgs): $ZodFunction<NewArgs, Returns>;
-    output<NewReturns extends schemas.$ZodType>(output: NewReturns): $ZodFunction<Args, NewReturns>;
-}
-export interface $ZodFunctionParams<I extends $ZodFunctionIn, O extends schemas.$ZodType> {
-    input?: I;
-    output?: O;
-}
-declare function _function(): $ZodFunction;
-declare function _function<const In extends Array<schemas.$ZodType> = Array<schemas.$ZodType>>(params: {
-    input: In;
-}): $ZodFunction<$ZodTuple<In, null>, $ZodFunctionOut>;
-declare function _function<const In extends Array<schemas.$ZodType> = Array<schemas.$ZodType>, const Out extends $ZodFunctionOut = $ZodFunctionOut>(params: {
-    input: In;
-    output: Out;
-}): $ZodFunction<$ZodTuple<In, null>, Out>;
-declare function _function<const In extends $ZodFunctionIn = $ZodFunctionIn>(params: {
-    input: In;
-}): $ZodFunction<In, $ZodFunctionOut>;
-declare function _function<const Out extends $ZodFunctionOut = $ZodFunctionOut>(params: {
-    output: Out;
-}): $ZodFunction<$ZodFunctionIn, Out>;
-declare function _function<In extends $ZodFunctionIn = $ZodFunctionIn, Out extends schemas.$ZodType = schemas.$ZodType>(params?: {
-    input: In;
-    output: Out;
-}): $ZodFunction<In, Out>;
-export { _function as function };

package/v4/core/function.d.ts

@@ -1,52 +0,0 @@
-import type * as core from "./core.js";
-import * as schemas from "./schemas.js";
-import { $ZodTuple } from "./schemas.js";
-import type * as util from "./util.js";
-export interface $ZodFunctionDef<In extends $ZodFunctionIn = $ZodFunctionIn, Out extends $ZodFunctionOut = $ZodFunctionOut> {
-    type: "function";
-    input: In;
-    output: Out;
-}
-export type $ZodFunctionArgs = schemas.$ZodType<unknown[], unknown[]>;
-export type $ZodFunctionIn = $ZodFunctionArgs;
-export type $ZodFunctionOut = schemas.$ZodType;
-export type $InferInnerFunctionType<Args extends $ZodFunctionIn, Returns extends $ZodFunctionOut> = (...args: $ZodFunctionIn extends Args ? never[] : core.output<Args>) => core.input<Returns>;
-export type $InferInnerFunctionTypeAsync<Args extends $ZodFunctionIn, Returns extends $ZodFunctionOut> = (...args: $ZodFunctionIn extends Args ? never[] : core.output<Args>) => util.MaybeAsync<core.input<Returns>>;
-export type $InferOuterFunctionType<Args extends $ZodFunctionIn, Returns extends $ZodFunctionOut> = (...args: $ZodFunctionIn extends Args ? never[] : core.input<Args>) => core.output<Returns>;
-export type $InferOuterFunctionTypeAsync<Args extends $ZodFunctionIn, Returns extends $ZodFunctionOut> = (...args: $ZodFunctionIn extends Args ? never[] : core.input<Args>) => util.MaybeAsync<core.output<Returns>>;
-export declare class $ZodFunction<Args extends $ZodFunctionIn = $ZodFunctionIn, Returns extends $ZodFunctionOut = $ZodFunctionOut> {
-    def: $ZodFunctionDef<Args, Returns>;
-    /** @deprecated */
-    _def: $ZodFunctionDef<Args, Returns>;
-    _input: $InferInnerFunctionType<Args, Returns>;
-    _output: $InferOuterFunctionType<Args, Returns>;
-    constructor(def: $ZodFunctionDef<Args, Returns>);
-    implement<F extends $InferInnerFunctionType<Args, Returns>>(func: F): (...args: Parameters<this["_output"]>) => ReturnType<F> extends ReturnType<this["_output"]> ? ReturnType<F> : ReturnType<this["_output"]>;
-    implementAsync<F extends $InferInnerFunctionTypeAsync<Args, Returns>>(func: F): F extends $InferOuterFunctionTypeAsync<Args, Returns> ? F : $InferOuterFunctionTypeAsync<Args, Returns>;
-    input<const Items extends util.TupleItems, const Rest extends $ZodFunctionOut = $ZodFunctionOut>(args: Items, rest?: Rest): $ZodFunction<schemas.$ZodTuple<Items, Rest>, Returns>;
-    input<NewArgs extends $ZodFunctionIn>(args: NewArgs): $ZodFunction<NewArgs, Returns>;
-    output<NewReturns extends schemas.$ZodType>(output: NewReturns): $ZodFunction<Args, NewReturns>;
-}
-export interface $ZodFunctionParams<I extends $ZodFunctionIn, O extends schemas.$ZodType> {
-    input?: I;
-    output?: O;
-}
-declare function _function(): $ZodFunction;
-declare function _function<const In extends Array<schemas.$ZodType> = Array<schemas.$ZodType>>(params: {
-    input: In;
-}): $ZodFunction<$ZodTuple<In, null>, $ZodFunctionOut>;
-declare function _function<const In extends Array<schemas.$ZodType> = Array<schemas.$ZodType>, const Out extends $ZodFunctionOut = $ZodFunctionOut>(params: {
-    input: In;
-    output: Out;
-}): $ZodFunction<$ZodTuple<In, null>, Out>;
-declare function _function<const In extends $ZodFunctionIn = $ZodFunctionIn>(params: {
-    input: In;
-}): $ZodFunction<In, $ZodFunctionOut>;
-declare function _function<const Out extends $ZodFunctionOut = $ZodFunctionOut>(params: {
-    output: Out;
-}): $ZodFunction<$ZodFunctionIn, Out>;
-declare function _function<In extends $ZodFunctionIn = $ZodFunctionIn, Out extends schemas.$ZodType = schemas.$ZodType>(params?: {
-    input: In;
-    output: Out;
-}): $ZodFunction<In, Out>;
-export { _function as function };

package/v4/core/function.js

@@ -1,75 +0,0 @@
-import { _array, _tuple, _unknown } from "./api.js";
-import { parse, parseAsync } from "./parse.js";
-import * as schemas from "./schemas.js";
-import { $ZodTuple } from "./schemas.js";
-export class $ZodFunction {
-    constructor(def) {
-        this._def = def;
-        this.def = def;
-    }
-    implement(func) {
-        if (typeof func !== "function") {
-            throw new Error("implement() must be called with a function");
-        }
-        const impl = ((...args) => {
-            const parsedArgs = this._def.input ? parse(this._def.input, args, undefined, { callee: impl }) : args;
-            if (!Array.isArray(parsedArgs)) {
-                throw new Error("Invalid arguments schema: not an array or tuple schema.");
-            }
-            const output = func(...parsedArgs);
-            return this._def.output ? parse(this._def.output, output, undefined, { callee: impl }) : output;
-        });
-        return impl;
-    }
-    implementAsync(func) {
-        if (typeof func !== "function") {
-            throw new Error("implement() must be called with a function");
-        }
-        const impl = (async (...args) => {
-            const parsedArgs = this._def.input ? await parseAsync(this._def.input, args, undefined, { callee: impl }) : args;
-            if (!Array.isArray(parsedArgs)) {
-                throw new Error("Invalid arguments schema: not an array or tuple schema.");
-            }
-            const output = await func(...parsedArgs);
-            return this._def.output ? parseAsync(this._def.output, output, undefined, { callee: impl }) : output;
-        });
-        return impl;
-    }
-    input(...args) {
-        const F = this.constructor;
-        if (Array.isArray(args[0])) {
-            return new F({
-                type: "function",
-                input: new $ZodTuple({
-                    type: "tuple",
-                    items: args[0],
-                    rest: args[1],
-                }),
-                output: this._def.output,
-            });
-        }
-        return new F({
-            type: "function",
-            input: args[0],
-            output: this._def.output,
-        });
-    }
-    output(output) {
-        const F = this.constructor;
-        return new F({
-            type: "function",
-            input: this._def.input,
-            output,
-        });
-    }
-}
-function _function(params) {
-    return new $ZodFunction({
-        type: "function",
-        input: Array.isArray(params?.input)
-            ? _tuple(schemas.$ZodTuple, params?.input)
-            : (params?.input ?? _array(schemas.$ZodArray, _unknown(schemas.$ZodUnknown))),
-        output: params?.output ?? _unknown(schemas.$ZodUnknown),
-    });
-}
-export { _function as function };