@ptolemy2002/regex-utils 2.4.0 → 2.6.0

package/README.md

@@ -18,11 +18,21 @@ type TransformRegexOptions = {
     accentInsensitive?: boolean;
     matchWhole?: boolean;
 };
-export type ZodValidator<O> = (v: O) => boolean;
-export type ZodValidatorWithErrors<O> = (v: O) => true | string | string[];
-export type ZodSafeParseable<O> = {
+type ZodValidator<O> = (v: O) => boolean;
+type ZodValidatorWithErrors<O> = (v: O) => true | string | string[];
+type ZodSafeParseable<O> = {
     safeParse: (v: unknown) => z.SafeParseReturnType<unknown, O>;
 };
+type InterpretZodErrorOptions = {
+    prefix?: string | string[];
+    separator?: string;
+};
+type ZodValidateWithErrorsOptions = {
+    _throw?: boolean;
+    prefix?: string | string[];
+    joinSeparator?: string;
+    pathSeparator?: string;
+};
 ```
 
 ## Classes
@@ -33,8 +43,10 @@ The following classes are available in the library:
 A custom error class that is used to represent errors that have been interpreted from a zod error. It takes in either a single error or an array of errors, combining them in the `message` property, but keeping the original errors in the `zodMessage` property.
 
 #### Properties
-- `zodMessage` (`string | string[] | null`): The interpreted error message(s). If not specified, this will be `null`, but the `message` property itself will be `undefined`.
-- `joinSeparator?` (`string`): The separator to be used when joining multiple errors. Default is `'\n'`.
+- `zodMessage` (`string | string[] | null`): The interpreted error message(s). If not specified, this will be `null`, but the `message` property itself will be `undefined`. The class can be constructed with a `ZodError` object to automatically interpret the error.
+- `prefix` (`string | string[]`): A prefix to be added to the path. If an array is passed, the elements will be joined by `pathSeparator`. If not specified, the path will be used as is.
+- `separator` (`string`): The separator to be used when joining multiple errors. Default is `'\n'`.
+
 
 ## Functions
 The following functions are available in the library:
@@ -141,11 +153,13 @@ Checks if a string is a valid set of regular expression flags.
 
 ### interpretZodError
 #### Description
-Given a zod error, interprets it to `null` if no error is found, a single error message if there is a single error, or an array of error messages if there are multiple errors. The error messages will be in the format `<path>: <message>`.
+Given a zod error, interprets it to `null` if no error is found, a single error message if there is a single error, or an array of error messages if there are multiple errors. The error messages will be in the format `<path>: <message>`. If the error is with function arguments, "arguments.<index>" will be appended to the end of the path. Similarly, if the error is with a function return value, "returnValue" will be appended to the end of the path. Note that for function arguments, only the first seen error will be reported.
 
 #### Parameters
 - `e` (`ZodError`): The zod error to be interpreted.
-- `prefix?` (`string | string[]`): A prefix to be added to the path. If an array is passed, the elements will be joined by a period. If not specified, the path will be used as is.
+- `options` (`InterpretZodErrorOptions`): Used to specify optional arguments.
+    - `prefix?` (`string | string[]`): A prefix to be added to the path. If an array is passed, the elements will be joined by `separator`. If not specified, the path will be used as is.
+    - `separator` (`string`): The separator to be used when joining the path nodes. Default is `'.'`.
 
 #### Returns
 `string | string[] | null` - The interpreted error message(s).
@@ -166,8 +180,10 @@ This is a simple function that takes a zod schema, returning a function that tak
 
 #### Parameters
 - `p` (`ZodSafeParseable<O>`): The zod schema to be used for validation.
-- `_throw` (`boolean`): Whether to throw a `ZodInterpretedError` if the value does not match the schema. If true, errors will be delimited by the `joinSeparator` value. Default is `false`.
-- `joinSeparator` (`string`): The separator to be used when joining multiple errors. Default is `'\n'`.
+- `options` (`ZodValidateWithErrorsOptions`): Used to specify optional arguments.
+    - `_throw` (`boolean`): Whether to throw a `ZodInterpretedError` if the value does not match the schema. If true, errors will be delimited by the `joinSeparator` value. Default is `false`.
+    - `prefix?` (`string | string[]`): A prefix to be added to the path. If an array is passed, the elements will be joined by a period. If not specified, the path will be used as is.
+    - `joinSeparator` (`string`): The separator to be used when joining multiple errors. Default is `'\n'`.
 
 #### Returns
 `ZodValidatorWithErrors<O>` - A function that takes a value and returns `true` if the value matches the schema, an error message if there is a single error, or an array of error messages if there are multiple errors.

package/dist/index.d.ts

@@ -17,17 +17,28 @@ export declare function isValidRegex(value: string, flags?: string): boolean;
 export declare function isValidRegexFlags(value: string): boolean;
 export type ZodValidator<O> = (v: O) => boolean;
 export type ZodValidatorWithErrors<O> = (v: O) => true | string | string[];
-export declare function interpretZodError(e: ZodError, prefix?: string | string[]): string | string[] | null;
+export type InterpretZodErrorOptions = {
+    prefix?: string | string[];
+    separator?: string;
+};
+export declare function interpretZodError(e: ZodError, { prefix, separator }?: InterpretZodErrorOptions): string | string[] | null;
 export type ZodSafeParseable<O> = {
     safeParse: (v: unknown) => z.SafeParseReturnType<unknown, O>;
 };
 export declare function zodValidate<O>(p: ZodSafeParseable<O>): ZodValidator<O>;
+export type ZodValidateWithErrorsOptions = {
+    _throw?: boolean;
+    prefix?: string | string[];
+    joinSeparator?: string;
+    pathSeparator?: string;
+};
 export declare class ZodInterpretedError extends Error {
     zodMessage: string | string[] | null;
+    prefix: string | string[] | undefined;
     joinSeparator: string;
-    constructor(message?: string | string[] | null, joinSeparator?: string);
+    constructor(message?: ZodError | string | string[] | null, { prefix, joinSeparator, pathSeparator }?: ZodValidateWithErrorsOptions);
 }
-export declare function zodValidateWithErrors<O>(p: ZodSafeParseable<O>, _throw?: boolean, joinSeparator?: string): ZodValidatorWithErrors<O>;
+export declare function zodValidateWithErrors<O>(p: ZodSafeParseable<O>, { _throw, prefix, joinSeparator, pathSeparator }?: ZodValidateWithErrorsOptions): ZodValidatorWithErrors<O>;
 export declare function isAlphanumeric(str: string): boolean;
 export declare function toAlphanumeric(str: string, separator?: string): string;
 export declare function isValidEmail(v: string): boolean;

package/dist/index.js

@@ -111,10 +111,10 @@ function isValidRegex(value, flags = "") {
 function isValidRegexFlags(value) {
     return /^[gimsuy]*$/.test(value);
 }
-function interpretZodError(e, prefix) {
+function interpretZodError(e, { prefix, separator = "." } = {}) {
     const { errors } = e;
     function formatIssue(issue) {
-        const { path: _path, message } = issue;
+        const { code, path: _path, message } = issue;
         let path = _path;
         if (typeof prefix === "string") {
             path = [prefix, ...path];
@@ -122,9 +122,19 @@ function interpretZodError(e, prefix) {
         else if (Array.isArray(prefix)) {
             path = [...prefix, ...path];
         }
+        if (code === "invalid_return_type") {
+            const returnTypeIssue = issue.returnTypeError.errors[0];
+            path = [...path, "returnType", ...returnTypeIssue.path];
+            return `${path.join(separator)}: ${returnTypeIssue.message}`;
+        }
+        else if (code === "invalid_arguments") {
+            const argumentsIssue = issue.argumentsError.errors[0];
+            path = [...path, "arguments", ...argumentsIssue.path];
+            return `${path.join(separator)}: ${argumentsIssue.message}`;
+        }
         if (path.length === 0)
             return message;
-        return `${path.join(".")}: ${message}`;
+        return `${path.join(separator)}: ${message}`;
     }
     if (errors.length === 0)
         return null;
@@ -139,22 +149,25 @@ function zodValidate(p) {
     };
 }
 class ZodInterpretedError extends Error {
-    constructor(message = null, joinSeparator = "\n") {
+    constructor(message = null, { prefix, joinSeparator = "\n", pathSeparator = "." } = {}) {
+        if (message instanceof zod_1.ZodError)
+            message = interpretZodError(message, { prefix, separator: pathSeparator });
         super(Array.isArray(message) ? message.join(joinSeparator) : message ?? undefined);
         this.zodMessage = message;
+        this.prefix = prefix;
         this.joinSeparator = joinSeparator;
     }
 }
 exports.ZodInterpretedError = ZodInterpretedError;
-function zodValidateWithErrors(p, _throw = false, joinSeparator = "\n") {
+function zodValidateWithErrors(p, { _throw = false, prefix, joinSeparator = "\n", pathSeparator = "." } = {}) {
     return (v) => {
-        const result = p.safeParse(v);
-        if (result.success)
+        const { success, error: error } = p.safeParse(v);
+        if (success)
             return true;
-        const error = interpretZodError(result.error);
+        const zError = new ZodInterpretedError(error, { prefix, joinSeparator, pathSeparator });
         if (_throw)
-            throw new ZodInterpretedError(error, joinSeparator);
-        return error;
+            throw zError;
+        return zError.zodMessage ?? "";
     };
 }
 const alphanumericPattern = /[\w_-]+/i;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@ptolemy2002/regex-utils",
-    "version": "2.4.0",
+    "version": "2.6.0",
     "private": false,
     "main": "dist/index.js",
     "types": "dist/index.d.ts",