@ptolemy2002/regex-utils 2.0.0 → 2.1.0

package/README.md

@@ -125,6 +125,16 @@ Checks if a string is a valid set of regular expression flags.
 #### Returns
 `boolean` - `true` if the string is a valid set of regular expression flags, `false` otherwise.
 
+### 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.
+
+#### Parameters
+- `e` (`ZodError`): The zod error to be interpreted.
+
+#### Returns
+`string | string[] | null` - The interpreted error message(s).
+
 ### zodValidate<O>
 #### Description
 This is a simple function that takes a zod schema, returning a function that takes a value. If the value matches, the function returns `true`. Otherwise, it returns `false`. `O` refers to the output type of the zod schema, which should be the same as its input type.
@@ -137,7 +147,7 @@ This is a simple function that takes a zod schema, returning a function that tak
 
 ### zodValidateWithErrors<O>
 #### Description
-This is a simple function that takes a zod schema, returning a function that takes a value. If the value matches, the function returns `true`. Otherwise, it returns a single error message or an array of error messages if there are multiple errors. `O` refers to the output type of the zod schema, which should be the same as its input type.
+This is a simple function that takes a zod schema, returning a function that takes a value. If the value matches, the function returns `true`. Otherwise, it returns the result of `interpretZodError` on the error. `O` refers to the output type of the zod schema, which should be the same as its input type.
 
 #### Parameters
 - `p` (`ZodSchema<O>`): The zod schema to be used for validation.

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { ZodSchema } from "zod";
+import { ZodError, ZodSchema } from "zod";
 export type RegexInput = string | RegExp;
 export declare function combineFlags(...flags: string[]): string;
 export declare function escapeRegex(value: RegexInput, flags?: string): RegExp;
@@ -12,11 +12,12 @@ export type TransformRegexOptions = {
     accentInsensitive?: boolean;
     matchWhole?: boolean;
 };
-export declare function transformRegex(value: RegexInput, { flags, accentInsensitive, caseInsensitive, matchWhole }: TransformRegexOptions): RegExp;
+export declare function transformRegex(value: RegexInput, { flags, accentInsensitive, caseInsensitive, matchWhole }?: TransformRegexOptions): RegExp;
 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 zodValidate<O>(p: ZodSchema<O>): ZodValidator<O>;
 export declare function zodValidateWithErrors<O>(p: ZodSchema<O>): ZodValidatorWithErrors<O>;
 export declare function isAlphanumeric(str: string): boolean;

package/dist/index.js

@@ -9,6 +9,7 @@ exports.regexMatchWhole = regexMatchWhole;
 exports.transformRegex = transformRegex;
 exports.isValidRegex = isValidRegex;
 exports.isValidRegexFlags = isValidRegexFlags;
+exports.interpretZodError = interpretZodError;
 exports.zodValidate = zodValidate;
 exports.zodValidateWithErrors = zodValidateWithErrors;
 exports.isAlphanumeric = isAlphanumeric;
@@ -82,7 +83,7 @@ function regexMatchWhole(value, flags = "") {
         return regexMatchWhole(value.source, combineFlags(value.flags, flags));
     }
 }
-function transformRegex(value, { flags = "", accentInsensitive = false, caseInsensitive = false, matchWhole = false }) {
+function transformRegex(value, { flags = "", accentInsensitive = false, caseInsensitive = false, matchWhole = false } = {}) {
     if (accentInsensitive)
         value = regexAccentInsensitive(value, flags);
     if (caseInsensitive)
@@ -109,6 +110,14 @@ function isValidRegex(value, flags = "") {
 function isValidRegexFlags(value) {
     return /^[gimsuy]*$/.test(value);
 }
+function interpretZodError(e) {
+    const { errors } = e;
+    if (errors.length === 0)
+        return null;
+    if (errors.length === 1)
+        return e.errors[0].message;
+    return errors.map((e) => e.message);
+}
 function zodValidate(p) {
     return (v) => {
         const result = p.safeParse(v);
@@ -120,9 +129,7 @@ function zodValidateWithErrors(p) {
         const result = p.safeParse(v);
         if (result.success)
             return true;
-        if (result.error.errors.length === 1)
-            return result.error.errors[0].message;
-        return result.error.errors.map((e) => e.message);
+        return interpretZodError(result.error);
     };
 }
 const alphanumericPattern = /[\w_-]+/i;

package/package.json

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