@ptolemy2002/regex-utils 4.0.0 → 4.2.0

package/README.md

@@ -33,6 +33,16 @@ type ZodValidateWithErrorsOptions = {
     joinSeparator?: string;
     pathSeparator?: string;
 };
+
+type ArrayWithOptional<AR extends unknown[], AO extends unknown[]> = AR | [...AR, ...AO];
+type ZodGenericFactory<ZTA extends Array<ZodType<unknown>>=[ZodType], ZT extends ZodType=ZodType> =
+    <ZTAO extends ZTA>(...genericArgs: ZTAO) => (
+        <ZTO extends ZT>(
+            fn: (...args: ZTAO) => ZTO
+        ) => ZTO
+    )
+;
+type MaybeZodOptional<ZT extends ZodType> = ZT | ZodOptional<ZT>;
 ```
 
 ## Classes
@@ -259,6 +269,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>=[ZodType]>, 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, ZodOptional, ZodType } from "zod";
 export type RegexInput = string | RegExp;
 export declare function combineFlags(...flags: string[]): string;
 export declare function escapeRegex(value: RegexInput, flags?: string): RegExp;
@@ -74,3 +74,7 @@ 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>> = [ZodType], 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> = [ZodType], ZT extends ZodType = ZodType>(): ZodGenericFactory<ZTA, ZT>;
+export type MaybeZodOptional<ZT extends ZodType> = ZT | ZodOptional<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|Á|À|Ä|Â|Ã)",
@@ -215,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": "4.0.0",
+    "version": "4.2.0",
     "private": false,
     "main": "dist/index.js",
     "types": "dist/index.d.ts",