@tachui/forms 0.7.0-alpha1 → 0.8.0-alpha

package/dist/validation/index.js

@@ -1,21 +1,691 @@
-import { C as e, m as i, F as t, l as r, j as l, V as o, k as d, i as V, n, d as m, g as u, r as F, e as g, u as c, h as v, f as R, v as f } from "../forms-core-B1bx1drO.js";
+class s extends Error {
+  constructor(t, r) {
+    super(t), this.context = r, this.name = "FormsValidationError";
+  }
+  getFormattedMessage() {
+    const { component: t, suggestion: r, example: a, documentation: n } = this.context;
+    let i = `❌ [@tachui/advanced-forms] ${t} Component Error: ${this.message}
+`;
+    return r && (i += `
+💡 Suggestion: ${r}
+`), a && (i += `
+❌ Wrong: ${a.wrong}`, i += `
+✅ Correct: ${a.correct}
+`), n && (i += `
+📚 Documentation: ${n}`), i;
+  }
+}
+const l = {
+  // TextField Component
+  validateTextField(e) {
+    if (e.length === 0)
+      throw new s(
+        "TextField component requires a props object with name",
+        {
+          component: "TextField",
+          suggestion: 'Add name property: TextField({ name: "fieldName" })',
+          documentation: "https://docs.tachui.dev/advanced-forms/components/textfield",
+          example: {
+            wrong: "TextField()",
+            correct: 'TextField({ name: "email", value: emailSignal })'
+          }
+        }
+      );
+    const [t] = e;
+    if (!t || typeof t != "object")
+      throw new s("TextField requires a props object", {
+        component: "TextField",
+        suggestion: "Pass a props object with name property",
+        example: {
+          wrong: 'TextField("email")',
+          correct: 'TextField({ name: "email" })'
+        }
+      });
+    const r = t;
+    if (!r.name || typeof r.name != "string")
+      throw new s(
+        "TextField name property is required and must be a string",
+        {
+          component: "TextField",
+          suggestion: "Provide a unique name for the field",
+          example: {
+            wrong: 'TextField({ placeholder: "Email" })',
+            correct: 'TextField({ name: "email", placeholder: "Email" })'
+          }
+        }
+      );
+  },
+  // EmailField Component
+  validateEmailField(e) {
+    if (e.length === 0)
+      throw new s(
+        "EmailField component requires a props object with name",
+        {
+          component: "EmailField",
+          suggestion: 'Add name property: EmailField({ name: "email" })',
+          documentation: "https://docs.tachui.dev/advanced-forms/components/emailfield",
+          example: {
+            wrong: "EmailField()",
+            correct: 'EmailField({ name: "email", value: emailSignal })'
+          }
+        }
+      );
+    const [t] = e;
+    if (!t || typeof t != "object")
+      throw new s("EmailField requires a props object", {
+        component: "EmailField",
+        suggestion: "Pass a props object with name property",
+        example: {
+          wrong: 'EmailField("email@example.com")',
+          correct: 'EmailField({ name: "email", value: "email@example.com" })'
+        }
+      });
+    const r = t;
+    if (!r.name || typeof r.name != "string")
+      throw new s(
+        "EmailField name property is required and must be a string",
+        {
+          component: "EmailField",
+          suggestion: "Provide a unique name for the email field",
+          example: {
+            wrong: 'EmailField({ placeholder: "Email" })',
+            correct: 'EmailField({ name: "email", placeholder: "Email" })'
+          }
+        }
+      );
+  },
+  // PasswordField Component
+  validatePasswordField(e) {
+    if (e.length === 0)
+      throw new s(
+        "PasswordField component requires a props object with name",
+        {
+          component: "PasswordField",
+          suggestion: 'Add name property: PasswordField({ name: "password" })',
+          documentation: "https://docs.tachui.dev/advanced-forms/components/passwordfield",
+          example: {
+            wrong: "PasswordField()",
+            correct: 'PasswordField({ name: "password", value: passwordSignal })'
+          }
+        }
+      );
+    const [t] = e;
+    if (!t || typeof t != "object")
+      throw new s("PasswordField requires a props object", {
+        component: "PasswordField",
+        suggestion: "Pass a props object with name property",
+        example: {
+          wrong: 'PasswordField("password")',
+          correct: 'PasswordField({ name: "password", value: passwordSignal })'
+        }
+      });
+    const r = t;
+    if (!r.name || typeof r.name != "string")
+      throw new s(
+        "PasswordField name property is required and must be a string",
+        {
+          component: "PasswordField",
+          suggestion: "Provide a unique name for the password field",
+          example: {
+            wrong: 'PasswordField({ placeholder: "Password" })',
+            correct: 'PasswordField({ name: "password", placeholder: "Password" })'
+          }
+        }
+      );
+  },
+  // PhoneField Component
+  validatePhoneField(e) {
+    if (e.length === 0)
+      throw new s(
+        "PhoneField component requires a props object with name",
+        {
+          component: "PhoneField",
+          suggestion: 'Add name property: PhoneField({ name: "phone" })',
+          documentation: "https://docs.tachui.dev/advanced-forms/components/phonefield",
+          example: {
+            wrong: "PhoneField()",
+            correct: 'PhoneField({ name: "phone", format: "US" })'
+          }
+        }
+      );
+    const [t] = e;
+    if (!t || typeof t != "object")
+      throw new s("PhoneField requires a props object", {
+        component: "PhoneField",
+        suggestion: "Pass a props object with name property",
+        example: {
+          wrong: 'PhoneField("(555) 123-4567")',
+          correct: 'PhoneField({ name: "phone", value: phoneSignal })'
+        }
+      });
+    const r = t;
+    if (!r.name || typeof r.name != "string")
+      throw new s(
+        "PhoneField name property is required and must be a string",
+        {
+          component: "PhoneField",
+          suggestion: "Provide a unique name for the phone field",
+          example: {
+            wrong: 'PhoneField({ format: "US" })',
+            correct: 'PhoneField({ name: "phone", format: "US" })'
+          }
+        }
+      );
+  },
+  // NumberField Component
+  validateNumberField(e) {
+    if (e.length === 0)
+      throw new s(
+        "NumberField component requires a props object with name",
+        {
+          component: "NumberField",
+          suggestion: 'Add name property: NumberField({ name: "amount" })',
+          documentation: "https://docs.tachui.dev/advanced-forms/components/numberfield",
+          example: {
+            wrong: "NumberField()",
+            correct: 'NumberField({ name: "amount", min: 0, max: 100 })'
+          }
+        }
+      );
+    const [t] = e;
+    if (!t || typeof t != "object")
+      throw new s("NumberField requires a props object", {
+        component: "NumberField",
+        suggestion: "Pass a props object with name property",
+        example: {
+          wrong: "NumberField(42)",
+          correct: 'NumberField({ name: "amount", value: 42 })'
+        }
+      });
+    const r = t;
+    if (!r.name || typeof r.name != "string")
+      throw new s(
+        "NumberField name property is required and must be a string",
+        {
+          component: "NumberField",
+          suggestion: "Provide a unique name for the number field",
+          example: {
+            wrong: "NumberField({ min: 0, max: 100 })",
+            correct: 'NumberField({ name: "amount", min: 0, max: 100 })'
+          }
+        }
+      );
+  },
+  // CreditCardField Component
+  validateCreditCardField(e) {
+    if (e.length === 0)
+      throw new s(
+        "CreditCardField component requires a props object with name",
+        {
+          component: "CreditCardField",
+          suggestion: 'Add name property: CreditCardField({ name: "cardNumber" })',
+          documentation: "https://docs.tachui.dev/advanced-forms/components/creditcardfield",
+          example: {
+            wrong: "CreditCardField()",
+            correct: 'CreditCardField({ name: "cardNumber", onChange: handleChange })'
+          }
+        }
+      );
+    const [t] = e;
+    if (!t || typeof t != "object")
+      throw new s(
+        "CreditCardField requires a props object",
+        {
+          component: "CreditCardField",
+          suggestion: "Pass a props object with name property",
+          example: {
+            wrong: 'CreditCardField("4111111111111111")',
+            correct: 'CreditCardField({ name: "cardNumber", value: cardSignal })'
+          }
+        }
+      );
+    const r = t;
+    if (!r.name || typeof r.name != "string")
+      throw new s(
+        "CreditCardField name property is required and must be a string",
+        {
+          component: "CreditCardField",
+          suggestion: "Provide a unique name for the credit card field",
+          example: {
+            wrong: 'CreditCardField({ placeholder: "Card Number" })',
+            correct: 'CreditCardField({ name: "cardNumber", placeholder: "Card Number" })'
+          }
+        }
+      );
+  }
+  // Additional Forms components would go here...
+  // (SearchField, URLField, TextArea, ColorField, etc.)
+};
+function p() {
+  return [
+    {
+      packageName: "advanced-forms",
+      componentName: "TextField",
+      validate: l.validateTextField
+    },
+    {
+      packageName: "advanced-forms",
+      componentName: "EmailField",
+      validate: l.validateEmailField
+    },
+    {
+      packageName: "advanced-forms",
+      componentName: "PasswordField",
+      validate: l.validatePasswordField
+    },
+    {
+      packageName: "advanced-forms",
+      componentName: "PhoneField",
+      validate: l.validatePhoneField
+    },
+    {
+      packageName: "advanced-forms",
+      componentName: "NumberField",
+      validate: l.validateNumberField
+    },
+    {
+      packageName: "advanced-forms",
+      componentName: "CreditCardField",
+      validate: l.validateCreditCardField
+    }
+    // Additional validators would be added here for remaining Forms components
+  ];
+}
+async function g() {
+  try {
+    const { registerComponentValidator: e } = await import("@tachui/core/validation"), t = p();
+    for (const r of t)
+      e(r);
+    process.env.NODE_ENV !== "production" && console.info(
+      `🔍 [@tachui/advanced-forms] Registered ${t.length} component validators`
+    );
+  } catch (e) {
+    process.env.NODE_ENV !== "production" && console.warn(
+      "⚠️ [@tachui/advanced-forms] Could not register validators with Core:",
+      e
+    );
+  }
+}
+typeof window < "u" && process.env.NODE_ENV !== "production" && setTimeout(g, 10);
+const m = {
+  required: (e) => ({
+    valid: e != null && e !== "",
+    message: "This field is required",
+    code: "REQUIRED"
+  }),
+  email: (e) => e ? {
+    valid: /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(e),
+    message: "Please enter a valid email address",
+    code: "INVALID_EMAIL"
+  } : { valid: !0 },
+  url: (e) => {
+    if (!e) return { valid: !0 };
+    try {
+      return new URL(e), { valid: !0 };
+    } catch {
+      return {
+        valid: !1,
+        message: "Please enter a valid URL",
+        code: "INVALID_URL"
+      };
+    }
+  },
+  number: (e) => {
+    if (!e) return { valid: !0 };
+    const t = Number(e);
+    return {
+      valid: !Number.isNaN(t) && Number.isFinite(t),
+      message: "Please enter a valid number",
+      code: "INVALID_NUMBER"
+    };
+  },
+  integer: (e) => {
+    if (!e) return { valid: !0 };
+    const t = Number(e);
+    return {
+      valid: !Number.isNaN(t) && Number.isFinite(t) && Number.isInteger(t),
+      message: "Please enter a valid integer",
+      code: "INVALID_INTEGER"
+    };
+  },
+  min: (e, t) => {
+    if (!e) return { valid: !0 };
+    const r = Number(e);
+    return Number.isNaN(r) ? { valid: !0 } : {
+      valid: r >= t.min,
+      message: `Value must be at least ${t.min}`,
+      code: "MIN_VALUE"
+    };
+  },
+  max: (e, t) => {
+    if (!e) return { valid: !0 };
+    const r = Number(e);
+    return Number.isNaN(r) ? { valid: !0 } : {
+      valid: r <= t.max,
+      message: `Value must be at most ${t.max}`,
+      code: "MAX_VALUE"
+    };
+  },
+  minLength: (e, t) => e ? {
+    valid: e.length >= t.minLength,
+    message: `Must be at least ${t.minLength} characters`,
+    code: "MIN_LENGTH"
+  } : { valid: !0 },
+  maxLength: (e, t) => e ? {
+    valid: e.length <= t.maxLength,
+    message: `Must be at most ${t.maxLength} characters`,
+    code: "MAX_LENGTH"
+  } : { valid: !0 },
+  pattern: (e, t) => e ? {
+    valid: (typeof t.pattern == "string" ? new RegExp(t.pattern) : t.pattern).test(e),
+    message: t.message || "Value does not match required pattern",
+    code: "PATTERN_MISMATCH"
+  } : { valid: !0 },
+  // Additional validation rules expected by tests
+  numeric: (e) => {
+    if (!e) return { valid: !0 };
+    const t = Number(e);
+    return {
+      valid: !Number.isNaN(t) && Number.isFinite(t),
+      message: "Please enter a valid number",
+      code: "INVALID_NUMERIC"
+    };
+  },
+  phone: (e) => {
+    if (!e) return { valid: !0 };
+    const t = /^\+?[\d\s\-().]+$/, r = e.replace(/[\s\-().]/g, "");
+    return {
+      valid: t.test(e) && r.length >= 10,
+      message: "Please enter a valid phone number",
+      code: "INVALID_PHONE"
+    };
+  },
+  creditCard: (e) => {
+    if (!e) return { valid: !0 };
+    const t = e.replace(/\s/g, "");
+    let r = 0, a = !1;
+    for (let n = t.length - 1; n >= 0; n--) {
+      let i = parseInt(t.charAt(n));
+      a && (i *= 2, i > 9 && (i = i % 10 + 1)), r += i, a = !a;
+    }
+    return {
+      valid: /^\d{13,19}$/.test(t) && r % 10 === 0,
+      message: "Please enter a valid credit card number",
+      code: "INVALID_CREDIT_CARD"
+    };
+  },
+  ssn: (e) => {
+    if (!e) return { valid: !0 };
+    const t = e.replace(/[-\s]/g, "");
+    return {
+      valid: /^\d{9}$/.test(t),
+      message: "Please enter a valid Social Security Number",
+      code: "INVALID_SSN"
+    };
+  },
+  postalCode: (e) => {
+    if (!e) return { valid: !0 };
+    const t = /^\d{5}(-\d{4})?$/, r = /^[A-Z0-9]{3,10}$/i;
+    return {
+      valid: t.test(e) || r.test(e),
+      message: "Please enter a valid postal code",
+      code: "INVALID_POSTAL_CODE"
+    };
+  },
+  zipCode: (e) => e ? {
+    valid: /^\d{5}(-\d{4})?$/.test(e),
+    message: "Please enter a valid ZIP code",
+    code: "INVALID_ZIP_CODE"
+  } : { valid: !0 },
+  date: (e) => {
+    if (!e) return { valid: !0 };
+    const t = new Date(e);
+    return {
+      valid: !Number.isNaN(t.getTime()) && !!e.match(/^\d{4}-\d{2}-\d{2}$/),
+      message: "Please enter a valid date (YYYY-MM-DD)",
+      code: "INVALID_DATE"
+    };
+  },
+  time: (e) => e ? {
+    valid: /^([0-1]?[0-9]|2[0-3]):[0-5][0-9]$/.test(e),
+    message: "Please enter a valid time (HH:MM)",
+    code: "INVALID_TIME"
+  } : { valid: !0 },
+  strongPassword: (e) => {
+    if (!e) return { valid: !0 };
+    const t = /[A-Z]/.test(e), r = /[a-z]/.test(e), a = /\d/.test(e), n = /\W/.test(e), i = e.length >= 8, o = t && r && a && n && i;
+    return {
+      valid: o,
+      message: o ? void 0 : "Password must be at least 8 characters with uppercase, lowercase, number and special character",
+      code: "WEAK_PASSWORD"
+    };
+  }
+}, c = /* @__PURE__ */ new Map();
+function v(e) {
+  c.set(e.name, e);
+}
+function F(e) {
+  c.delete(e);
+}
+function N() {
+  return [...Object.keys(m), ...c.keys()];
+}
+function u(e, t, r) {
+  for (const a of t) {
+    let n;
+    if (typeof a == "string") {
+      const i = m[a];
+      if (i)
+        n = i(e, r?.[a]);
+      else {
+        const o = c.get(a);
+        if (o)
+          n = o.validate(e, o.options);
+        else {
+          console.warn(`Unknown validation rule: ${a}`);
+          continue;
+        }
+      }
+    } else if ("validate" in a)
+      n = a.validate(e, a.options);
+    else {
+      const i = m[a.name];
+      if (i)
+        n = i(e, a.options);
+      else {
+        console.warn(`Unknown built-in validation rule: ${a.name}`);
+        continue;
+      }
+    }
+    if (!n.valid)
+      return n;
+  }
+  return { valid: !0 };
+}
+function b(e, t) {
+  return !t?.rules || t.rules.length === 0 ? { valid: !0 } : u(e.value, t.rules);
+}
+async function f(e, t, r) {
+  for (const a of t) {
+    let n;
+    if (typeof a == "string") {
+      const o = m[a];
+      if (o)
+        n = o(e, r?.[a]);
+      else {
+        const d = c.get(a);
+        if (d)
+          n = d.validate(e, d.options);
+        else
+          continue;
+      }
+    } else if ("validate" in a)
+      n = a.validate(e, a.options);
+    else {
+      const o = m[a.name];
+      if (o)
+        n = o(e, a.options);
+      else
+        continue;
+    }
+    const i = await Promise.resolve(n);
+    if (!i.valid)
+      return i;
+  }
+  return { valid: !0 };
+}
+function P(e, t = 300) {
+  let r, a, n;
+  return (i) => new Promise((o) => {
+    if (i === a && n) {
+      Promise.resolve(n).then(o);
+      return;
+    }
+    a = i, clearTimeout(r), r = setTimeout(async () => {
+      try {
+        n = e(i);
+        const d = await Promise.resolve(n);
+        o(d);
+      } catch {
+        o({
+          valid: !1,
+          message: "Validation error occurred",
+          code: "VALIDATION_ERROR"
+        });
+      }
+    }, t);
+  });
+}
+const E = {
+  /**
+   * Validate that two fields match (e.g., password confirmation)
+   */
+  fieldMatch: (e, t, r = "Fields must match") => (a) => a[e] === a[t] ? { valid: !0 } : {
+    valid: !1,
+    message: r,
+    code: "FIELD_MISMATCH"
+  },
+  /**
+   * Validate that at least one field in a group is filled
+   */
+  requireOneOf: (e, t = "At least one field is required") => (r) => e.some((n) => {
+    const i = r[n];
+    return i != null && i !== "";
+  }) ? { valid: !0 } : {
+    valid: !1,
+    message: t,
+    code: "REQUIRE_ONE_OF"
+  },
+  /**
+   * Validate that a field is required when another field has a specific value
+   */
+  requiredWhen: (e, t, r, a = `${e} is required`) => (n) => {
+    if (n[t] === r) {
+      const i = n[e];
+      return i != null && i !== "" ? { valid: !0 } : {
+        valid: !1,
+        message: a,
+        code: "REQUIRED_WHEN"
+      };
+    }
+    return { valid: !0 };
+  },
+  /**
+   * Validate date range (start date before end date)
+   */
+  dateRange: (e, t, r = "End date must be after start date") => (a) => {
+    const n = a[e], i = a[t];
+    if (!n || !i) return { valid: !0 };
+    const o = new Date(n);
+    return new Date(i) >= o ? { valid: !0 } : {
+      valid: !1,
+      message: r,
+      code: "INVALID_DATE_RANGE"
+    };
+  }
+}, x = {
+  email: ["required", "email"],
+  password: ["required", { name: "minLength", options: { minLength: 8 } }],
+  phone: [
+    "required",
+    {
+      name: "pattern",
+      options: { pattern: /^\+?[\d\s-()]+$/, message: "Invalid phone number" }
+    }
+  ],
+  url: ["required", "url"],
+  positiveNumber: ["required", "number", { name: "min", options: { min: 0 } }],
+  percentage: [
+    "required",
+    "number",
+    { name: "min", options: { min: 0 } },
+    { name: "max", options: { max: 100 } }
+  ]
+};
+class h {
+  messages = {};
+  constructor(t = {}) {
+    this.messages = t;
+  }
+  setMessage(t, r) {
+    this.messages[t] = r;
+  }
+  setMessages(t) {
+    this.messages = { ...this.messages, ...t };
+  }
+  format(t, r) {
+    return t.code && this.messages[t.code] ? this.messages[t.code].replace(
+      "${field}",
+      r || "field"
+    ) : t.message || "Validation failed";
+  }
+}
+const C = new h(), V = {
+  /**
+   * Check if a validation result represents an error
+   */
+  isError: (e) => !e.valid,
+  /**
+   * Check if a validation result is valid
+   */
+  isValid: (e) => e.valid,
+  /**
+   * Combine multiple validation results
+   */
+  combineResults: (e) => {
+    const t = e.filter((r) => !r.valid);
+    return t.length === 0 ? { valid: !0 } : {
+      valid: !1,
+      message: t.map((r) => r.message).join(", "),
+      code: "MULTIPLE_ERRORS"
+    };
+  },
+  /**
+   * Create a validation function from a rule configuration
+   */
+  createValidator: (e, t) => (r) => u(r, e, t),
+  /**
+   * Create an async validation function
+   */
+  createAsyncValidator: (e, t) => (r) => f(r, e, t)
+};
 export {
-  e as CrossFieldValidators,
-  i as FormsComponentValidation,
-  t as FormsValidationError,
-  r as VALIDATION_RULES,
-  l as ValidationMessageFormatter,
-  o as ValidationPresets,
-  d as ValidationUtils,
-  V as createDebouncedValidator,
-  n as createFormsValidators,
-  m as defaultMessageFormatter,
-  u as getValidationRules,
-  F as registerFormsValidators,
-  g as registerValidationRule,
-  c as unregisterValidationRule,
-  v as validateField,
-  R as validateValue,
+  E as CrossFieldValidators,
+  l as FormsComponentValidation,
+  s as FormsValidationError,
+  m as VALIDATION_RULES,
+  h as ValidationMessageFormatter,
+  x as ValidationPresets,
+  V as ValidationUtils,
+  P as createDebouncedValidator,
+  p as createFormsValidators,
+  C as defaultMessageFormatter,
+  N as getValidationRules,
+  g as registerFormsValidators,
+  v as registerValidationRule,
+  F as unregisterValidationRule,
+  b as validateField,
+  u as validateValue,
   f as validateValueAsync
 };
 //# sourceMappingURL=index.js.map