codpro-validator 1.0.0

package/README.md

@@ -0,0 +1,282 @@
+# codpro-validator
+
+🚀 A lightweight, powerful and flexible React validation hook.
+
+Built for developers who want full control without heavy form libraries.
+
+---
+
+## ✨ Features
+
+- Lightweight & zero external dependencies
+- Custom validation rules
+- Cross-field validation (match passwords)
+- Multiple validation modes
+  - `onSubmit`
+  - `onBlur`
+  - `onChange`
+- `isDirty` tracking
+- `touchedFields` tracking
+- `isSubmitting` state
+- `isValid` state
+- `reset()` support
+- Async submit support
+- Fully extensible
+- TypeScript friendly
+
+---
+
+## 📦 Installation
+
+```bash
+npm install codpro-validator
+```
+
+or
+
+```bash
+yarn add codpro-validator
+```
+
+---
+
+## 🚀 Basic Usage
+
+```js
+import {
+  useValidator,
+  required,
+  email,
+  min,
+  match
+} from "codpro-validator"
+
+function RegisterForm() {
+  const {
+    register,
+    handleSubmit,
+    errors,
+    isDirty,
+    isSubmitting,
+    isValid,
+    touchedFields,
+    reset
+  } = useValidator(
+    {
+      email: {
+        rules: [required(), email()]
+      },
+      password: {
+        rules: [required(), min(6)]
+      },
+      confirmPassword: {
+        rules: [
+          required(),
+          match("password", "Passwords must match")
+        ]
+      }
+    },
+    { mode: "onSubmit" }
+  )
+
+  const onSubmit = async (data) => {
+    await new Promise((r) => setTimeout(r, 1000))
+    console.log(data)
+    reset()
+  }
+
+  return (
+    <form onSubmit={handleSubmit(onSubmit)}>
+      <input {...register("email")} placeholder="Email" />
+      {errors.email && <p>{errors.email}</p>}
+
+      <input type="password" {...register("password")} placeholder="Password" />
+      {errors.password && <p>{errors.password}</p>}
+
+      <input type="password" {...register("confirmPassword")} placeholder="Confirm Password" />
+      {errors.confirmPassword && <p>{errors.confirmPassword}</p>}
+
+      <button disabled={!isDirty || isSubmitting}>
+        {isSubmitting ? "Submitting..." : "Submit"}
+      </button>
+    </form>
+  )
+}
+```
+
+---
+
+## 🧠 Validation Modes
+
+### onSubmit (Default)
+
+Validation runs when form is submitted.
+
+```js
+useValidator(schema, { mode: "onSubmit" })
+```
+
+---
+
+### onBlur
+
+Validation runs when input loses focus.
+
+```js
+useValidator(schema, { mode: "onBlur" })
+```
+
+---
+
+### onChange
+
+Validation runs on every keystroke.
+
+```js
+useValidator(schema, { mode: "onChange" })
+```
+
+---
+
+## 📘 API
+
+### useValidator(schema, options)
+
+#### Parameters
+
+| Name    | Type   | Description |
+|---------|--------|------------|
+| schema  | object | Validation schema |
+| options | object | Config options |
+
+---
+
+### Returned Properties
+
+| Property        | Description |
+|----------------|------------|
+| register        | Connect input field |
+| handleSubmit    | Wrap submit handler |
+| errors          | Validation errors |
+| isDirty         | True if any field changed |
+| isSubmitting    | True during submit |
+| touchedFields   | Tracks touched inputs |
+| isValid         | True if no errors |
+| reset           | Reset form |
+
+---
+
+## 🛠 Built-in Validators
+
+### required(message?)
+
+```js
+required("This field is required")
+```
+
+---
+
+### email(message?)
+
+```js
+email("Invalid email address")
+```
+
+---
+
+### min(length, message?)
+
+```js
+min(6, "Minimum 6 characters required")
+```
+
+---
+
+### max(length, message?)
+
+```js
+max(20, "Maximum 20 characters allowed")
+```
+
+---
+
+### match(fieldName, message?)
+
+```js
+match("password", "Passwords must match")
+```
+
+---
+
+## 🔁 Reset Form
+
+```js
+reset()
+```
+
+Resets form back to initial values.
+
+---
+
+## 🧩 Example Project Structure
+
+```
+src/
+ ├── guards/
+ │    ├── required.js
+ │    ├── email.js
+ │    ├── min.js
+ │    ├── max.js
+ │    └── match.js
+ │
+ ├── hooks/
+ │    └── useValidator.js
+ │
+ └── index.js
+```
+
+---
+
+## 🔥 Why codpro-validator?
+
+- Smaller than heavy form libraries
+- Easy to understand
+- Fully customizable
+- Great for learning & production
+- Clean API design
+
+---
+
+## 🗺 Roadmap
+
+- Async validation rules
+- Debounced validation
+- Nested object validation
+- Field arrays support
+- DevTools integration
+
+---
+
+## 🏷 Keywords
+
+react validation hook, react form validation, lightweight form library, custom validation, react validator hook, form state management
+
+---
+
+## 📄 License
+
+MIT © CodPro Sui
+
+---
+
+## ⭐ Support
+
+If you like this project:
+
+- Star the repository
+- Share it with developers
+- Contribute improvements
+
+---
+
+Built with ❤️ by CodPro Sui

