@ptolemy2002/regex-utils 2.2.4 → 2.4.0

package/README.md

@@ -25,6 +25,17 @@ export type ZodSafeParseable<O> = {
 };
 ```
 
+## 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`.
+- `joinSeparator?` (`string`): The separator to be used when joining multiple errors. Default is `'\n'`.
+
 ## Functions
 The following functions are available in the library:
 
@@ -134,6 +145,7 @@ 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.
+- `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.
 
 #### Returns
 `string | string[] | null` - The interpreted error message(s).
@@ -154,6 +166,8 @@ 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'`.
 
 #### 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,17 @@ 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 declare function interpretZodError(e: ZodError, prefix?: string | string[]): 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>): ZodValidatorWithErrors<O>;
+export declare class ZodInterpretedError extends Error {
+    zodMessage: string | string[] | null;
+    joinSeparator: string;
+    constructor(message?: string | string[] | null, joinSeparator?: string);
+}
+export declare function zodValidateWithErrors<O>(p: ZodSafeParseable<O>, _throw?: boolean, joinSeparator?: string): 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,10 +111,17 @@ function isValidRegex(value, flags = "") {
 function isValidRegexFlags(value) {
     return /^[gimsuy]*$/.test(value);
 }
-function interpretZodError(e) {
+function interpretZodError(e, prefix) {
     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}`;
@@ -131,12 +138,23 @@ function zodValidate(p) {
         return result.success;
     };
 }
-function zodValidateWithErrors(p) {
+class ZodInterpretedError extends Error {
+    constructor(message = null, joinSeparator = "\n") {
+        super(Array.isArray(message) ? message.join(joinSeparator) : message ?? undefined);
+        this.zodMessage = message;
+        this.joinSeparator = joinSeparator;
+    }
+}
+exports.ZodInterpretedError = ZodInterpretedError;
+function zodValidateWithErrors(p, _throw = false, joinSeparator = "\n") {
     return (v) => {
         const result = p.safeParse(v);
         if (result.success)
             return true;
-        return interpretZodError(result.error);
+        const error = interpretZodError(result.error);
+        if (_throw)
+            throw new ZodInterpretedError(error, joinSeparator);
+        return error;
     };
 }
 const alphanumericPattern = /[\w_-]+/i;

package/package.json

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