@tachui/forms 0.7.0-alpha1

package/dist/forms-core-B1bx1drO.js

@@ -0,0 +1,839 @@
+var $ = Object.defineProperty;
+var q = (e, t, r) => t in e ? $(e, t, { enumerable: !0, configurable: !0, writable: !0, value: r }) : e[t] = r;
+var O = (e, t, r) => q(e, typeof t != "symbol" ? t + "" : t, r);
+import { createSignal as w, createComputed as D, createEffect as x } from "@tachui/core";
+class g extends Error {
+  constructor(t, r) {
+    super(t), this.context = r, this.name = "FormsValidationError";
+  }
+  getFormattedMessage() {
+    const { component: t, suggestion: r, example: a, documentation: s } = this.context;
+    let o = `❌ [@tachui/forms] ${t} Component Error: ${this.message}
+`;
+    return r && (o += `
+💡 Suggestion: ${r}
+`), a && (o += `
+❌ Wrong: ${a.wrong}`, o += `
+✅ Correct: ${a.correct}
+`), s && (o += `
+📚 Documentation: ${s}`), o;
+  }
+}
+const y = {
+  // EmailField Component
+  validateEmailField(e) {
+    if (e.length === 0)
+      throw new g("EmailField component requires a props object with value", {
+        component: "EmailField",
+        suggestion: "Add value: EmailField({ value: emailSignal })",
+        documentation: "https://docs.tachui.dev/forms/components/emailfield",
+        example: {
+          wrong: "EmailField()",
+          correct: "EmailField({ value: emailSignal, onChange: handleChange })"
+        }
+      });
+    const [t] = e;
+    if (!t || typeof t != "object")
+      throw new g("EmailField requires a props object", {
+        component: "EmailField",
+        suggestion: "Pass a props object with value property",
+        example: {
+          wrong: 'EmailField("email@example.com")',
+          correct: 'EmailField({ value: "email@example.com" })'
+        }
+      });
+    if (t.value === void 0)
+      throw new g("EmailField value property is required", {
+        component: "EmailField",
+        suggestion: "Provide a value for the email field",
+        example: {
+          wrong: 'EmailField({ placeholder: "Email" })',
+          correct: 'EmailField({ value: emailSignal, placeholder: "Email" })'
+        }
+      });
+  },
+  // PasswordField Component
+  validatePasswordField(e) {
+    if (e.length === 0)
+      throw new g("PasswordField component requires a props object with value", {
+        component: "PasswordField",
+        suggestion: "Add value: PasswordField({ value: passwordSignal })",
+        documentation: "https://docs.tachui.dev/forms/components/passwordfield",
+        example: {
+          wrong: "PasswordField()",
+          correct: "PasswordField({ value: passwordSignal, onChange: handleChange })"
+        }
+      });
+    const [t] = e;
+    if (!t || typeof t != "object")
+      throw new g("PasswordField requires a props object", {
+        component: "PasswordField",
+        suggestion: "Pass a props object with value property",
+        example: {
+          wrong: 'PasswordField("password")',
+          correct: "PasswordField({ value: passwordSignal })"
+        }
+      });
+    if (t.value === void 0)
+      throw new g("PasswordField value property is required", {
+        component: "PasswordField",
+        suggestion: "Provide a value for the password field",
+        example: {
+          wrong: 'PasswordField({ placeholder: "Password" })',
+          correct: 'PasswordField({ value: passwordSignal, placeholder: "Password" })'
+        }
+      });
+  },
+  // PhoneField Component  
+  validatePhoneField(e) {
+    if (e.length === 0)
+      throw new g("PhoneField component requires a props object with value", {
+        component: "PhoneField",
+        suggestion: "Add value: PhoneField({ value: phoneSignal })",
+        documentation: "https://docs.tachui.dev/forms/components/phonefield",
+        example: {
+          wrong: "PhoneField()",
+          correct: 'PhoneField({ value: phoneSignal, format: "US" })'
+        }
+      });
+    const [t] = e;
+    if (!t || typeof t != "object")
+      throw new g("PhoneField requires a props object", {
+        component: "PhoneField",
+        suggestion: "Pass a props object with value property",
+        example: {
+          wrong: 'PhoneField("(555) 123-4567")',
+          correct: "PhoneField({ value: phoneSignal })"
+        }
+      });
+    if (t.value === void 0)
+      throw new g("PhoneField value property is required", {
+        component: "PhoneField",
+        suggestion: "Provide a value for the phone field",
+        example: {
+          wrong: 'PhoneField({ format: "US" })',
+          correct: 'PhoneField({ value: phoneSignal, format: "US" })'
+        }
+      });
+  },
+  // NumberField Component
+  validateNumberField(e) {
+    if (e.length === 0)
+      throw new g("NumberField component requires a props object with value", {
+        component: "NumberField",
+        suggestion: "Add value: NumberField({ value: numberSignal })",
+        documentation: "https://docs.tachui.dev/forms/components/numberfield",
+        example: {
+          wrong: "NumberField()",
+          correct: "NumberField({ value: numberSignal, min: 0, max: 100 })"
+        }
+      });
+    const [t] = e;
+    if (!t || typeof t != "object")
+      throw new g("NumberField requires a props object", {
+        component: "NumberField",
+        suggestion: "Pass a props object with value property",
+        example: {
+          wrong: "NumberField(42)",
+          correct: "NumberField({ value: 42 })"
+        }
+      });
+    if (t.value === void 0)
+      throw new g("NumberField value property is required", {
+        component: "NumberField",
+        suggestion: "Provide a numeric value for the field",
+        example: {
+          wrong: "NumberField({ min: 0, max: 100 })",
+          correct: "NumberField({ value: 42, min: 0, max: 100 })"
+        }
+      });
+  },
+  // CreditCardField Component
+  validateCreditCardField(e) {
+    if (e.length === 0)
+      throw new g("CreditCardField component requires a props object with value", {
+        component: "CreditCardField",
+        suggestion: "Add value: CreditCardField({ value: cardSignal })",
+        documentation: "https://docs.tachui.dev/forms/components/creditcardfield",
+        example: {
+          wrong: "CreditCardField()",
+          correct: "CreditCardField({ value: cardSignal, onChange: handleChange })"
+        }
+      });
+    const [t] = e;
+    if (!t || typeof t != "object")
+      throw new g("CreditCardField requires a props object", {
+        component: "CreditCardField",
+        suggestion: "Pass a props object with value property",
+        example: {
+          wrong: 'CreditCardField("4111111111111111")',
+          correct: "CreditCardField({ value: cardSignal })"
+        }
+      });
+    if (t.value === void 0)
+      throw new g("CreditCardField value property is required", {
+        component: "CreditCardField",
+        suggestion: "Provide a value for the credit card field",
+        example: {
+          wrong: 'CreditCardField({ placeholder: "Card Number" })',
+          correct: 'CreditCardField({ value: cardSignal, placeholder: "Card Number" })'
+        }
+      });
+  }
+  // Additional Forms components would go here...
+  // (SearchField, URLField, TextArea, ColorField, Select, MultiSelect, Checkbox, Radio, etc.)
+};
+function U() {
+  return [
+    {
+      packageName: "forms",
+      componentName: "EmailField",
+      validate: y.validateEmailField
+    },
+    {
+      packageName: "forms",
+      componentName: "PasswordField",
+      validate: y.validatePasswordField
+    },
+    {
+      packageName: "forms",
+      componentName: "PhoneField",
+      validate: y.validatePhoneField
+    },
+    {
+      packageName: "forms",
+      componentName: "NumberField",
+      validate: y.validateNumberField
+    },
+    {
+      packageName: "forms",
+      componentName: "CreditCardField",
+      validate: y.validateCreditCardField
+    }
+    // Additional validators would be added here for remaining 9+ Forms components
+  ];
+}
+async function k() {
+  try {
+    const { registerComponentValidator: e } = await import("@tachui/core/validation"), t = U();
+    for (const r of t)
+      e(r);
+    process.env.NODE_ENV !== "production" && console.info(`🔍 [@tachui/forms] Registered ${t.length} component validators`);
+  } catch (e) {
+    process.env.NODE_ENV !== "production" && console.warn("⚠️ [@tachui/forms] Could not register validators with Core:", e);
+  }
+}
+typeof window < "u" && process.env.NODE_ENV !== "production" && setTimeout(k, 10);
+const C = {
+  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 s = t.length - 1; s >= 0; s--) {
+      let o = parseInt(t.charAt(s));
+      a && (o *= 2, o > 9 && (o = o % 10 + 1)), r += o, 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), s = /\W/.test(e), o = e.length >= 8, l = t && r && a && s && o;
+    return {
+      valid: l,
+      message: l ? void 0 : "Password must be at least 8 characters with uppercase, lowercase, number and special character",
+      code: "WEAK_PASSWORD"
+    };
+  }
+}, S = /* @__PURE__ */ new Map();
+function Y(e) {
+  S.set(e.name, e);
+}
+function Q(e) {
+  S.delete(e);
+}
+function z() {
+  return [...Object.keys(C), ...S.keys()];
+}
+function T(e, t, r) {
+  for (const a of t) {
+    let s;
+    if (typeof a == "string") {
+      const o = C[a];
+      if (o)
+        s = o(e, r?.[a]);
+      else {
+        const l = S.get(a);
+        if (l)
+          s = l.validate(e, l.options);
+        else {
+          console.warn(`Unknown validation rule: ${a}`);
+          continue;
+        }
+      }
+    } else if ("validate" in a)
+      s = a.validate(e, a.options);
+    else {
+      const o = C[a.name];
+      if (o)
+        s = o(e, a.options);
+      else {
+        console.warn(`Unknown built-in validation rule: ${a.name}`);
+        continue;
+      }
+    }
+    if (!s.valid)
+      return s;
+  }
+  return { valid: !0 };
+}
+function B(e, t) {
+  return !t?.rules || t.rules.length === 0 ? { valid: !0 } : T(e.value, t.rules);
+}
+async function L(e, t, r) {
+  for (const a of t) {
+    let s;
+    if (typeof a == "string") {
+      const l = C[a];
+      if (l)
+        s = l(e, r?.[a]);
+      else {
+        const c = S.get(a);
+        if (c)
+          s = c.validate(e, c.options);
+        else
+          continue;
+      }
+    } else if ("validate" in a)
+      s = a.validate(e, a.options);
+    else {
+      const l = C[a.name];
+      if (l)
+        s = l(e, a.options);
+      else
+        continue;
+    }
+    const o = await Promise.resolve(s);
+    if (!o.valid)
+      return o;
+  }
+  return { valid: !0 };
+}
+function X(e, t = 300) {
+  let r, a, s;
+  return (o) => new Promise((l) => {
+    if (o === a && s) {
+      Promise.resolve(s).then(l);
+      return;
+    }
+    a = o, clearTimeout(r), r = setTimeout(async () => {
+      try {
+        s = e(o);
+        const c = await Promise.resolve(s);
+        l(c);
+      } catch {
+        l({
+          valid: !1,
+          message: "Validation error occurred",
+          code: "VALIDATION_ERROR"
+        });
+      }
+    }, t);
+  });
+}
+const K = {
+  /**
+   * 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((s) => {
+    const o = r[s];
+    return o != null && o !== "";
+  }) ? { 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`) => (s) => {
+    if (s[t] === r) {
+      const o = s[e];
+      return o != null && o !== "" ? { 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 s = a[e], o = a[t];
+    if (!s || !o) return { valid: !0 };
+    const l = new Date(s);
+    return new Date(o) >= l ? { valid: !0 } : {
+      valid: !1,
+      message: r,
+      code: "INVALID_DATE_RANGE"
+    };
+  }
+}, J = {
+  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 {
+  constructor(t = {}) {
+    O(this, "messages", {});
+    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 ee = new H(), te = {
+  /**
+   * 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) => T(r, e, t),
+  /**
+   * Create an async validation function
+   */
+  createAsyncValidator: (e, t) => (r) => L(r, e, t)
+};
+function j(e) {
+  const [t, r] = w(e), [a, s] = w(void 0), [o, l] = w(!1), [c, F] = w(!1), [b, A] = w(!1), [V, I] = w(!1);
+  x(() => {
+    t() !== e && F(!0);
+  });
+  const d = D(() => !a());
+  return {
+    state: D(
+      () => ({
+        value: t(),
+        error: a(),
+        touched: o(),
+        dirty: c(),
+        valid: d(),
+        validating: V(),
+        focused: b()
+      })
+    ),
+    setValue: (m) => {
+      r(m), F(m !== e), o();
+    },
+    setError: s,
+    setTouched: l,
+    setFocused: A,
+    setValidating: I
+  };
+}
+function W(e = {}) {
+  const t = /* @__PURE__ */ new Map(), r = /* @__PURE__ */ new Map(), [a, s] = w(!1), [o, l] = w(!1);
+  Object.keys(e).forEach((n) => {
+    const i = j(e[n]);
+    t.set(n, i);
+  });
+  const c = D(() => {
+    const n = {}, i = {}, u = {};
+    let v = !0, f = !1;
+    for (const [_, E] of t) {
+      const P = E.state();
+      n[_] = P, P.error && (i[_] = P.error, v = !1), P.touched && (u[_] = !0), P.dirty && (f = !0);
+    }
+    return {
+      fields: n,
+      valid: v,
+      dirty: f,
+      submitting: a(),
+      submitted: o(),
+      errors: i,
+      touched: u
+    };
+  }), F = (n, i) => {
+    if (t.has(n)) {
+      i && r.set(n, i);
+      return;
+    }
+    const u = j(e[n]);
+    if (t.set(n, u), i && r.set(n, i), i) {
+      const v = u.state;
+      x(async () => {
+        const f = v();
+        if ((i.validateOn === "change" || i.validateOn === "blur" && f.touched || i.validateOn === "submit" && o()) && (f.dirty || f.touched)) {
+          u.setValidating(!0);
+          try {
+            const E = await M(f, i);
+            u.setError(E.valid ? void 0 : E.message);
+          } catch {
+            u.setError("Validation error occurred");
+          } finally {
+            u.setValidating(!1);
+          }
+        }
+      });
+    }
+  }, b = (n) => {
+    t.delete(n), r.delete(n);
+  }, A = (n, i) => {
+    const u = t.get(n);
+    u && u.setValue(i);
+  }, V = (n) => t.get(n)?.state().value, I = (n) => t.get(n)?.state().error, d = async (n) => {
+    const i = t.get(n), u = r.get(n);
+    if (!i || !u)
+      return !0;
+    const v = i.state();
+    i.setValidating(!0);
+    try {
+      const f = await M(v, u);
+      return i.setError(f.valid ? void 0 : f.message), f.valid;
+    } catch {
+      return i.setError("Validation error occurred"), !1;
+    } finally {
+      i.setValidating(!1);
+    }
+  }, p = async () => {
+    const n = Array.from(t.keys()).map(d);
+    return (await Promise.all(n)).every((u) => u);
+  }, m = () => {
+    for (const [n, i] of t)
+      i.setValue(e[n]), i.setError(void 0), i.setTouched(!1), i.setFocused(!1), i.setValidating(!1);
+    s(!1), l(!1);
+  }, h = async (n) => {
+    s(!0), l(!0);
+    try {
+      if (await p() && n) {
+        const u = {};
+        for (const [v, f] of t)
+          u[v] = f.state().value;
+        await n(u, c());
+      }
+    } finally {
+      s(!1);
+    }
+  }, N = (n) => {
+    const i = {}, u = n || Array.from(t.keys());
+    for (const v of u)
+      t.has(v) && (i[v] = V(v));
+    return i;
+  }, R = async (n) => {
+    const u = (n || Array.from(t.keys())).map(d);
+    return (await Promise.all(u)).every((f) => f);
+  };
+  return {
+    fields: c().fields,
+    state: c(),
+    register: F,
+    unregister: b,
+    setValue: A,
+    getValue: V,
+    getError: I,
+    validateField: d,
+    validateForm: p,
+    resetForm: m,
+    submitForm: h,
+    watch: N,
+    trigger: R
+  };
+}
+async function M(e, t) {
+  return !t.rules || t.rules.length === 0 ? { valid: !0 } : t.debounceMs ? new Promise((r) => {
+    setTimeout(async () => {
+      const a = await L(e.value, t.rules);
+      r(a);
+    }, t.debounceMs);
+  }) : L(e.value, t.rules);
+}
+function re(e, t, r) {
+  const a = j(t), s = a.state;
+  r && x(async () => {
+    const c = s();
+    if ((r.validateOn === "change" || r.validateOn === "blur" && c.touched) && (c.dirty || c.touched)) {
+      a.setValidating(!0);
+      try {
+        const b = await M(c, r);
+        a.setError(b.valid ? void 0 : b.message);
+      } catch {
+        a.setError("Validation error occurred");
+      } finally {
+        a.setValidating(!1);
+      }
+    }
+  });
+  const o = async () => {
+    if (!r) return !0;
+    a.setValidating(!0);
+    try {
+      const c = await M(s(), r);
+      return a.setError(c.valid ? void 0 : c.message), c.valid;
+    } catch {
+      return a.setError("Validation error occurred"), !1;
+    } finally {
+      a.setValidating(!1);
+    }
+  }, l = () => {
+    a.setValue(t), a.setError(void 0), a.setTouched(!1), a.setFocused(!1), a.setValidating(!1);
+  };
+  return {
+    value: () => s().value,
+    setValue: a.setValue,
+    error: () => s().error,
+    touched: () => s().touched,
+    dirty: () => s().dirty,
+    valid: () => s().valid,
+    validating: () => s().validating,
+    focused: () => s().focused,
+    onFocus: () => {
+      a.setFocused(!0);
+    },
+    onBlur: () => {
+      a.setFocused(!1), a.setTouched(!0);
+    },
+    validate: o,
+    reset: l
+  };
+}
+function ae(e, t = {}) {
+  const [r, a] = w(0), [s, o] = w(/* @__PURE__ */ new Set()), l = /* @__PURE__ */ new Map();
+  return e.forEach((d, p) => {
+    const m = Object.keys(t).filter((h) => h.startsWith(`step_${p}_`)).reduce(
+      (h, N) => {
+        const R = N.replace(`step_${p}_`, "");
+        return h[R] = t[N], h;
+      },
+      {}
+    );
+    l.set(p, W(m));
+  }), {
+    currentStep: r,
+    completedSteps: s,
+    nextStep: async (d = !0) => {
+      const p = r(), m = l.get(p);
+      return d && m && !await m.validateForm() ? !1 : p < e.length - 1 ? (o((h) => /* @__PURE__ */ new Set([...h, p])), a(p + 1), !0) : !1;
+    },
+    previousStep: () => {
+      const d = r();
+      return d > 0 ? (a(d - 1), !0) : !1;
+    },
+    goToStep: (d) => d >= 0 && d < e.length ? (a(d), !0) : !1,
+    getCurrentForm: () => l.get(r()),
+    getAllValues: () => {
+      const d = {};
+      return l.forEach((p, m) => {
+        const h = p.watch();
+        Object.keys(h).forEach((N) => {
+          d[`step_${m}_${N}`] = h[N];
+        });
+      }), d;
+    },
+    validateAllSteps: async () => {
+      const d = Array.from(l.values()).map((m) => m.validateForm());
+      return (await Promise.all(d)).every((m) => m);
+    },
+    getStepForm: (d) => l.get(d),
+    isStepCompleted: (d) => s().has(d),
+    canGoToStep: (d) => d <= r() || s().has(d)
+  };
+}
+export {
+  K as C,
+  g as F,
+  J as V,
+  W as a,
+  ae as b,
+  re as c,
+  ee as d,
+  Y as e,
+  T as f,
+  z as g,
+  B as h,
+  X as i,
+  H as j,
+  te as k,
+  C as l,
+  y as m,
+  U as n,
+  k as r,
+  Q as u,
+  L as v
+};
+//# sourceMappingURL=forms-core-B1bx1drO.js.map