package/dist/index.cjs

@@ -0,0 +1,212 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.js
+var index_exports = {};
+__export(index_exports, {
+  default: () => index_default,
+  email: () => email_default,
+  match: () => match_default,
+  max: () => max_default,
+  min: () => min_default,
+  password: () => password_default,
+  required: () => required_default,
+  useValidator: () => useValidator_default
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/guards/email.js
+var email = (reg, mess = "Invalid email") => {
+  return (value) => {
+    if (!value || value.trim() === "admin@gmail.com") return mess;
+    let regex = /^[a-zA-Z0-9._%+-]+@[a-zA-Z.-]{2,}\.[a-zA-Z]{2,}$/;
+    if (reg) {
+      regex = reg;
+    }
+    return regex.test(value) ? null : mess;
+  };
+};
+var email_default = email;
+
+// src/guards/match.js
+var match = (fieldName, mess = "No Match!") => {
+  return (value, values) => {
+    return value === values[fieldName] ? null : mess;
+  };
+};
+var match_default = match;
+
+// src/guards/max.js
+var max = (length, mess) => {
+  return (value) => {
+    if (!value.trim() || typeof value !== "string") return null;
+    if (value.trim().length > length) {
+      return mess || `The size must be less than ${length}`;
+    }
+    return null;
+  };
+};
+var max_default = max;
+
+// src/guards/min.js
+var min = (length, mess) => {
+  return (value) => {
+    if (!value || typeof value !== "string") return null;
+    if (value.trim().length < length)
+      return mess || `The size must be at least ${length}`;
+    return null;
+  };
+};
+var min_default = min;
+
+// src/guards/password.js
+var password = (regex, mess = "Password must include at least one uppercase letter, one lowercase letter, one number, one special character (@$!%*?&) and be at least 8 characters long.") => {
+  return (value) => {
+    if (!value || typeof value !== "string") return null;
+    let reg = regex || /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,}$/;
+    return reg.test(value.trim()) ? null : mess;
+  };
+};
+var password_default = password;
+
+// src/guards/required.js
+var required = (mess = "This is required") => {
+  return (value) => {
+    if (typeof value === "string" && value.trim() === "" || value === null || value === void 0)
+      return mess;
+    return null;
+  };
+};
+var required_default = required;
+
+// src/hooks/useValidator.js
+var import_react = require("react");
+
+// src/engine/runRules.js
+var runRules = async (value, rules = [], values = {}) => {
+  for (let rule of rules) {
+    let res = await rule(value, values);
+    if (res) return res;
+  }
+  return null;
+};
+var runRules_default = runRules;
+
+// src/hooks/useValidator.js
+var useValidator = (schema = {}, options = {}) => {
+  const [values, setValues] = (0, import_react.useState)({});
+  const [errors, setErrors] = (0, import_react.useState)({});
+  const [isSubmitting, setIsSubmitting] = (0, import_react.useState)(false);
+  const [touch, setTouch] = (0, import_react.useState)({});
+  const [isDirty, setIsDirty] = (0, import_react.useState)({});
+  let mode = options.mode || "onSubmit";
+  for (let field in schema) {
+    setIsDirty((pre) => ({ ...pre, [field]: "" }));
+  }
+  const register = (name) => {
+    if (typeof name !== "string") {
+      console.warn("In the register must be a string");
+      return {};
+    }
+    let config = schema[name] || {};
+    return {
+      name,
+      value: values[name] || "",
+      disabled: config.disabled || false,
+      onChange: async (e) => {
+        setValues((pre) => ({ ...pre, [name]: e.target.value }));
+        setIsDirty((pre) => ({ ...pre, [name]: e.target.value !== isDirty[name] }));
+        if (mode === "onChange") {
+          let res = await runRules_default(e.target.value, config.rules, values);
+          setErrors((pre) => ({ ...pre, [name]: res }));
+        }
+      },
+      onBlur: async () => {
+        setTouch((pre) => ({ ...pre, [name]: true }));
+        if (mode === "onBlur") {
+          let res = await runRules_default(values[name], config.rules, values);
+          setErrors((pre) => ({ ...pre, [name]: res }));
+        }
+      }
+    };
+  };
+  async function isValid() {
+    let error = {};
+    for (let field in schema) {
+      let config = schema[field];
+      if (config.disabled) continue;
+      let res = await runRules_default(values[field], config.rules, values);
+      if (res) error[field] = res;
+    }
+    setErrors(error);
+    return Object.keys(error).length === 0;
+  }
+  ;
+  const handleSubmit = (onSuccess, onError = () => {
+  }) => {
+    return async (e) => {
+      e.preventDefault();
+      setIsSubmitting(true);
+      try {
+        const valid = await isValid();
+        if (!valid) {
+          onError(errors);
+          return;
+        }
+        await onSuccess(values);
+      } catch (err) {
+        console.error("Submit Error:", err);
+      } finally {
+        setIsSubmitting(false);
+      }
+    };
+  };
+  const reset = () => {
+    let resetObj = {};
+    for (let field in schema) {
+      resetObj[field] = "";
+    }
+    setValues(resetObj);
+    setErrors({});
+  };
+  return {
+    values,
+    errors,
+    register,
+    isValid,
+    handleSubmit,
+    reset,
+    isSubmitting,
+    isDirty,
+    touch
+  };
+};
+var useValidator_default = useValidator;
+
+// src/index.js
+var index_default = useValidator_default;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  email,
+  match,
+  max,
+  min,
+  password,
+  required,
+  useValidator
+});

