@stacksjs/stx 0.2.95 → 0.2.97

package/dist/forms-validation.js

@@ -1,4 +1,510 @@
-// @bun
-import"./chunk-xv34zbp4.js";class O{rules=[];defaultValue="";addRule(j){let k=new O;return k.rules=[...this.rules,j],k.defaultValue=this.defaultValue,k}required(j="This field is required"){return this.addRule({name:"required",message:j,validate:(k)=>{if(k===null||k===void 0)return j;if(typeof k==="string"&&k.trim()==="")return j;if(Array.isArray(k)&&k.length===0)return j;return!0}})}email(j="Please enter a valid email"){return this.addRule({name:"email",message:j,validate:(k)=>{if(!k)return!0;return/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(String(k))||j}})}url(j="Please enter a valid URL"){return this.addRule({name:"url",message:j,validate:(k)=>{if(!k)return!0;try{return new URL(String(k)),!0}catch{return j}}})}min(j,k){let q=k||`Must be at least ${j} characters`;return this.addRule({name:"min",message:q,validate:(z)=>{if(!z)return!0;return String(z).length>=j||q}})}max(j,k){let q=k||`Must be no more than ${j} characters`;return this.addRule({name:"max",message:q,validate:(z)=>{if(!z)return!0;return String(z).length<=j||q}})}length(j,k,q){let z=q||`Must be between ${j} and ${k} characters`;return this.addRule({name:"length",message:z,validate:(B)=>{if(!B)return!0;let G=String(B).length;return G>=j&&G<=k||z}})}pattern(j,k="Invalid format"){return this.addRule({name:"pattern",message:k,validate:(q)=>{if(!q)return!0;return j.test(String(q))||k}})}hasUppercase(j="Must contain an uppercase letter"){return this.pattern(/[A-Z]/,j)}hasLowercase(j="Must contain a lowercase letter"){return this.pattern(/[a-z]/,j)}hasNumber(j="Must contain a number"){return this.pattern(/\d/,j)}hasSpecial(j="Must contain a special character"){return this.pattern(/[!@#$%^&*(),.?":{}|<>]/,j)}alphanumeric(j="Only letters and numbers allowed"){return this.pattern(/^[a-zA-Z0-9]+$/,j)}startsWithLetter(j="Must start with a letter"){return this.pattern(/^[a-zA-Z]/,j)}noSpaces(j="Spaces are not allowed"){return this.addRule({name:"noSpaces",message:j,validate:(k)=>{if(!k)return!0;return!String(k).includes(" ")||j}})}number(j="Must be a number"){let k=this.addRule({name:"number",message:j,validate:(q)=>{if(!q&&q!==0)return!0;return!Number.isNaN(Number(q))||j}});return k.defaultValue=0,k}integer(j="Must be a whole number"){return this.addRule({name:"integer",message:j,validate:(k)=>{if(!k&&k!==0)return!0;return Number.isInteger(Number(k))||j}})}positive(j="Must be a positive number"){return this.addRule({name:"positive",message:j,validate:(k)=>{if(!k&&k!==0)return!0;return Number(k)>0||j}})}negative(j="Must be a negative number"){return this.addRule({name:"negative",message:j,validate:(k)=>{if(!k&&k!==0)return!0;return Number(k)<0||j}})}minValue(j,k){let q=k||`Must be at least ${j}`;return this.addRule({name:"minValue",message:q,validate:(z)=>{if(!z&&z!==0)return!0;return Number(z)>=j||q}})}maxValue(j,k){let q=k||`Must be no more than ${j}`;return this.addRule({name:"maxValue",message:q,validate:(z)=>{if(!z&&z!==0)return!0;return Number(z)<=j||q}})}between(j,k,q){let z=q||`Must be between ${j} and ${k}`;return this.addRule({name:"between",message:z,validate:(B)=>{if(!B&&B!==0)return!0;let G=Number(B);return G>=j&&G<=k||z}})}matches(j,k){let q=k||`Must match ${j}`;return this.addRule({name:"matches",message:q,validate:(z,B)=>{if(!B)return!0;return z===B[j]||q}})}oneOf(j,k){let q=k||`Must be one of: ${j.join(", ")}`;return this.addRule({name:"oneOf",message:q,validate:(z)=>{if(!z)return!0;return j.includes(z)||q}})}notOneOf(j,k){let q=k||`Cannot be one of: ${j.join(", ")}`;return this.addRule({name:"notOneOf",message:q,validate:(z)=>{if(!z)return!0;return!j.includes(z)||q}})}date(j="Must be a valid date"){return this.addRule({name:"date",message:j,validate:(k)=>{if(!k)return!0;let q=new Date(String(k));return!Number.isNaN(q.getTime())||j}})}before(j,k){let q=new Date(j),z=k||`Must be before ${q.toLocaleDateString()}`;return this.addRule({name:"before",message:z,validate:(B)=>{if(!B)return!0;return new Date(String(B))<q||z}})}after(j,k){let q=new Date(j),z=k||`Must be after ${q.toLocaleDateString()}`;return this.addRule({name:"after",message:z,validate:(B)=>{if(!B)return!0;return new Date(String(B))>q||z}})}custom(j,k="Invalid value"){return this.addRule({name:"custom",message:k,validate:j})}async(j,k="Invalid value"){return this.addRule({name:"async",message:k,async:!0,validate:j})}when(j,k){let q=new O;q.rules=[...this.rules],q.defaultValue=this.defaultValue;for(let z of k.getRules())q.rules.push({...z,validate:(B,G)=>{if(!j(B,G||{}))return!0;return z.validate(B,G)}});return q}getRules(){return this.rules}getDefaultValue(){return this.defaultValue}default(j){let k=new O;return k.rules=[...this.rules],k.defaultValue=j,k}async validate(j,k){let q=[];for(let z of this.rules){let B=await z.validate(j,k);if(B!==!0)q.push(B)}return q}validateSync(j,k){let q=[];for(let z of this.rules){if(z.async)continue;let B=z.validate(j,k);if(B!==!0)q.push(B)}return q}}var S=new O;function T(j,k){let q=Object.keys(j),z={},B={},G={},L={},M={};for(let A of q)z[A]=k?.[A]??j[A].getDefaultValue(),B[A]=[],G[A]=!1,L[A]=!1,M[A]=!1;let C=!1;async function I(A){M[A]=!0;let K=await j[A].validate(z[A],z);return B[A]=K,M[A]=!1,K.length===0}async function J(){C=!0;let A=await Promise.all(q.map(I));return C=!1,A.every(Boolean)}function Q(){for(let A of q)z[A]=k?.[A]??j[A].getDefaultValue(),B[A]=[],G[A]=!1,L[A]=!1}function U(A){for(let K of q)if(K in A)z[K]=A[K],L[K]=!0}function W(A,K){z[A]=K,L[A]=!0}function X(A,K=!0){if(G[A]=K,K)I(A)}function Y(A){return{value:z[A],errors:B[A],touched:G[A],dirty:L[A],valid:B[A].length===0,validating:M[A]}}function Z(A){return async(K)=>{K?.preventDefault?.();for(let _ of q)G[_]=!0;if(await J())await A(z)}}return{values:z,errors:B,touched:G,dirty:L,get isValid(){return q.every((A)=>B[A].length===0)},get isValidating(){return C||q.some((A)=>M[A])},get isDirty(){return q.some((A)=>L[A])},validate:J,validateField:I,reset:Q,setValues:U,setFieldValue:W,setFieldTouched:X,getFieldState:Y,handleSubmit:Z}}function $(j,k,q){let z=/@error\s*\(\s*([^)]+)\s*\)([\s\S]*?)@enderror/g;return j.replace(z,(B,G,L)=>{try{let M=G.trim().split("."),C=k;for(let J of M)if(C&&typeof C==="object"&&J in C)C=C[J];else return"";let I=C;if(!I||!Array.isArray(I)||I.length===0)return"";return I.map((J)=>{return L.replace(/\{\{\s*message\s*\}\}/g,J)}).join(`
-`)}catch{return""}})}function H(j,k,q){let z=/@errors\s*\(\s*([^)]+)\s*\)([\s\S]*?)@enderrors/g;return j.replace(z,(B,G,L)=>{try{let M=G.trim().split("."),C=k;for(let J of M)if(C&&typeof C==="object"&&J in C)C=C[J];else return"";let I=C;if(!I||!Array.isArray(I)||I.length===0)return"";return I.map((J)=>L.replace(/\{\{\s*message\s*\}\}/g,J)).join(`
-`)}catch{return""}})}function R(j,k,q){let z=/@hasErrors\s*\(\s*([^)]+)\s*\)([\s\S]*?)@endhasErrors/g;return j.replace(z,(B,G,L)=>{try{let M=G.trim().split("."),C=k;for(let J of M)if(C&&typeof C==="object"&&J in C)C=C[J];else return"";let I=C;if(!I||!Array.isArray(I)||I.length===0)return"";return L}catch{return""}})}function E(j,k,q){let z=j;return z=$(z,k,q),z=H(z,k,q),z=R(z,k,q),z}export{S as v,R as processHasErrorsDirective,E as processFormValidationDirectives,H as processErrorsDirective,$ as processErrorDirective,T as defineForm,O as Validator};
+class Validator {
+  rules = [];
+  defaultValue = "";
+  addRule(rule) {
+    const next = new Validator;
+    next.rules = [...this.rules, rule];
+    next.defaultValue = this.defaultValue;
+    return next;
+  }
+  required(message = "This field is required") {
+    return this.addRule({
+      name: "required",
+      message,
+      validate: (value) => {
+        if (value === null || value === void 0)
+          return message;
+        if (typeof value === "string" && value.trim() === "")
+          return message;
+        if (Array.isArray(value) && value.length === 0)
+          return message;
+        return !0;
+      }
+    });
+  }
+  email(message = "Please enter a valid email") {
+    return this.addRule({
+      name: "email",
+      message,
+      validate: (value) => {
+        if (!value)
+          return !0;
+        return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(String(value)) || message;
+      }
+    });
+  }
+  url(message = "Please enter a valid URL") {
+    return this.addRule({
+      name: "url",
+      message,
+      validate: (value) => {
+        if (!value)
+          return !0;
+        try {
+          new URL(String(value));
+          return !0;
+        } catch {
+          return message;
+        }
+      }
+    });
+  }
+  min(length, message) {
+    const msg = message || `Must be at least ${length} characters`;
+    return this.addRule({
+      name: "min",
+      message: msg,
+      validate: (value) => {
+        if (!value)
+          return !0;
+        return String(value).length >= length || msg;
+      }
+    });
+  }
+  max(length, message) {
+    const msg = message || `Must be no more than ${length} characters`;
+    return this.addRule({
+      name: "max",
+      message: msg,
+      validate: (value) => {
+        if (!value)
+          return !0;
+        return String(value).length <= length || msg;
+      }
+    });
+  }
+  length(min, max, message) {
+    const msg = message || `Must be between ${min} and ${max} characters`;
+    return this.addRule({
+      name: "length",
+      message: msg,
+      validate: (value) => {
+        if (!value)
+          return !0;
+        const len = String(value).length;
+        return len >= min && len <= max || msg;
+      }
+    });
+  }
+  pattern(regex, message = "Invalid format") {
+    return this.addRule({
+      name: "pattern",
+      message,
+      validate: (value) => {
+        if (!value)
+          return !0;
+        return regex.test(String(value)) || message;
+      }
+    });
+  }
+  hasUppercase(message = "Must contain an uppercase letter") {
+    return this.pattern(/[A-Z]/, message);
+  }
+  hasLowercase(message = "Must contain a lowercase letter") {
+    return this.pattern(/[a-z]/, message);
+  }
+  hasNumber(message = "Must contain a number") {
+    return this.pattern(/\d/, message);
+  }
+  hasSpecial(message = "Must contain a special character") {
+    return this.pattern(/[!@#$%^&*(),.?":{}|<>]/, message);
+  }
+  alphanumeric(message = "Only letters and numbers allowed") {
+    return this.pattern(/^[a-zA-Z0-9]+$/, message);
+  }
+  startsWithLetter(message = "Must start with a letter") {
+    return this.pattern(/^[a-zA-Z]/, message);
+  }
+  noSpaces(message = "Spaces are not allowed") {
+    return this.addRule({
+      name: "noSpaces",
+      message,
+      validate: (value) => {
+        if (!value)
+          return !0;
+        return !String(value).includes(" ") || message;
+      }
+    });
+  }
+  number(message = "Must be a number") {
+    const next = this.addRule({
+      name: "number",
+      message,
+      validate: (value) => {
+        if (!value && value !== 0)
+          return !0;
+        return !Number.isNaN(Number(value)) || message;
+      }
+    });
+    next.defaultValue = 0;
+    return next;
+  }
+  integer(message = "Must be a whole number") {
+    return this.addRule({
+      name: "integer",
+      message,
+      validate: (value) => {
+        if (!value && value !== 0)
+          return !0;
+        return Number.isInteger(Number(value)) || message;
+      }
+    });
+  }
+  positive(message = "Must be a positive number") {
+    return this.addRule({
+      name: "positive",
+      message,
+      validate: (value) => {
+        if (!value && value !== 0)
+          return !0;
+        return Number(value) > 0 || message;
+      }
+    });
+  }
+  negative(message = "Must be a negative number") {
+    return this.addRule({
+      name: "negative",
+      message,
+      validate: (value) => {
+        if (!value && value !== 0)
+          return !0;
+        return Number(value) < 0 || message;
+      }
+    });
+  }
+  minValue(min, message) {
+    const msg = message || `Must be at least ${min}`;
+    return this.addRule({
+      name: "minValue",
+      message: msg,
+      validate: (value) => {
+        if (!value && value !== 0)
+          return !0;
+        return Number(value) >= min || msg;
+      }
+    });
+  }
+  maxValue(max, message) {
+    const msg = message || `Must be no more than ${max}`;
+    return this.addRule({
+      name: "maxValue",
+      message: msg,
+      validate: (value) => {
+        if (!value && value !== 0)
+          return !0;
+        return Number(value) <= max || msg;
+      }
+    });
+  }
+  between(min, max, message) {
+    const msg = message || `Must be between ${min} and ${max}`;
+    return this.addRule({
+      name: "between",
+      message: msg,
+      validate: (value) => {
+        if (!value && value !== 0)
+          return !0;
+        const num = Number(value);
+        return num >= min && num <= max || msg;
+      }
+    });
+  }
+  matches(fieldName, message) {
+    const msg = message || `Must match ${fieldName}`;
+    return this.addRule({
+      name: "matches",
+      message: msg,
+      validate: (value, formValues) => {
+        if (!formValues)
+          return !0;
+        return value === formValues[fieldName] || msg;
+      }
+    });
+  }
+  oneOf(values, message) {
+    const msg = message || `Must be one of: ${values.join(", ")}`;
+    return this.addRule({
+      name: "oneOf",
+      message: msg,
+      validate: (value) => {
+        if (!value)
+          return !0;
+        return values.includes(value) || msg;
+      }
+    });
+  }
+  notOneOf(values, message) {
+    const msg = message || `Cannot be one of: ${values.join(", ")}`;
+    return this.addRule({
+      name: "notOneOf",
+      message: msg,
+      validate: (value) => {
+        if (!value)
+          return !0;
+        return !values.includes(value) || msg;
+      }
+    });
+  }
+  date(message = "Must be a valid date") {
+    return this.addRule({
+      name: "date",
+      message,
+      validate: (value) => {
+        if (!value)
+          return !0;
+        const date = new Date(String(value));
+        return !Number.isNaN(date.getTime()) || message;
+      }
+    });
+  }
+  before(date, message) {
+    const targetDate = new Date(date), msg = message || `Must be before ${targetDate.toLocaleDateString()}`;
+    return this.addRule({
+      name: "before",
+      message: msg,
+      validate: (value) => {
+        if (!value)
+          return !0;
+        return new Date(String(value)) < targetDate || msg;
+      }
+    });
+  }
+  after(date, message) {
+    const targetDate = new Date(date), msg = message || `Must be after ${targetDate.toLocaleDateString()}`;
+    return this.addRule({
+      name: "after",
+      message: msg,
+      validate: (value) => {
+        if (!value)
+          return !0;
+        return new Date(String(value)) > targetDate || msg;
+      }
+    });
+  }
+  custom(fn, message = "Invalid value") {
+    return this.addRule({
+      name: "custom",
+      message,
+      validate: fn
+    });
+  }
+  async(fn, message = "Invalid value") {
+    return this.addRule({
+      name: "async",
+      message,
+      async: !0,
+      validate: fn
+    });
+  }
+  when(condition, thenValidator) {
+    const next = new Validator;
+    next.rules = [...this.rules];
+    next.defaultValue = this.defaultValue;
+    for (const rule of thenValidator.getRules())
+      next.rules.push({
+        ...rule,
+        validate: (value, formValues) => {
+          if (!condition(value, formValues || {}))
+            return !0;
+          return rule.validate(value, formValues);
+        }
+      });
+    return next;
+  }
+  getRules() {
+    return this.rules;
+  }
+  getDefaultValue() {
+    return this.defaultValue;
+  }
+  default(value) {
+    const next = new Validator;
+    next.rules = [...this.rules];
+    next.defaultValue = value;
+    return next;
+  }
+  async validate(value, formValues) {
+    const errors = [];
+    for (const rule of this.rules) {
+      const result = await rule.validate(value, formValues);
+      if (result !== !0)
+        errors.push(result);
+    }
+    return errors;
+  }
+  validateSync(value, formValues) {
+    const errors = [];
+    for (const rule of this.rules) {
+      if (rule.async)
+        continue;
+      const result = rule.validate(value, formValues);
+      if (result !== !0)
+        errors.push(result);
+    }
+    return errors;
+  }
+}
+export const v = new Validator;
+export function defineForm(schema, initialValues) {
+  const fields = Object.keys(schema), values = {}, errors = {}, touched = {}, dirty = {}, validating = {};
+  for (const field of fields) {
+    values[field] = initialValues?.[field] ?? schema[field].getDefaultValue();
+    errors[field] = [];
+    touched[field] = !1;
+    dirty[field] = !1;
+    validating[field] = !1;
+  }
+  let isValidating = !1;
+  async function validateField(field) {
+    validating[field] = !0;
+    const fieldErrors = await schema[field].validate(values[field], values);
+    errors[field] = fieldErrors;
+    validating[field] = !1;
+    return fieldErrors.length === 0;
+  }
+  async function validate() {
+    isValidating = !0;
+    const results = await Promise.all(fields.map(validateField));
+    isValidating = !1;
+    return results.every(Boolean);
+  }
+  function reset() {
+    for (const field of fields) {
+      values[field] = initialValues?.[field] ?? schema[field].getDefaultValue();
+      errors[field] = [];
+      touched[field] = !1;
+      dirty[field] = !1;
+    }
+  }
+  function setValues(newValues) {
+    for (const field of fields)
+      if (field in newValues) {
+        values[field] = newValues[field];
+        dirty[field] = !0;
+      }
+  }
+  function setFieldValue(field, value) {
+    values[field] = value;
+    dirty[field] = !0;
+  }
+  function setFieldTouched(field, isTouched = !0) {
+    touched[field] = isTouched;
+    if (isTouched)
+      validateField(field);
+  }
+  function getFieldState(field) {
+    return {
+      value: values[field],
+      errors: errors[field],
+      touched: touched[field],
+      dirty: dirty[field],
+      valid: errors[field].length === 0,
+      validating: validating[field]
+    };
+  }
+  function handleSubmit(onSubmit) {
+    return async (e) => {
+      e?.preventDefault?.();
+      for (const field of fields)
+        touched[field] = !0;
+      if (await validate())
+        await onSubmit(values);
+    };
+  }
+  return {
+    values,
+    errors,
+    touched,
+    dirty,
+    get isValid() {
+      return fields.every((f) => errors[f].length === 0);
+    },
+    get isValidating() {
+      return isValidating || fields.some((f) => validating[f]);
+    },
+    get isDirty() {
+      return fields.some((f) => dirty[f]);
+    },
+    validate,
+    validateField,
+    reset,
+    setValues,
+    setFieldValue,
+    setFieldTouched,
+    getFieldState,
+    handleSubmit
+  };
+}
+export function processErrorDirective(content, context, _filePath) {
+  const errorRegex = /@error\s*\(\s*([^)]+)\s*\)([\s\S]*?)@enderror/g;
+  return content.replace(errorRegex, (_, fieldPath, body) => {
+    try {
+      const parts = fieldPath.trim().split(".");
+      let current = context;
+      for (const part of parts)
+        if (current && typeof current === "object" && part in current)
+          current = current[part];
+        else
+          return "";
+      const errors = current;
+      if (!errors || !Array.isArray(errors) || errors.length === 0)
+        return "";
+      return errors.map((message) => {
+        return body.replace(/\{\{\s*message\s*\}\}/g, message);
+      }).join(`
+`);
+    } catch {
+      return "";
+    }
+  });
+}
+export function processErrorsDirective(content, context, _filePath) {
+  const errorsRegex = /@errors\s*\(\s*([^)]+)\s*\)([\s\S]*?)@enderrors/g;
+  return content.replace(errorsRegex, (_, fieldPath, body) => {
+    try {
+      const parts = fieldPath.trim().split(".");
+      let current = context;
+      for (const part of parts)
+        if (current && typeof current === "object" && part in current)
+          current = current[part];
+        else
+          return "";
+      const errors = current;
+      if (!errors || !Array.isArray(errors) || errors.length === 0)
+        return "";
+      return errors.map((message) => body.replace(/\{\{\s*message\s*\}\}/g, message)).join(`
+`);
+    } catch {
+      return "";
+    }
+  });
+}
+export function processHasErrorsDirective(content, context, _filePath) {
+  const hasErrorsRegex = /@hasErrors\s*\(\s*([^)]+)\s*\)([\s\S]*?)@endhasErrors/g;
+  return content.replace(hasErrorsRegex, (_, fieldPath, body) => {
+    try {
+      const parts = fieldPath.trim().split(".");
+      let current = context;
+      for (const part of parts)
+        if (current && typeof current === "object" && part in current)
+          current = current[part];
+        else
+          return "";
+      const errors = current;
+      if (!errors || !Array.isArray(errors) || errors.length === 0)
+        return "";
+      return body;
+    } catch {
+      return "";
+    }
+  });
+}
+export function processFormValidationDirectives(content, context, filePath) {
+  let result = content;
+  result = processErrorDirective(result, context, filePath);
+  result = processErrorsDirective(result, context, filePath);
+  result = processHasErrorsDirective(result, context, filePath);
+  return result;
+}
+
+export { Validator };