@ptolemy2002/regex-utils 2.3.0 → 2.5.0

package/README.md

@@ -18,13 +18,36 @@ 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
+The following classes are available in the library:
+
+### ZodInterpretedError
+#### Description
+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`. 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:
 
@@ -134,6 +157,9 @@ Given a zod error, interprets it to `null` if no error is found, a single error
 
 #### Parameters
 - `e` (`ZodError`): The zod error to be interpreted.
+- `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).
@@ -154,7 +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 an error if the value does not match the schema. If true, errors will be delimited by newlines. Default is `false`.
+- `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,12 +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): 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 declare function zodValidateWithErrors<O>(p: ZodSafeParseable<O>, _throw?: boolean): ZodValidatorWithErrors<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?: ZodError | string | string[] | null, { prefix, joinSeparator, pathSeparator }?: ZodValidateWithErrorsOptions);
+}
+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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ZodCoercedBoolean = exports.ZodCoercedBooleanEnum = void 0;
+exports.ZodCoercedBoolean = exports.ZodCoercedBooleanEnum = exports.ZodInterpretedError = void 0;
 exports.combineFlags = combineFlags;
 exports.escapeRegex = escapeRegex;
 exports.regexAccentInsensitive = regexAccentInsensitive;
@@ -111,13 +111,20 @@ function isValidRegex(value, flags = "") {
 function isValidRegexFlags(value) {
     return /^[gimsuy]*$/.test(value);
 }
-function interpretZodError(e) {
+function interpretZodError(e, { prefix, separator = "." }) {
     const { errors } = e;
     function formatIssue(issue) {
-        const { path, message } = issue;
+        const { path: _path, message } = issue;
+        let path = _path;
+        if (typeof prefix === "string") {
+            path = [prefix, ...path];
+        }
+        else if (Array.isArray(prefix)) {
+            path = [...prefix, ...path];
+        }
         if (path.length === 0)
             return message;
-        return `${path.join(".")}: ${message}`;
+        return `${path.join(separator)}: ${message}`;
     }
     if (errors.length === 0)
         return null;
@@ -131,21 +138,26 @@ function zodValidate(p) {
         return result.success;
     };
 }
-function zodValidateWithErrors(p, _throw = false) {
+class ZodInterpretedError extends Error {
+    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, 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);
-        if (_throw) {
-            if (Array.isArray(error)) {
-                throw new Error(error.join("\n"));
-            }
-            else {
-                throw new Error(error);
-            }
-        }
-        return error;
+        const zError = new ZodInterpretedError(error, { prefix, joinSeparator, pathSeparator });
+        if (_throw)
+            throw zError;
+        return zError.zodMessage ?? "";
     };
 }
 const alphanumericPattern = /[\w_-]+/i;

package/package.json

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