package/dist/index.d.cts

@@ -0,0 +1,177 @@
+import { useState } from 'react';
+
+const email = (reg, mess = "Invalid email") => {
+  return (value) => {
+    if (!value || value.trim() === "admin@gmail.com") return mess;
+    let regex = /^[a-zA-Z0-9._%+-]+@[a-zA-Z.-]{2,}\.[a-zA-Z]{2,}$/;
+    if (reg) {
+      regex = reg;
+    }
+    return regex.test(value) ? null : mess;
+  };
+};
+
+const match = (fieldName,mess="No Match!") =>{
+    return (value,values) =>{
+        return value === values[fieldName]?null:mess;
+    }
+};
+
+const max = (length, mess) => {
+  return (value) => {
+    if (!value.trim() || typeof value !== "string") return null;
+    if (value.trim().length > length) {
+      return mess || `The size must be less than ${length}`;
+    }
+    return null;
+  };
+};
+
+const min = (length, mess) => {
+  return (value) => {
+    if (!value || typeof value !== "string") return null;
+    if (value.trim().length < length)
+      return mess || `The size must be at least ${length}`;
+    return null;
+  };
+};
+
+const password = (
+  regex,
+  mess = "Password must include at least one uppercase letter, one lowercase letter, one number, one special character (@$!%*?&) and be at least 8 characters long.",
+) => {
+  return (value) => {
+    if (!value || typeof value !== "string") return null;
+    let reg = regex || /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,}$/;
+
+    return reg.test(value.trim()) ? null : mess;
+  };
+};
+
+const required = (mess = "This is required") => {
+  return (value) => {
+    if ((typeof value === "string" && value.trim() === "") || value === null || value === undefined)
+      return mess;
+    return null;
+  };
+};
+
+const runRules = async (value,rules = [],values = {}) =>{
+    for(let rule of rules){
+        let res = await rule(value,values);
+        if(res) return res;
+    }
+    return null
+};
+
+const useValidator = (schema = {}, options = {}) => {
+  const [values, setValues] = useState({});
+  const [errors, setErrors] = useState({});
+  const [isSubmitting,setIsSubmitting] = useState(false);
+ const [touch, setTouch] = useState({});
+ const [isDirty,setIsDirty] = useState({});
+  //define default
+  let mode = options.mode || "onSubmit"; // onSubmit, onBlur, onChange
+  
+  //dirty
+  for(let field in schema){
+    setIsDirty(pre => ({...pre,[field]: ""}));
+  }
+  
+  // register for input
+  const register = (name) => {
+    if (typeof name !== "string") {
+      console.warn("In the register must be a string");
+      return {};
+    }
+    let config = schema[name] || {};
+    return {
+      name,
+      value: values[name] || "",
+      disabled: config.disabled || false,
+      onChange: async (e) => {
+        setValues((pre) => ({ ...pre, [name]: e.target.value }));
+        
+        //dirty field
+        setIsDirty(pre => ({...pre,[name]:e.target.value !== isDirty[name]}));
+
+        if (mode === "onChange") {
+          let res = await runRules(e.target.value, config.rules,values);
+          setErrors((pre) => ({ ...pre, [name]: res }));
+        }
+      },
+      onBlur: async () => {
+        setTouch(pre => ({...pre,[name]:true}));
+        if (mode === "onBlur") {
+          let res = await runRules(values[name], config.rules,values);
+          setErrors((pre) => ({ ...pre, [name]: res }));
+        }
+      },
+    };
+  };
+
+  //checker
+    async function isValid(){
+    let error = {};
+    for (let field in schema) {
+      let config = schema[field];
+      if (config.disabled) continue;
+      let res = await runRules(values[field], config.rules,values);
+      if (res) error[field] = res;
+    }
+    setErrors(error);
+    return Object.keys(error).length === 0;
+  }
+  //submit data
+  
+  const handleSubmit = (onSuccess, onError = () => {}) => {
+  return async (e) => {
+    e.preventDefault();
+
+    setIsSubmitting(true);
+
+    try {
+      const valid = await isValid();
+
+      if (!valid) {
+        onError(errors);
+        return;
+      }
+
+      await onSuccess(values);
+
+    } catch (err) {
+      console.error("Submit Error:", err);
+    } finally {
+      setIsSubmitting(false);
+    }
+  };
+};
+  
+  //reset data
+
+  const reset = () => {
+    let resetObj = {};
+    for(let field in schema){
+      resetObj[field] = "";
+    }
+    setValues(resetObj);
+    setErrors({});
+  };
+
+
+
+  return {
+    values,
+    errors,
+    register,
+    isValid,
+    handleSubmit,
+    reset,
+    isSubmitting,
+    isDirty,
+    touch
+  };
+};
+
+export { useValidator as default, email, match, max, min, password, required, useValidator };

