@ptolemy2002/regex-utils 3.0.0 → 4.1.0

package/README.md

@@ -33,6 +33,9 @@ type ZodValidateWithErrorsOptions = {
     joinSeparator?: string;
     pathSeparator?: string;
 };
+
+type ArrayWithOptional<AR extends unknown[], AO extends unknown[]> = AR | [...AR, ...AO];
+type ZodGenericFactory<ZTA extends Array<ZodType<unknown>>, ZT extends ZodType=ZodType> = <ZTAO extends ZTA>(...genericArgs: ZTAO) => <ZTO extends ZT>(fn: (...args: ZTAO) => ZTO) => ZTO;
 ```
 
 ## Classes
@@ -163,7 +166,7 @@ Checks if an unknown value is a ZodError. This is more reliable than using `inst
 
 ### 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>`. 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.
+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>`.
 
 #### Parameters
 - `e` (`ZodError`): The zod error to be interpreted.
@@ -259,6 +262,58 @@ Uses `zodValidate` to check if a string is a valid Social Security Number (SSN).
 #### Returns
 `boolean` - `true` if the string is a valid SSN, `false` otherwise.
 
+### zodGenericFactory<ZTA extends Array<ZodType<unknown>>, ZT extends ZodType=ZodType>
+
+#### Description
+Creates a factory for building generic Zod schemas with reusable type parameters. This is useful when you want to create schema templates where certain types (like ID or name fields) can be customized while maintaining type safety.
+
+#### Type Parameters
+* `ZTA` - An array of ZodType schemas that will serve as the generic parameters
+* `ZT` - (Optional) The base type constraint for the resulting schema. Defaults to `ZodType`.
+
+#### Returns
+`ZodGenericFactory<ZTA, ZT>` - A factory function that:
+1. Takes the actual Zod schemas matching `ZTA`
+2. Returns a builder function that accepts an implementation function.
+3. The implementation receives the schemas as typed arguments and returns the final schema
+
+#### Example
+```typescript
+// Create a factory for object schemas with customizable id and name types
+const genericFactory = zodGenericFactory<
+  // Here, the second type parameter is optional.
+  ArrayWithOptional<[ZodNumber | ZodUUID], [ZodString]>,
+  // An object schema with id and name fields of any type
+  ZodObject<{ id: ZodType; name: ZodType }>
+>();
+
+// Apply specific schemas
+const template1 = genericFactory(z.number().min(0), z.string());
+
+// Define the final schema structure
+// Since the template provides the second parameter, it will be available in the function
+const schema1 = template1((idSchema, nameSchema) => {
+  return z.object({
+    id: idSchema,
+    name: nameSchema
+  });
+});
+
+// Now `schema1` is typed as z.object({ id: ZodNumber, name: ZodString })
+
+// We omit the second parameter, meaning the function will not have a nameSchema argument
+// and detect that it can only be provided with `ZodUUID` for the idSchema
+const template2 = genericFactory(z.uuid());
+const schema2 = template2((idSchema) => {
+  return z.object({
+    id: idSchema,
+    name: z.string()
+  });
+});
+
+// Now `schema2` is typed as z.object({ id: ZodUUID, name: ZodString })
+```
+
 ## Schemas
 The following schemas are available in the library:
 

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { z, ZodError } from "zod";
+import { z, ZodError, ZodType } from "zod";
 export type RegexInput = string | RegExp;
 export declare function combineFlags(...flags: string[]): string;
 export declare function escapeRegex(value: RegexInput, flags?: string): RegExp;
@@ -24,7 +24,7 @@ export type InterpretZodErrorOptions = {
 };
 export declare function interpretZodError(e: ZodError, { prefix, separator }?: InterpretZodErrorOptions): string | string[] | null;
 export type ZodSafeParseable<O> = {
-    safeParse: (v: unknown) => z.SafeParseReturnType<unknown, O>;
+    safeParse: (v: unknown) => z.ZodSafeParseResult<O>;
 };
 export declare function zodValidate<O>(p: ZodSafeParseable<O>): ZodValidator<O>;
 export type ZodValidateWithErrorsOptions = {
@@ -74,3 +74,6 @@ export declare const ZodCoercedBoolean: z.ZodPipe<z.ZodEnum<{
     on: "on";
     off: "off";
 }>, z.ZodTransform<boolean, "0" | "1" | "true" | "false" | "t" | "f" | "yes" | "no" | "y" | "n" | "on" | "off">>;
+export type ArrayWithOptional<AR extends unknown[], AO extends unknown[]> = AR | [...AR, ...AO];
+export type ZodGenericFactory<ZTA extends Array<ZodType<unknown>>, ZT extends ZodType = ZodType> = <ZTAO extends ZTA>(...genericArgs: ZTAO) => <ZTO extends ZT>(fn: (...args: ZTAO) => ZTO) => ZTO;
+export declare function zodGenericFactory<ZTA extends Array<ZodType<unknown>>, ZT extends ZodType = ZodType>(): ZodGenericFactory<ZTA, ZT>;

package/dist/index.js

@@ -20,6 +20,7 @@ exports.isValidEmail = isValidEmail;
 exports.isValidURL = isValidURL;
 exports.isValidPhoneNumber = isValidPhoneNumber;
 exports.isValidSSN = isValidSSN;
+exports.zodGenericFactory = zodGenericFactory;
 const zod_1 = require("zod");
 const accentPatterns = [
     "(a|á|à|ä|â|ã)", "(A|Á|À|Ä|Â|Ã)",
@@ -116,7 +117,7 @@ function isZodError(err) {
     return Boolean(err && (err instanceof zod_1.ZodError || err.name === 'ZodError'));
 }
 function interpretZodError(e, { prefix, separator = "." } = {}) {
-    const { errors } = e;
+    const { issues } = e;
     function formatIssue(issue) {
         const { code, path: _path, message } = issue;
         let path = _path;
@@ -126,25 +127,15 @@ function interpretZodError(e, { prefix, separator = "." } = {}) {
         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(separator)}: ${message}`;
     }
-    if (errors.length === 0)
+    if (issues.length === 0)
         return null;
-    if (errors.length === 1)
-        return formatIssue(errors[0]);
-    return errors.map((e) => formatIssue(e));
+    if (issues.length === 1)
+        return formatIssue(issues[0]);
+    return issues.map((e) => formatIssue(e));
 }
 function zodValidate(p) {
     return (v) => {
@@ -225,3 +216,6 @@ exports.ZodCoercedBoolean = exports.ZodCoercedBooleanEnum.transform((val) => {
             return false;
     }
 });
+function zodGenericFactory() {
+    return (...genericArgs) => (fn) => fn(...genericArgs);
+}

package/package.json

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