@exodus/zod 3.24.2 → 3.24.4

package/index.d.ts

@@ -1,2 +1,2 @@
-export * from "./lib";
+export * from "./lib/index.js";
 export as namespace Zod;

package/lib/ZodError.d.ts

@@ -1,6 +1,6 @@
-import type { TypeOf, ZodType } from ".";
-import { Primitive } from "./helpers/typeAliases";
-import { util, ZodParsedType } from "./helpers/util";
+import { Primitive } from "./helpers/typeAliases.js";
+import { util, ZodParsedType } from "./helpers/util.js";
+import type { TypeOf, ZodType } from "./index.js";
 type allKeys<T> = T extends any ? keyof T : never;
 export type inferFlattenedErrors<T extends ZodType<any, any, any>, U = string> = typeToFlattenedError<TypeOf<T>, U>;
 export type typeToFlattenedError<T, U = string> = {

package/lib/errors.d.ts

@@ -1,5 +1,5 @@
-import defaultErrorMap from "./locales/en";
-import type { ZodErrorMap } from "./ZodError";
+import defaultErrorMap from "./locales/en.js";
+import type { ZodErrorMap } from "./ZodError.js";
 export { defaultErrorMap };
 export declare function setErrorMap(map: ZodErrorMap): void;
 export declare function getErrorMap(): ZodErrorMap;

package/lib/external.d.ts

@@ -1,6 +1,6 @@
-export * from "./errors";
-export * from "./helpers/parseUtil";
-export * from "./helpers/typeAliases";
-export * from "./helpers/util";
-export * from "./types";
-export * from "./ZodError";
+export * from "./errors.js";
+export * from "./helpers/parseUtil.js";
+export * from "./helpers/typeAliases.js";
+export * from "./helpers/util.js";
+export * from "./types.js";
+export * from "./ZodError.js";

package/lib/helpers/parseUtil.d.ts

@@ -1,5 +1,5 @@
-import type { IssueData, ZodErrorMap, ZodIssue } from "../ZodError";
-import type { ZodParsedType } from "./util";
+import type { IssueData, ZodErrorMap, ZodIssue } from "../ZodError.js";
+import type { ZodParsedType } from "./util.js";
 export declare const makeIssue: (params: {
     data: any;
     path: (string | number)[];

package/lib/helpers/partialUtil.d.ts

@@ -1,4 +1,4 @@
-import type { ZodArray, ZodNullable, ZodObject, ZodOptional, ZodRawShape, ZodTuple, ZodTupleItems, ZodTypeAny } from "../index";
+import type { ZodArray, ZodNullable, ZodObject, ZodOptional, ZodRawShape, ZodTuple, ZodTupleItems, ZodTypeAny } from "../index.js";
 export declare namespace partialUtil {
     type DeepPartial<T extends ZodTypeAny> = T extends ZodObject<ZodRawShape> ? ZodObject<{
         [k in keyof T["shape"]]: ZodOptional<DeepPartial<T["shape"][k]>>;

package/lib/index.d.ts

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

package/lib/index.mjs

@@ -166,36 +166,42 @@ class ZodError extends Error {
             function (issue) {
                 return issue.message;
             };
-        const fieldErrors = { _errors: [] };
-        const processError = (error) => {
-            for (const issue of error.issues) {
-                if (issue.code === "invalid_union") {
-                    issue.unionErrors.map(processError);
-                }
-                else if (issue.code === "invalid_return_type") {
-                    processError(issue.returnTypeError);
-                }
-                else if (issue.code === "invalid_arguments") {
-                    processError(issue.argumentsError);
-                }
-                else if (issue.path.length === 0) {
-                    fieldErrors._errors.push(mapper(issue));
-                }
-                else {
-                    let curr = fieldErrors;
-                    let i = 0;
-                    while (i < issue.path.length) {
-                        const el = issue.path[i];
-                        const terminal = i === issue.path.length - 1;
-                        if (!terminal) {
-                            curr[el] = curr[el] || { _errors: [] };
+        const fieldErrors = { __proto__: null, _errors: [] };
+        const processError = (rootError) => {
+            const stack = [rootError];
+            while (stack.length > 0) {
+                const error = stack.pop();
+                for (const issue of error.issues) {
+                    if (issue.code === "invalid_union") {
+                        for (const unionError of issue.unionErrors) {
+                            stack.push(unionError);
                         }
-                        else {
-                            curr[el] = curr[el] || { _errors: [] };
-                            curr[el]._errors.push(mapper(issue));
+                    }
+                    else if (issue.code === "invalid_return_type") {
+                        stack.push(issue.returnTypeError);
+                    }
+                    else if (issue.code === "invalid_arguments") {
+                        stack.push(issue.argumentsError);
+                    }
+                    else if (issue.path.length === 0) {
+                        fieldErrors._errors.push(mapper(issue));
+                    }
+                    else {
+                        let curr = fieldErrors;
+                        let i = 0;
+                        while (i < issue.path.length) {
+                            const el = issue.path[i];
+                            const terminal = i === issue.path.length - 1;
+                            if (!terminal) {
+                                curr[el] = curr[el] || { _errors: [] };
+                            }
+                            else {
+                                curr[el] = curr[el] || { _errors: [] };
+                                curr[el]._errors.push(mapper(issue));
+                            }
+                            curr = curr[el];
+                            i++;
                         }
-                        curr = curr[el];
-                        i++;
                     }
                 }
             }
@@ -2677,48 +2683,53 @@ class ZodUnion extends ZodType {
     };
 }
 const getDiscriminator = (type) => {
-    if (type instanceof ZodLazy) {
-        return getDiscriminator(type.schema);
-    }
-    else if (type instanceof ZodEffects) {
-        return getDiscriminator(type.innerType());
-    }
-    else if (type instanceof ZodLiteral) {
-        return [type.value];
-    }
-    else if (type instanceof ZodEnum) {
-        return type.options;
-    }
-    else if (type instanceof ZodNativeEnum) {
-        return util.objectValues(type.enum);
-    }
-    else if (type instanceof ZodDefault) {
-        return getDiscriminator(type._def.innerType);
-    }
-    else if (type instanceof ZodUndefined) {
-        return [undefined];
-    }
-    else if (type instanceof ZodNull) {
-        return [null];
-    }
-    else if (type instanceof ZodOptional) {
-        return [undefined, ...getDiscriminator(type.unwrap())];
-    }
-    else if (type instanceof ZodNullable) {
-        return [null, ...getDiscriminator(type.unwrap())];
-    }
-    else if (type instanceof ZodBranded) {
-        return getDiscriminator(type.unwrap());
-    }
-    else if (type instanceof ZodReadonly) {
-        return getDiscriminator(type.unwrap());
-    }
-    else if (type instanceof ZodCatch) {
-        return getDiscriminator(type._def.innerType);
-    }
-    else {
-        return [];
+    const result = [];
+    const stack = [type];
+    while (stack.length > 0) {
+        const current = stack.pop();
+        if (current instanceof ZodLazy) {
+            stack.push(current.schema);
+        }
+        else if (current instanceof ZodEffects) {
+            stack.push(current.innerType());
+        }
+        else if (current instanceof ZodLiteral) {
+            result.push(current.value);
+        }
+        else if (current instanceof ZodEnum) {
+            result.push(...current.options);
+        }
+        else if (current instanceof ZodNativeEnum) {
+            result.push(...util.objectValues(current.enum));
+        }
+        else if (current instanceof ZodDefault) {
+            stack.push(current._def.innerType);
+        }
+        else if (current instanceof ZodUndefined) {
+            result.push(undefined);
+        }
+        else if (current instanceof ZodNull) {
+            result.push(null);
+        }
+        else if (current instanceof ZodOptional) {
+            result.push(undefined);
+            stack.push(current.unwrap());
+        }
+        else if (current instanceof ZodNullable) {
+            result.push(null);
+            stack.push(current.unwrap());
+        }
+        else if (current instanceof ZodBranded) {
+            stack.push(current.unwrap());
+        }
+        else if (current instanceof ZodReadonly) {
+            stack.push(current.unwrap());
+        }
+        else if (current instanceof ZodCatch) {
+            stack.push(current._def.innerType);
+        }
     }
+    return result;
 };
 class ZodDiscriminatedUnion extends ZodType {
     _parse(input) {
@@ -2790,50 +2801,66 @@ class ZodDiscriminatedUnion extends ZodType {
     }
 }
 function mergeValues(a, b) {
-    const aType = getParsedType(a);
-    const bType = getParsedType(b);
-    if (a === b) {
-        return { valid: true, data: a };
-    }
-    else if (aType === ZodParsedType.object && bType === ZodParsedType.object) {
-        const bKeys = util.objectKeys(b);
-        const sharedKeys = util
-            .objectKeys(a)
-            .filter((key) => bKeys.indexOf(key) !== -1);
-        const newObj = { __proto__: null, ...a, ...b };
-        for (const key of sharedKeys) {
-            const sharedValue = mergeValues(a[key], b[key]);
-            if (!sharedValue.valid) {
-                return { valid: false };
-            }
-            newObj[key] = sharedValue.data;
-        }
-        return { valid: true, data: newObj };
-    }
-    else if (aType === ZodParsedType.array && bType === ZodParsedType.array) {
-        if (a.length !== b.length) {
-            return { valid: false };
-        }
-        const newArray = [];
-        for (let index = 0; index < a.length; index++) {
-            const itemA = a[index];
-            const itemB = b[index];
-            const sharedValue = mergeValues(itemA, itemB);
-            if (!sharedValue.valid) {
-                return { valid: false };
-            }
-            newArray.push(sharedValue.data);
-        }
-        return { valid: true, data: newArray };
-    }
-    else if (aType === ZodParsedType.date &&
-        bType === ZodParsedType.date &&
-        +a === +b) {
-        return { valid: true, data: a };
+    const root = { _data: undefined };
+    let valid = true;
+    const stack = [
+        { a, b, parent: root, key: "_data" },
+    ];
+    while (stack.length > 0 && valid) {
+        const { a, b, parent, key } = stack.pop();
+        const aType = getParsedType(a);
+        const bType = getParsedType(b);
+        if (a === b) {
+            parent[key] = a;
+            continue;
+        }
+        if (aType === ZodParsedType.object && bType === ZodParsedType.object) {
+            const bKeys = util.objectKeys(b);
+            const sharedKeys = util
+                .objectKeys(a)
+                .filter((k) => bKeys.indexOf(k) !== -1);
+            const newObj = { __proto__: null, ...a, ...b };
+            parent[key] = newObj;
+            for (const sharedKey of sharedKeys) {
+                stack.push({
+                    a: a[sharedKey],
+                    b: b[sharedKey],
+                    parent: newObj,
+                    key: sharedKey,
+                });
+            }
+            continue;
+        }
+        if (aType === ZodParsedType.array && bType === ZodParsedType.array) {
+            if (a.length !== b.length) {
+                valid = false;
+                break;
+            }
+            const newArray = [];
+            parent[key] = newArray;
+            for (let i = 0; i < a.length; i++) {
+                newArray[i] = undefined;
+                stack.push({
+                    a: a[i],
+                    b: b[i],
+                    parent: newArray,
+                    key: i,
+                });
+            }
+            continue;
+        }
+        if (aType === ZodParsedType.date &&
+            bType === ZodParsedType.date &&
+            +a === +b) {
+            parent[key] = a;
+            continue;
+        }
+        valid = false;
     }
-    else {
+    if (!valid) {
         return { valid: false };
     }
+    return { valid: true, data: root._data };
 }
 class ZodIntersection extends ZodType {
     _parse(input) {

package/lib/locales/en.d.ts

@@ -1,3 +1,3 @@
-import { ZodErrorMap } from "../ZodError";
+import { ZodErrorMap } from "../ZodError.js";
 declare const errorMap: ZodErrorMap;
 export default errorMap;

package/lib/types.d.ts

@@ -1,11 +1,11 @@
-import { enumUtil } from "./helpers/enumUtil";
-import { errorUtil } from "./helpers/errorUtil";
-import { AsyncParseReturnType, INVALID, ParseContext, ParseInput, ParseParams, ParseReturnType, ParseStatus, SyncParseReturnType } from "./helpers/parseUtil";
-import { partialUtil } from "./helpers/partialUtil";
-import { Primitive } from "./helpers/typeAliases";
-import { objectUtil, util } from "./helpers/util";
-import type { StandardSchemaV1 } from "./standard-schema";
-import { IssueData, StringValidation, ZodCustomIssue, ZodError, ZodErrorMap } from "./ZodError";
+import { enumUtil } from "./helpers/enumUtil.js";
+import { errorUtil } from "./helpers/errorUtil.js";
+import { AsyncParseReturnType, INVALID, ParseContext, ParseInput, ParseParams, ParseReturnType, ParseStatus, SyncParseReturnType } from "./helpers/parseUtil.js";
+import { partialUtil } from "./helpers/partialUtil.js";
+import { Primitive } from "./helpers/typeAliases.js";
+import { objectUtil, util } from "./helpers/util.js";
+import type { StandardSchemaV1 } from "./standard-schema.js";
+import { IssueData, StringValidation, ZodCustomIssue, ZodError, ZodErrorMap } from "./ZodError.js";
 export interface RefinementCtx {
     addIssue: (arg: IssueData) => void;
     path: (string | number)[];

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "@exodus/zod",
-  "version": "3.24.2",
+  "version": "3.24.4",
   "author": "Exodus Movement, Inc.",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/ExodusMovement/zod.git"
   },
   "type": "module",
+  "main": "./lib/index.mjs",
   "module": "./lib/index.mjs",
   "devDependencies": {
     "@babel/core": "^7.22.5",