package/dist/index.d.ts

@@ -0,0 +1,177 @@
+import { useState } from 'react';
+
+const email = (reg, mess = "Invalid email") => {
+  return (value) => {
+    if (!value || value.trim() === "admin@gmail.com") return mess;
+    let regex = /^[a-zA-Z0-9._%+-]+@[a-zA-Z.-]{2,}\.[a-zA-Z]{2,}$/;
+    if (reg) {
+      regex = reg;
+    }
+    return regex.test(value) ? null : mess;
+  };
+};
+
+const match = (fieldName,mess="No Match!") =>{
+    return (value,values) =>{
+        return value === values[fieldName]?null:mess;
+    }
+};
+
+const max = (length, mess) => {
+  return (value) => {
+    if (!value.trim() || typeof value !== "string") return null;
+    if (value.trim().length > length) {
+      return mess || `The size must be less than ${length}`;
+    }
+    return null;
+  };
+};
+
+const min = (length, mess) => {
+  return (value) => {
+    if (!value || typeof value !== "string") return null;
+    if (value.trim().length < length)
+      return mess || `The size must be at least ${length}`;
+    return null;
+  };
+};
+
+const password = (
+  regex,
+  mess = "Password must include at least one uppercase letter, one lowercase letter, one number, one special character (@$!%*?&) and be at least 8 characters long.",
+) => {
+  return (value) => {
+    if (!value || typeof value !== "string") return null;
+    let reg = regex || /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,}$/;
+
+    return reg.test(value.trim()) ? null : mess;
+  };
+};
+
+const required = (mess = "This is required") => {
+  return (value) => {
+    if ((typeof value === "string" && value.trim() === "") || value === null || value === undefined)
+      return mess;
+    return null;
+  };
+};
+
+const runRules = async (value,rules = [],values = {}) =>{
+    for(let rule of rules){
+        let res = await rule(value,values);
+        if(res) return res;
+    }
+    return null
+};
+
+const useValidator = (schema = {}, options = {}) => {
+  const [values, setValues] = useState({});
+  const [errors, setErrors] = useState({});
+  const [isSubmitting,setIsSubmitting] = useState(false);
+ const [touch, setTouch] = useState({});
+ const [isDirty,setIsDirty] = useState({});
+  //define default
+  let mode = options.mode || "onSubmit"; // onSubmit, onBlur, onChange
+  
+  //dirty
+  for(let field in schema){
+    setIsDirty(pre => ({...pre,[field]: ""}));
+  }
+  
+  // register for input
+  const register = (name) => {
+    if (typeof name !== "string") {
+      console.warn("In the register must be a string");
+      return {};
+    }
+    let config = schema[name] || {};
+    return {
+      name,
+      value: values[name] || "",
+      disabled: config.disabled || false,
+      onChange: async (e) => {
+        setValues((pre) => ({ ...pre, [name]: e.target.value }));
+        
+        //dirty field
+        setIsDirty(pre => ({...pre,[name]:e.target.value !== isDirty[name]}));
+
+        if (mode === "onChange") {
+          let res = await runRules(e.target.value, config.rules,values);
+          setErrors((pre) => ({ ...pre, [name]: res }));
+        }
+      },
+      onBlur: async () => {
+        setTouch(pre => ({...pre,[name]:true}));
+        if (mode === "onBlur") {
+          let res = await runRules(values[name], config.rules,values);
+          setErrors((pre) => ({ ...pre, [name]: res }));
+        }
+      },
+    };
+  };
+
+  //checker
+    async function isValid(){
+    let error = {};
+    for (let field in schema) {
+      let config = schema[field];
+      if (config.disabled) continue;
+      let res = await runRules(values[field], config.rules,values);
+      if (res) error[field] = res;
+    }
+    setErrors(error);
+    return Object.keys(error).length === 0;
+  }
+  //submit data
+  
+  const handleSubmit = (onSuccess, onError = () => {}) => {
+  return async (e) => {
+    e.preventDefault();
+
+    setIsSubmitting(true);
+
+    try {
+      const valid = await isValid();
+
+      if (!valid) {
+        onError(errors);
+        return;
+      }
+
+      await onSuccess(values);
+
+    } catch (err) {
+      console.error("Submit Error:", err);
+    } finally {
+      setIsSubmitting(false);
+    }
+  };
+};
+  
+  //reset data
+
+  const reset = () => {
+    let resetObj = {};
+    for(let field in schema){
+      resetObj[field] = "";
+    }
+    setValues(resetObj);
+    setErrors({});
+  };
+
+
+
+  return {
+    values,
+    errors,
+    register,
+    isValid,
+    handleSubmit,
+    reset,
+    isSubmitting,
+    isDirty,
+    touch
+  };
+};
+
+export { useValidator as default, email, match, max, min, password, required, useValidator };

