zod-compiler 1.23.0 → 1.23.2

package/dist/core/extract/checks.js

@@ -1,331 +1,338 @@
 import { isPayloadCheck, isReferenceablePredicate, tryCompileEffect } from "./effects.js";
+//#region src/core/extract/checks.ts
 /**
- * Build the `refineRef` registrar for {@link extractChecks} from an extractor's
- * context: it appends a {@link RefEntry} pointing at the check's own predicate
- * (`<schema>._zod.def.checks[i]._zod.def.fn`) so generated code can call the
- * user's function object directly. Returns undefined — meaning "fall back as
- * before" — when the extraction is not collecting refs.
- */
-export function refineRefRegistrar(ctx, checks) {
-    const refs = ctx.refs;
-    if (!refs)
-        return undefined;
-    return (index) => {
-        const fn = checks[index]?._zod?.def?.fn;
-        if (!isReferenceablePredicate(fn))
-            return undefined;
-        refs.push({ schema: fn, accessPath: `${ctx.path}._zod.def.checks[${index}]._zod.def.fn` });
-        return refs.length - 1;
-    };
+* Build the `refineRef` registrar for {@link extractChecks} from an extractor's
+* context: it appends a {@link RefEntry} pointing at the check's own predicate
+* (`<schema>._zod.def.checks[i]._zod.def.fn`) so generated code can call the
+* user's function object directly. Returns undefined — meaning "fall back as
+* before" — when the extraction is not collecting refs.
+*/
+function refineRefRegistrar(ctx, checks) {
+	const refs = ctx.refs;
+	if (!refs) return void 0;
+	return (index) => {
+		const fn = checks[index]?._zod?.def?.fn;
+		if (!isReferenceablePredicate(fn)) return void 0;
+		refs.push({
+			schema: fn,
+			accessPath: `${ctx.path}._zod.def.checks[${index}]._zod.def.fn`
+		});
+		return refs.length - 1;
+	};
 }
 /**
- * Register the payload-taking callback of check `index` (`superRefine`) as an
- * `__rf[N]` reference, pointing at zod's own wrapper
- * (`<schema>._zod.def.checks[i]._zod.check`).
- *
- * Only the LAST check on a node qualifies: an issue carrying
- * `fatal`/`continue:false` aborts zod's remaining chain, and compiled output
- * runs every check unconditionally — with nothing following, there is nothing
- * left to abort, so the two agree.
- */
-export function payloadCheckRef(ctx, checks, index) {
-    if (index !== checks.length - 1)
-        return undefined;
-    const check = checks[index];
-    const refs = ctx.refs;
-    if (!refs || !check || !isPayloadCheck(check))
-        return undefined;
-    refs.push({
-        schema: check._zod.check,
-        accessPath: `${ctx.path}._zod.def.checks[${index}]._zod.check`,
-    });
-    return refs.length - 1;
+* Register the payload-taking callback of check `index` (`superRefine`) as an
+* `__rf[N]` reference, pointing at zod's own wrapper
+* (`<schema>._zod.def.checks[i]._zod.check`).
+*
+* Only the LAST check on a node qualifies: an issue carrying
+* `fatal`/`continue:false` aborts zod's remaining chain, and compiled output
+* runs every check unconditionally — with nothing following, there is nothing
+* left to abort, so the two agree.
+*/
+function payloadCheckRef(ctx, checks, index) {
+	if (index !== checks.length - 1) return void 0;
+	const check = checks[index];
+	const refs = ctx.refs;
+	if (!refs || !check || !isPayloadCheck(check)) return void 0;
+	refs.push({
+		schema: check._zod.check,
+		accessPath: `${ctx.path}._zod.def.checks[${index}]._zod.check`
+	});
+	return refs.length - 1;
 }
 /**
- * String formats the codegen can validate without a regex pattern.
- * Everything else without a pattern (e.g. z.jwt(), which validates
- * algorithmically) must fall back to Zod instead of being silently skipped.
- */
-const PATTERNLESS_FORMATS = new Set(["email", "uuid", "url"]);
+* String formats the codegen can validate without a regex pattern.
+* Everything else without a pattern (e.g. z.jwt(), which validates
+* algorithmically) must fall back to Zod instead of being silently skipped.
+*/
+const PATTERNLESS_FORMATS = /* @__PURE__ */ new Set([
+	"email",
+	"uuid",
+	"url"
+]);
 /**
- * Formats whose def.pattern is NOT the authoritative validator — zod's
- * runtime check is algorithmic and accepts inputs the pattern rejects
- * (e.g. z.cidrv6() splits the prefix and validates the IPv6 part separately).
- */
-const NON_AUTHORITATIVE_PATTERN_FORMATS = new Set(["cidrv6"]);
+* Formats whose def.pattern is NOT the authoritative validator — zod's
+* runtime check is algorithmic and accepts inputs the pattern rejects
+* (e.g. z.cidrv6() splits the prefix and validates the IPv6 part separately).
+*/
+const NON_AUTHORITATIVE_PATTERN_FORMATS = /* @__PURE__ */ new Set(["cidrv6"]);
 /**
- * Check kinds where Zod itself installs a `when` guard
- * (`!nullish(value) && value.length/size !== undefined`). Compiled output
- * reproduces that gating structurally — length/size checks only run after the
- * typeof/instanceof guard — so a `when` on these kinds is expected and safe.
- * A `when` anywhere else must be user-supplied → fall back to Zod.
- * (A user-supplied `when` on one of these six kinds is indistinguishable from
- * the internal guard and remains unsupported.)
- */
-const INTERNAL_WHEN_CHECK_KINDS = new Set([
-    "min_length",
-    "max_length",
-    "length_equals",
-    "min_size",
-    "max_size",
-    "size_equals",
+* Check kinds where Zod itself installs a `when` guard
+* (`!nullish(value) && value.length/size !== undefined`). Compiled output
+* reproduces that gating structurally — length/size checks only run after the
+* typeof/instanceof guard — so a `when` on these kinds is expected and safe.
+* A `when` anywhere else must be user-supplied → fall back to Zod.
+* (A user-supplied `when` on one of these six kinds is indistinguishable from
+* the internal guard and remains unsupported.)
+*/
+const INTERNAL_WHEN_CHECK_KINDS = /* @__PURE__ */ new Set([
+	"min_length",
+	"max_length",
+	"length_equals",
+	"min_size",
+	"max_size",
+	"size_equals"
 ]);
 /** True when a check carries a runtime `when` predicate we cannot reproduce. */
 function hasUserWhen(def) {
-    return Boolean(def.when) && !INTERNAL_WHEN_CHECK_KINDS.has(def.check);
+	return Boolean(def.when) && !INTERNAL_WHEN_CHECK_KINDS.has(def.check);
 }
 /**
- * True when a check can't be compiled because of runtime modifiers:
- * a user-supplied `when` predicate, or `abort: true` (which stops later
- * checks and marks the option as aborted in union pruning — compiled
- * output always runs every check).
- */
-export function hasUncompilableModifiers(def) {
-    return hasUserWhen(def) || def.abort === true;
+* True when a check can't be compiled because of runtime modifiers:
+* a user-supplied `when` predicate, or `abort: true` (which stops later
+* checks and marks the option as aborted in union pruning — compiled
+* output always runs every check).
+*/
+function hasUncompilableModifiers(def) {
+	return hasUserWhen(def) || def.abort === true;
 }
-export function extractChecks(checks, 
-/**
- * Registers the predicate of the check at `index` as an `__rf[N]` reference
- * and returns N, or undefined when references are unavailable (no refs array)
- * or the callback's shape cannot be called directly. Supplied by extractors
- * that know their schema's access path; omitted by callers that do not, which
- * simply keeps the old fall-back-to-zod behavior.
- */
-refineRef, 
-/** Registers a payload-taking callback (superRefine); see payloadCheckRef. */
-payloadRefFor) {
-    const checkIRs = [];
-    let hasFallback = false;
-    for (const [index, check] of checks.entries()) {
-        const def = check._zod?.def;
-        if (!def)
-            continue;
-        // Checks gated by a user-supplied runtime `when` predicate or abort:true
-        // can't be reproduced in compiled output — delegate the schema to Zod.
-        if (hasUncompilableModifiers(def)) {
-            hasFallback = true;
-            continue;
-        }
-        // Per-check custom error: bake static messages into the IR; error maps
-        // that read the issue (dynamic) can't be compiled — fall back so Zod
-        // produces the exact message.
-        const resolved = resolveCheckMessage(def.error);
-        if (resolved.kind === "dynamic") {
-            hasFallback = true;
-            continue;
-        }
-        const message = resolved.kind === "static" ? { message: resolved.message } : {};
-        switch (def.check) {
-            case "min_length":
-                checkIRs.push({ kind: "min_length", minimum: def.minimum, ...message });
-                break;
-            case "max_length":
-                checkIRs.push({ kind: "max_length", maximum: def.maximum, ...message });
-                break;
-            case "length_equals":
-                checkIRs.push({ kind: "length_equals", length: def.length, ...message });
-                break;
-            case "greater_than":
-                checkIRs.push({
-                    kind: "greater_than",
-                    value: def.value,
-                    inclusive: def.inclusive,
-                    ...message,
-                });
-                break;
-            case "less_than":
-                checkIRs.push({
-                    kind: "less_than",
-                    value: def.value,
-                    inclusive: def.inclusive,
-                    ...message,
-                });
-                break;
-            case "multiple_of":
-                checkIRs.push({ kind: "multiple_of", value: def.value, ...message });
-                break;
-            case "number_format":
-                checkIRs.push({
-                    kind: "number_format",
-                    format: def.format,
-                    ...message,
-                });
-                break;
-            case "string_format": {
-                if (def.format === "includes" && typeof def.includes === "string") {
-                    checkIRs.push({
-                        kind: "includes",
-                        includes: def.includes,
-                        ...(typeof def.position === "number" ? { position: def.position } : {}),
-                        ...message,
-                    });
-                    break;
-                }
-                if (def.format === "starts_with" && typeof def.prefix === "string") {
-                    checkIRs.push({ kind: "starts_with", prefix: def.prefix, ...message });
-                    break;
-                }
-                if (def.format === "ends_with" && typeof def.suffix === "string") {
-                    checkIRs.push({ kind: "ends_with", suffix: def.suffix, ...message });
-                    break;
-                }
-                if (def.format === "url") {
-                    checkIRs.push({
-                        kind: "string_format",
-                        format: "url",
-                        ...regexFields("hostname", "hostnameFlags", def.hostname),
-                        ...regexFields("protocol", "protocolFlags", def.protocol),
-                        ...(def.normalize ? { normalize: true } : {}),
-                        ...message,
-                    });
-                    break;
-                }
-                if (NON_AUTHORITATIVE_PATTERN_FORMATS.has(def.format)) {
-                    hasFallback = true;
-                    break;
-                }
-                const pattern = def.pattern instanceof RegExp ? def.pattern.source : def.pattern;
-                const flags = def.pattern instanceof RegExp && def.pattern.flags ? def.pattern.flags : "";
-                if (!pattern && !PATTERNLESS_FORMATS.has(def.format)) {
-                    // Algorithmic format (e.g. jwt) — nothing to compile.
-                    hasFallback = true;
-                    break;
-                }
-                checkIRs.push({
-                    kind: "string_format",
-                    format: def.format,
-                    ...(pattern ? { pattern } : {}),
-                    ...(flags ? { patternFlags: flags } : {}),
-                    ...message,
-                });
-                break;
-            }
-            case "overwrite": {
-                // $ZodCheckOverwrite (.trim(), .toLowerCase(), ...): value = def.tx(value)
-                const source = tryCompileEffect(def.tx);
-                if (source) {
-                    checkIRs.push({ kind: "overwrite_effect", source });
-                }
-                else {
-                    hasFallback = true;
-                }
-                break;
-            }
-            case "custom": {
-                // superRefine / raw .check(): the callback collects issues from zod's
-                // payload rather than returning a verdict, so it is referenced and
-                // called with a synthesized payload (see SuperRefineEffectCheckIR).
-                if (isPayloadCheck(check)) {
-                    const payloadRef = payloadRefFor?.(index);
-                    if (payloadRef === undefined) {
-                        hasFallback = true;
-                        break;
-                    }
-                    checkIRs.push({ kind: "super_refine_effect", refIndex: payloadRef });
-                    break;
-                }
-                // `.refine(fn, { path })` reports the issue against a member of the
-                // refined value; anything but plain string/number segments is a shape
-                // the generated path expression cannot reproduce.
-                const customPath = Array.isArray(def.path) ? def.path : undefined;
-                if (customPath?.some((p) => typeof p !== "string" && typeof p !== "number")) {
-                    hasFallback = true;
-                    break;
-                }
-                const pathIR = customPath && customPath.length > 0 ? { path: customPath } : {};
-                const source = tryCompileEffect(def.fn);
-                if (source) {
-                    checkIRs.push({ kind: "refine_effect", source, ...pathIR, ...message });
-                    break;
-                }
-                // Not inlineable (the predicate captures outer variables). Call the
-                // user's own function object through a schema reference instead of
-                // delegating: a captured `.refine()` at the root otherwise costs the
-                // whole schema its compiled path.
-                const refIndex = refineRef?.(index);
-                if (refIndex !== undefined) {
-                    checkIRs.push({ kind: "refine_effect", refIndex, ...pathIR, ...message });
-                }
-                else {
-                    hasFallback = true;
-                }
-                break;
-            }
-            default:
-                // Unknown check kind — never drop silently; delegate to Zod.
-                hasFallback = true;
-                break;
-        }
-    }
-    return { checkIRs, hasFallback };
+function extractChecks(checks, refineRef, payloadRefFor) {
+	const checkIRs = [];
+	let hasFallback = false;
+	for (const [index, check] of checks.entries()) {
+		const def = check._zod?.def;
+		if (!def) continue;
+		if (hasUncompilableModifiers(def)) {
+			hasFallback = true;
+			continue;
+		}
+		const resolved = resolveCheckMessage(def.error);
+		if (resolved.kind === "dynamic") {
+			hasFallback = true;
+			continue;
+		}
+		const message = resolved.kind === "static" ? { message: resolved.message } : {};
+		switch (def.check) {
+			case "min_length":
+				checkIRs.push({
+					kind: "min_length",
+					minimum: def.minimum,
+					...message
+				});
+				break;
+			case "max_length":
+				checkIRs.push({
+					kind: "max_length",
+					maximum: def.maximum,
+					...message
+				});
+				break;
+			case "length_equals":
+				checkIRs.push({
+					kind: "length_equals",
+					length: def.length,
+					...message
+				});
+				break;
+			case "greater_than":
+				checkIRs.push({
+					kind: "greater_than",
+					value: def.value,
+					inclusive: def.inclusive,
+					...message
+				});
+				break;
+			case "less_than":
+				checkIRs.push({
+					kind: "less_than",
+					value: def.value,
+					inclusive: def.inclusive,
+					...message
+				});
+				break;
+			case "multiple_of":
+				checkIRs.push({
+					kind: "multiple_of",
+					value: def.value,
+					...message
+				});
+				break;
+			case "number_format":
+				checkIRs.push({
+					kind: "number_format",
+					format: def.format,
+					...message
+				});
+				break;
+			case "string_format": {
+				if (def.format === "includes" && typeof def.includes === "string") {
+					checkIRs.push({
+						kind: "includes",
+						includes: def.includes,
+						...typeof def.position === "number" ? { position: def.position } : {},
+						...message
+					});
+					break;
+				}
+				if (def.format === "starts_with" && typeof def.prefix === "string") {
+					checkIRs.push({
+						kind: "starts_with",
+						prefix: def.prefix,
+						...message
+					});
+					break;
+				}
+				if (def.format === "ends_with" && typeof def.suffix === "string") {
+					checkIRs.push({
+						kind: "ends_with",
+						suffix: def.suffix,
+						...message
+					});
+					break;
+				}
+				if (def.format === "url") {
+					checkIRs.push({
+						kind: "string_format",
+						format: "url",
+						...regexFields("hostname", "hostnameFlags", def.hostname),
+						...regexFields("protocol", "protocolFlags", def.protocol),
+						...def.normalize ? { normalize: true } : {},
+						...message
+					});
+					break;
+				}
+				if (NON_AUTHORITATIVE_PATTERN_FORMATS.has(def.format)) {
+					hasFallback = true;
+					break;
+				}
+				const pattern = def.pattern instanceof RegExp ? def.pattern.source : def.pattern;
+				const flags = def.pattern instanceof RegExp && def.pattern.flags ? def.pattern.flags : "";
+				if (!pattern && !PATTERNLESS_FORMATS.has(def.format)) {
+					hasFallback = true;
+					break;
+				}
+				checkIRs.push({
+					kind: "string_format",
+					format: def.format,
+					...pattern ? { pattern } : {},
+					...flags ? { patternFlags: flags } : {},
+					...message
+				});
+				break;
+			}
+			case "overwrite": {
+				const source = tryCompileEffect(def.tx);
+				if (source) checkIRs.push({
+					kind: "overwrite_effect",
+					source
+				});
+				else hasFallback = true;
+				break;
+			}
+			case "custom": {
+				if (isPayloadCheck(check)) {
+					const payloadRef = payloadRefFor?.(index);
+					if (payloadRef === void 0) {
+						hasFallback = true;
+						break;
+					}
+					checkIRs.push({
+						kind: "super_refine_effect",
+						refIndex: payloadRef
+					});
+					break;
+				}
+				const customPath = Array.isArray(def.path) ? def.path : void 0;
+				if (customPath?.some((p) => typeof p !== "string" && typeof p !== "number")) {
+					hasFallback = true;
+					break;
+				}
+				const pathIR = customPath && customPath.length > 0 ? { path: customPath } : {};
+				const source = tryCompileEffect(def.fn);
+				if (source) {
+					checkIRs.push({
+						kind: "refine_effect",
+						source,
+						...pathIR,
+						...message
+					});
+					break;
+				}
+				const refIndex = refineRef?.(index);
+				if (refIndex !== void 0) checkIRs.push({
+					kind: "refine_effect",
+					refIndex,
+					...pathIR,
+					...message
+				});
+				else hasFallback = true;
+				break;
+			}
+			default:
+				hasFallback = true;
+				break;
+		}
+	}
+	return {
+		checkIRs,
+		hasFallback
+	};
 }
 function regexFields(sourceKey, flagsKey, value) {
-    if (!(value instanceof RegExp))
-        return {};
-    return { [sourceKey]: value.source, ...(value.flags ? { [flagsKey]: value.flags } : {}) };
+	if (!(value instanceof RegExp)) return {};
+	return {
+		[sourceKey]: value.source,
+		...value.flags ? { [flagsKey]: value.flags } : {}
+	};
 }
 /**
- * Classify a check/schema-level `error` param.
- *
- * Zod normalizes `.min(3, "msg")` / `{ error: "msg" }` / `{ message: "msg" }`
- * into an error-map function that ignores its issue argument and returns the
- * string. We call the function with an access-tracking Proxy: if it never
- * inspects the issue, its return value is a constant we can bake into the
- * generated issue. If it reads any issue property (input-dependent message),
- * it is dynamic and the schema must fall back to Zod for exact messages.
- */
-export function resolveCheckMessage(error) {
-    if (error === null || error === undefined)
-        return { kind: "none" };
-    if (typeof error === "string")
-        return { kind: "static", message: error };
-    if (typeof error !== "function")
-        return { kind: "dynamic" };
-    let accessed = false;
-    const track = () => {
-        accessed = true;
-    };
-    const probe = new Proxy({}, {
-        get(_t, prop) {
-            track();
-            // Avoid breaking string coercion / await probing inside error maps.
-            if (prop === Symbol.toPrimitive || prop === "toString" || prop === "valueOf") {
-                return () => "";
-            }
-            return undefined;
-        },
-        has() {
-            track();
-            return false;
-        },
-        ownKeys() {
-            track();
-            return [];
-        },
-        getOwnPropertyDescriptor() {
-            track();
-            return undefined;
-        },
-    });
-    let result;
-    try {
-        result = error(probe);
-    }
-    catch {
-        return { kind: "dynamic" };
-    }
-    if (accessed)
-        return { kind: "dynamic" };
-    if (typeof result === "string")
-        return { kind: "static", message: result };
-    if (result !== null &&
-        typeof result === "object" &&
-        typeof result.message === "string") {
-        return { kind: "static", message: result.message };
-    }
-    // Error map deferred (returned undefined) — no custom message.
-    if (result === undefined)
-        return { kind: "none" };
-    return { kind: "dynamic" };
+* Classify a check/schema-level `error` param.
+*
+* Zod normalizes `.min(3, "msg")` / `{ error: "msg" }` / `{ message: "msg" }`
+* into an error-map function that ignores its issue argument and returns the
+* string. We call the function with an access-tracking Proxy: if it never
+* inspects the issue, its return value is a constant we can bake into the
+* generated issue. If it reads any issue property (input-dependent message),
+* it is dynamic and the schema must fall back to Zod for exact messages.
+*/
+function resolveCheckMessage(error) {
+	if (error === null || error === void 0) return { kind: "none" };
+	if (typeof error === "string") return {
+		kind: "static",
+		message: error
+	};
+	if (typeof error !== "function") return { kind: "dynamic" };
+	let accessed = false;
+	const track = () => {
+		accessed = true;
+	};
+	const probe = new Proxy({}, {
+		get(_t, prop) {
+			track();
+			if (prop === Symbol.toPrimitive || prop === "toString" || prop === "valueOf") return () => "";
+		},
+		has() {
+			track();
+			return false;
+		},
+		ownKeys() {
+			track();
+			return [];
+		},
+		getOwnPropertyDescriptor() {
+			track();
+		}
+	});
+	let result;
+	try {
+		result = error(probe);
+	} catch {
+		return { kind: "dynamic" };
+	}
+	if (accessed) return { kind: "dynamic" };
+	if (typeof result === "string") return {
+		kind: "static",
+		message: result
+	};
+	if (result !== null && typeof result === "object" && typeof result.message === "string") return {
+		kind: "static",
+		message: result.message
+	};
+	if (result === void 0) return { kind: "none" };
+	return { kind: "dynamic" };
 }
+//#endregion
+export { extractChecks, hasUncompilableModifiers, payloadCheckRef, refineRefRegistrar, resolveCheckMessage };
+
 //# sourceMappingURL=checks.js.map