package/dist/index.js

@@ -0,0 +1,180 @@
+// src/guards/email.js
+var email = (reg, mess = "Invalid email") => {
+  return (value) => {
+    if (!value || value.trim() === "admin@gmail.com") return mess;
+    let regex = /^[a-zA-Z0-9._%+-]+@[a-zA-Z.-]{2,}\.[a-zA-Z]{2,}$/;
+    if (reg) {
+      regex = reg;
+    }
+    return regex.test(value) ? null : mess;
+  };
+};
+var email_default = email;
+
+// src/guards/match.js
+var match = (fieldName, mess = "No Match!") => {
+  return (value, values) => {
+    return value === values[fieldName] ? null : mess;
+  };
+};
+var match_default = match;
+
+// src/guards/max.js
+var max = (length, mess) => {
+  return (value) => {
+    if (!value.trim() || typeof value !== "string") return null;
+    if (value.trim().length > length) {
+      return mess || `The size must be less than ${length}`;
+    }
+    return null;
+  };
+};
+var max_default = max;
+
+// src/guards/min.js
+var min = (length, mess) => {
+  return (value) => {
+    if (!value || typeof value !== "string") return null;
+    if (value.trim().length < length)
+      return mess || `The size must be at least ${length}`;
+    return null;
+  };
+};
+var min_default = min;
+
+// src/guards/password.js
+var password = (regex, mess = "Password must include at least one uppercase letter, one lowercase letter, one number, one special character (@$!%*?&) and be at least 8 characters long.") => {
+  return (value) => {
+    if (!value || typeof value !== "string") return null;
+    let reg = regex || /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,}$/;
+    return reg.test(value.trim()) ? null : mess;
+  };
+};
+var password_default = password;
+
+// src/guards/required.js
+var required = (mess = "This is required") => {
+  return (value) => {
+    if (typeof value === "string" && value.trim() === "" || value === null || value === void 0)
+      return mess;
+    return null;
+  };
+};
+var required_default = required;
+
+// src/hooks/useValidator.js
+import { useRef, useState } from "react";
+
+// src/engine/runRules.js
+var runRules = async (value, rules = [], values = {}) => {
+  for (let rule of rules) {
+    let res = await rule(value, values);
+    if (res) return res;
+  }
+  return null;
+};
+var runRules_default = runRules;
+
+// src/hooks/useValidator.js
+var useValidator = (schema = {}, options = {}) => {
+  const [values, setValues] = useState({});
+  const [errors, setErrors] = useState({});
+  const [isSubmitting, setIsSubmitting] = useState(false);
+  const [touch, setTouch] = useState({});
+  const [isDirty, setIsDirty] = useState({});
+  let mode = options.mode || "onSubmit";
+  for (let field in schema) {
+    setIsDirty((pre) => ({ ...pre, [field]: "" }));
+  }
+  const register = (name) => {
+    if (typeof name !== "string") {
+      console.warn("In the register must be a string");
+      return {};
+    }
+    let config = schema[name] || {};
+    return {
+      name,
+      value: values[name] || "",
+      disabled: config.disabled || false,
+      onChange: async (e) => {
+        setValues((pre) => ({ ...pre, [name]: e.target.value }));
+        setIsDirty((pre) => ({ ...pre, [name]: e.target.value !== isDirty[name] }));
+        if (mode === "onChange") {
+          let res = await runRules_default(e.target.value, config.rules, values);
+          setErrors((pre) => ({ ...pre, [name]: res }));
+        }
+      },
+      onBlur: async () => {
+        setTouch((pre) => ({ ...pre, [name]: true }));
+        if (mode === "onBlur") {
+          let res = await runRules_default(values[name], config.rules, values);
+          setErrors((pre) => ({ ...pre, [name]: res }));
+        }
+      }
+    };
+  };
+  async function isValid() {
+    let error = {};
+    for (let field in schema) {
+      let config = schema[field];
+      if (config.disabled) continue;
+      let res = await runRules_default(values[field], config.rules, values);
+      if (res) error[field] = res;
+    }
+    setErrors(error);
+    return Object.keys(error).length === 0;
+  }
+  ;
+  const handleSubmit = (onSuccess, onError = () => {
+  }) => {
+    return async (e) => {
+      e.preventDefault();
+      setIsSubmitting(true);
+      try {
+        const valid = await isValid();
+        if (!valid) {
+          onError(errors);
+          return;
+        }
+        await onSuccess(values);
+      } catch (err) {
+        console.error("Submit Error:", err);
+      } finally {
+        setIsSubmitting(false);
+      }
+    };
+  };
+  const reset = () => {
+    let resetObj = {};
+    for (let field in schema) {
+      resetObj[field] = "";
+    }
+    setValues(resetObj);
+    setErrors({});
+  };
+  return {
+    values,
+    errors,
+    register,
+    isValid,
+    handleSubmit,
+    reset,
+    isSubmitting,
+    isDirty,
+    touch
+  };
+};
+var useValidator_default = useValidator;
+
+// src/index.js
+var index_default = useValidator_default;
+export {
+  index_default as default,
+  email_default as email,
+  match_default as match,
+  max_default as max,
+  min_default as min,
+  password_default as password,
+  required_default as required,
+  useValidator_default as useValidator
+};

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "codpro-validator",
+  "version": "1.0.0",
+  "description": "A lightweight, flexible React validation hook with cross-field validation and powerful rule engine",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "dist/index.d.ts",
+  "type": "module",
+
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+
+  "files": [
+    "dist"
+  ],
+
+  "sideEffects": false,
+
+  "scripts": {
+    "build": "tsup src/index.js --format esm,cjs --dts",
+    "dev": "tsup src/index.js --watch",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+
+  "keywords": [
+    "react",
+    "react-hook",
+    "form-validation",
+    "react-form",
+    "validation",
+    "react-validation",
+    "custom-hook",
+    "form-library",
+    "cross-field-validation",
+    "lightweight-form"
+  ],
+
+  "peerDependencies": {
+    "react": ">=18"
+  },
+  "repository": {
+  "type": "git",
+  "url": "https://github.com/CodPro-Sui/codpro-validator.git"
+},
+"homepage": "https://github.com/CodPro-Sui/codpro-validator#readme",
+
+  "author": "CodPro Sui",
+  "license": "MIT",
+
+  "devDependencies": {
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3"
+  }
+}