@goodie-forms/react 1.1.0-alpha → 1.1.2-alpha

package/dist/index.js

@@ -0,0 +1,773 @@
+import { FormController as br, Field as F } from "@goodie-forms/core";
+import De, { useState as ne, useRef as re, startTransition as pr, useEffect as I } from "react";
+function W(...t) {
+  return () => {
+    for (const o of t)
+      o();
+  };
+}
+function J() {
+  const [, t] = ne(0), o = re(0), l = re(!1);
+  o.current++;
+  const d = () => {
+    l.current || (l.current = !0, queueMicrotask(() => {
+      pr(() => {
+        t((v) => v + 1);
+      }), l.current = !1;
+    }));
+  };
+  return {
+    renderCount: o.current,
+    forceRerender: d
+  };
+}
+function Sr(t, o) {
+  const [l] = ne(() => new br(t)), d = J();
+  return I(() => {
+    const v = () => {
+    };
+    return W(
+      l.events.on("submissionStatusChange", () => {
+        d.forceRerender();
+      }),
+      o?.watchIssues ? l.events.on(
+        "fieldIssuesUpdated",
+        () => d.forceRerender()
+      ) : v,
+      o?.watchValues ? l.events.on(
+        "valueChanged",
+        () => d.forceRerender()
+      ) : v
+    );
+  }, [l]), {
+    formConfigs: t,
+    hookConfigs: o,
+    controller: l
+  };
+}
+function mr(t, o, l) {
+  const d = J(), [v, c] = ne(() => {
+    let g = t.controller.getField(o);
+    return g == null && l != null && (g = t.controller.bindField(o, l)), g;
+  });
+  return I(() => {
+    const { events: g } = t.controller;
+    return c(t.controller.getField(o)), W(
+      g.on("fieldBound", (h) => {
+        h === o && c(t.controller.getField(o));
+      }),
+      g.on("fieldUnbound", (h) => {
+        h === o && c(void 0);
+      }),
+      g.on("valueChanged", (h) => {
+        (h === o || F.isDescendant(h, o)) && d.forceRerender();
+      }),
+      g.on("fieldTouchUpdated", (h) => {
+        h === o && d.forceRerender();
+      }),
+      g.on("fieldDirtyUpdated", (h) => {
+        h === o && d.forceRerender();
+      }),
+      g.on("fieldIssuesUpdated", (h) => {
+        h === o && d.forceRerender();
+      })
+    );
+  }, []), v;
+}
+function wr(t, o) {
+  const l = J(), d = o?.include == null ? t.controller._data : o.include.reduce((v, c) => {
+    const g = F.getValue(t.controller._data, c);
+    return F.setValue(v, c, g), v;
+  }, {});
+  return I(() => {
+    const { events: v } = t.controller;
+    return W(
+      v.on("valueChanged", (c) => {
+        (o?.include == null || o.include.some(
+          (h) => h === c || F.isDescendant(h, c)
+        )) && l.forceRerender();
+      })
+    );
+  }, []), d;
+}
+function yr(t, o) {
+  const l = {};
+  for (const d of t) {
+    const v = o(d);
+    (l[v] ??= []).push(d);
+  }
+  return l;
+}
+function Pr(t, o) {
+  const l = J(), d = t.controller._issues.filter((c) => {
+    if (o?.include == null) return !0;
+    const g = F.parsePath(c.path);
+    return o.include.includes(g);
+  }), v = yr(
+    d,
+    (c) => F.parsePath(c.path)
+  );
+  return I(() => {
+    const { events: c } = t.controller;
+    return W(
+      c.on("fieldIssuesUpdated", (g) => {
+        (o?.include?.includes?.(g) ?? !0) && l.forceRerender();
+      })
+    );
+  }, []), v;
+}
+var q = { exports: {} }, $ = {};
+var Fe;
+function Er() {
+  if (Fe) return $;
+  Fe = 1;
+  var t = De, o = /* @__PURE__ */ Symbol.for("react.element"), l = /* @__PURE__ */ Symbol.for("react.fragment"), d = Object.prototype.hasOwnProperty, v = t.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.ReactCurrentOwner, c = { key: !0, ref: !0, __self: !0, __source: !0 };
+  function g(h, p, j) {
+    var _, T = {}, S = null, Y = null;
+    j !== void 0 && (S = "" + j), p.key !== void 0 && (S = "" + p.key), p.ref !== void 0 && (Y = p.ref);
+    for (_ in p) d.call(p, _) && !c.hasOwnProperty(_) && (T[_] = p[_]);
+    if (h && h.defaultProps) for (_ in p = h.defaultProps, p) T[_] === void 0 && (T[_] = p[_]);
+    return { $$typeof: o, type: h, key: S, ref: Y, props: T, _owner: v.current };
+  }
+  return $.Fragment = l, $.jsx = g, $.jsxs = g, $;
+}
+var U = {};
+var je;
+function _r() {
+  return je || (je = 1, process.env.NODE_ENV !== "production" && (function() {
+    var t = De, o = /* @__PURE__ */ Symbol.for("react.element"), l = /* @__PURE__ */ Symbol.for("react.portal"), d = /* @__PURE__ */ Symbol.for("react.fragment"), v = /* @__PURE__ */ Symbol.for("react.strict_mode"), c = /* @__PURE__ */ Symbol.for("react.profiler"), g = /* @__PURE__ */ Symbol.for("react.provider"), h = /* @__PURE__ */ Symbol.for("react.context"), p = /* @__PURE__ */ Symbol.for("react.forward_ref"), j = /* @__PURE__ */ Symbol.for("react.suspense"), _ = /* @__PURE__ */ Symbol.for("react.suspense_list"), T = /* @__PURE__ */ Symbol.for("react.memo"), S = /* @__PURE__ */ Symbol.for("react.lazy"), Y = /* @__PURE__ */ Symbol.for("react.offscreen"), te = Symbol.iterator, Ie = "@@iterator";
+    function Ae(e) {
+      if (e === null || typeof e != "object")
+        return null;
+      var r = te && e[te] || e[Ie];
+      return typeof r == "function" ? r : null;
+    }
+    var x = t.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+    function m(e) {
+      {
+        for (var r = arguments.length, n = new Array(r > 1 ? r - 1 : 0), a = 1; a < r; a++)
+          n[a - 1] = arguments[a];
+        Ve("error", e, n);
+      }
+    }
+    function Ve(e, r, n) {
+      {
+        var a = x.ReactDebugCurrentFrame, s = a.getStackAddendum();
+        s !== "" && (r += "%s", n = n.concat([s]));
+        var f = n.map(function(u) {
+          return String(u);
+        });
+        f.unshift("Warning: " + r), Function.prototype.apply.call(console[e], console, f);
+      }
+    }
+    var $e = !1, Ue = !1, We = !1, Ye = !1, Me = !1, ae;
+    ae = /* @__PURE__ */ Symbol.for("react.module.reference");
+    function Le(e) {
+      return !!(typeof e == "string" || typeof e == "function" || e === d || e === c || Me || e === v || e === j || e === _ || Ye || e === Y || $e || Ue || We || typeof e == "object" && e !== null && (e.$$typeof === S || e.$$typeof === T || e.$$typeof === g || e.$$typeof === h || e.$$typeof === p || // This needs to include all possible module reference object
+      // types supported by any Flight configuration anywhere since
+      // we don't know which Flight build this will end up being used
+      // with.
+      e.$$typeof === ae || e.getModuleId !== void 0));
+    }
+    function Be(e, r, n) {
+      var a = e.displayName;
+      if (a)
+        return a;
+      var s = r.displayName || r.name || "";
+      return s !== "" ? n + "(" + s + ")" : n;
+    }
+    function oe(e) {
+      return e.displayName || "Context";
+    }
+    function O(e) {
+      if (e == null)
+        return null;
+      if (typeof e.tag == "number" && m("Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."), typeof e == "function")
+        return e.displayName || e.name || null;
+      if (typeof e == "string")
+        return e;
+      switch (e) {
+        case d:
+          return "Fragment";
+        case l:
+          return "Portal";
+        case c:
+          return "Profiler";
+        case v:
+          return "StrictMode";
+        case j:
+          return "Suspense";
+        case _:
+          return "SuspenseList";
+      }
+      if (typeof e == "object")
+        switch (e.$$typeof) {
+          case h:
+            var r = e;
+            return oe(r) + ".Consumer";
+          case g:
+            var n = e;
+            return oe(n._context) + ".Provider";
+          case p:
+            return Be(e, e.render, "ForwardRef");
+          case T:
+            var a = e.displayName || null;
+            return a !== null ? a : O(e.type) || "Memo";
+          case S: {
+            var s = e, f = s._payload, u = s._init;
+            try {
+              return O(u(f));
+            } catch {
+              return null;
+            }
+          }
+        }
+      return null;
+    }
+    var w = Object.assign, A = 0, ie, ue, le, se, ce, fe, de;
+    function ve() {
+    }
+    ve.__reactDisabledLog = !0;
+    function Ne() {
+      {
+        if (A === 0) {
+          ie = console.log, ue = console.info, le = console.warn, se = console.error, ce = console.group, fe = console.groupCollapsed, de = console.groupEnd;
+          var e = {
+            configurable: !0,
+            enumerable: !0,
+            value: ve,
+            writable: !0
+          };
+          Object.defineProperties(console, {
+            info: e,
+            log: e,
+            warn: e,
+            error: e,
+            group: e,
+            groupCollapsed: e,
+            groupEnd: e
+          });
+        }
+        A++;
+      }
+    }
+    function qe() {
+      {
+        if (A--, A === 0) {
+          var e = {
+            configurable: !0,
+            enumerable: !0,
+            writable: !0
+          };
+          Object.defineProperties(console, {
+            log: w({}, e, {
+              value: ie
+            }),
+            info: w({}, e, {
+              value: ue
+            }),
+            warn: w({}, e, {
+              value: le
+            }),
+            error: w({}, e, {
+              value: se
+            }),
+            group: w({}, e, {
+              value: ce
+            }),
+            groupCollapsed: w({}, e, {
+              value: fe
+            }),
+            groupEnd: w({}, e, {
+              value: de
+            })
+          });
+        }
+        A < 0 && m("disabledDepth fell below zero. This is a bug in React. Please file an issue.");
+      }
+    }
+    var K = x.ReactCurrentDispatcher, G;
+    function M(e, r, n) {
+      {
+        if (G === void 0)
+          try {
+            throw Error();
+          } catch (s) {
+            var a = s.stack.trim().match(/\n( *(at )?)/);
+            G = a && a[1] || "";
+          }
+        return `
+` + G + e;
+      }
+    }
+    var z = !1, L;
+    {
+      var Je = typeof WeakMap == "function" ? WeakMap : Map;
+      L = new Je();
+    }
+    function ge(e, r) {
+      if (!e || z)
+        return "";
+      {
+        var n = L.get(e);
+        if (n !== void 0)
+          return n;
+      }
+      var a;
+      z = !0;
+      var s = Error.prepareStackTrace;
+      Error.prepareStackTrace = void 0;
+      var f;
+      f = K.current, K.current = null, Ne();
+      try {
+        if (r) {
+          var u = function() {
+            throw Error();
+          };
+          if (Object.defineProperty(u.prototype, "props", {
+            set: function() {
+              throw Error();
+            }
+          }), typeof Reflect == "object" && Reflect.construct) {
+            try {
+              Reflect.construct(u, []);
+            } catch (E) {
+              a = E;
+            }
+            Reflect.construct(e, [], u);
+          } else {
+            try {
+              u.call();
+            } catch (E) {
+              a = E;
+            }
+            e.call(u.prototype);
+          }
+        } else {
+          try {
+            throw Error();
+          } catch (E) {
+            a = E;
+          }
+          e();
+        }
+      } catch (E) {
+        if (E && a && typeof E.stack == "string") {
+          for (var i = E.stack.split(`
+`), y = a.stack.split(`
+`), R = i.length - 1, b = y.length - 1; R >= 1 && b >= 0 && i[R] !== y[b]; )
+            b--;
+          for (; R >= 1 && b >= 0; R--, b--)
+            if (i[R] !== y[b]) {
+              if (R !== 1 || b !== 1)
+                do
+                  if (R--, b--, b < 0 || i[R] !== y[b]) {
+                    var C = `
+` + i[R].replace(" at new ", " at ");
+                    return e.displayName && C.includes("<anonymous>") && (C = C.replace("<anonymous>", e.displayName)), typeof e == "function" && L.set(e, C), C;
+                  }
+                while (R >= 1 && b >= 0);
+              break;
+            }
+        }
+      } finally {
+        z = !1, K.current = f, qe(), Error.prepareStackTrace = s;
+      }
+      var D = e ? e.displayName || e.name : "", P = D ? M(D) : "";
+      return typeof e == "function" && L.set(e, P), P;
+    }
+    function Ke(e, r, n) {
+      return ge(e, !1);
+    }
+    function Ge(e) {
+      var r = e.prototype;
+      return !!(r && r.isReactComponent);
+    }
+    function B(e, r, n) {
+      if (e == null)
+        return "";
+      if (typeof e == "function")
+        return ge(e, Ge(e));
+      if (typeof e == "string")
+        return M(e);
+      switch (e) {
+        case j:
+          return M("Suspense");
+        case _:
+          return M("SuspenseList");
+      }
+      if (typeof e == "object")
+        switch (e.$$typeof) {
+          case p:
+            return Ke(e.render);
+          case T:
+            return B(e.type, r, n);
+          case S: {
+            var a = e, s = a._payload, f = a._init;
+            try {
+              return B(f(s), r, n);
+            } catch {
+            }
+          }
+        }
+      return "";
+    }
+    var V = Object.prototype.hasOwnProperty, he = {}, Re = x.ReactDebugCurrentFrame;
+    function N(e) {
+      if (e) {
+        var r = e._owner, n = B(e.type, e._source, r ? r.type : null);
+        Re.setExtraStackFrame(n);
+      } else
+        Re.setExtraStackFrame(null);
+    }
+    function ze(e, r, n, a, s) {
+      {
+        var f = Function.call.bind(V);
+        for (var u in e)
+          if (f(e, u)) {
+            var i = void 0;
+            try {
+              if (typeof e[u] != "function") {
+                var y = Error((a || "React class") + ": " + n + " type `" + u + "` is invalid; it must be a function, usually from the `prop-types` package, but received `" + typeof e[u] + "`.This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`.");
+                throw y.name = "Invariant Violation", y;
+              }
+              i = e[u](r, u, a, n, null, "SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED");
+            } catch (R) {
+              i = R;
+            }
+            i && !(i instanceof Error) && (N(s), m("%s: type specification of %s `%s` is invalid; the type checker function must return `null` or an `Error` but returned a %s. You may have forgotten to pass an argument to the type checker creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and shape all require an argument).", a || "React class", n, u, typeof i), N(null)), i instanceof Error && !(i.message in he) && (he[i.message] = !0, N(s), m("Failed %s type: %s", n, i.message), N(null));
+          }
+      }
+    }
+    var Xe = Array.isArray;
+    function X(e) {
+      return Xe(e);
+    }
+    function He(e) {
+      {
+        var r = typeof Symbol == "function" && Symbol.toStringTag, n = r && e[Symbol.toStringTag] || e.constructor.name || "Object";
+        return n;
+      }
+    }
+    function Ze(e) {
+      try {
+        return be(e), !1;
+      } catch {
+        return !0;
+      }
+    }
+    function be(e) {
+      return "" + e;
+    }
+    function pe(e) {
+      if (Ze(e))
+        return m("The provided key is an unsupported type %s. This value must be coerced to a string before before using it here.", He(e)), be(e);
+    }
+    var me = x.ReactCurrentOwner, Qe = {
+      key: !0,
+      ref: !0,
+      __self: !0,
+      __source: !0
+    }, ye, Ee;
+    function er(e) {
+      if (V.call(e, "ref")) {
+        var r = Object.getOwnPropertyDescriptor(e, "ref").get;
+        if (r && r.isReactWarning)
+          return !1;
+      }
+      return e.ref !== void 0;
+    }
+    function rr(e) {
+      if (V.call(e, "key")) {
+        var r = Object.getOwnPropertyDescriptor(e, "key").get;
+        if (r && r.isReactWarning)
+          return !1;
+      }
+      return e.key !== void 0;
+    }
+    function nr(e, r) {
+      typeof e.ref == "string" && me.current;
+    }
+    function tr(e, r) {
+      {
+        var n = function() {
+          ye || (ye = !0, m("%s: `key` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://reactjs.org/link/special-props)", r));
+        };
+        n.isReactWarning = !0, Object.defineProperty(e, "key", {
+          get: n,
+          configurable: !0
+        });
+      }
+    }
+    function ar(e, r) {
+      {
+        var n = function() {
+          Ee || (Ee = !0, m("%s: `ref` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://reactjs.org/link/special-props)", r));
+        };
+        n.isReactWarning = !0, Object.defineProperty(e, "ref", {
+          get: n,
+          configurable: !0
+        });
+      }
+    }
+    var or = function(e, r, n, a, s, f, u) {
+      var i = {
+        // This tag allows us to uniquely identify this as a React Element
+        $$typeof: o,
+        // Built-in properties that belong on the element
+        type: e,
+        key: r,
+        ref: n,
+        props: u,
+        // Record the component responsible for creating this element.
+        _owner: f
+      };
+      return i._store = {}, Object.defineProperty(i._store, "validated", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !0,
+        value: !1
+      }), Object.defineProperty(i, "_self", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !1,
+        value: a
+      }), Object.defineProperty(i, "_source", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !1,
+        value: s
+      }), Object.freeze && (Object.freeze(i.props), Object.freeze(i)), i;
+    };
+    function ir(e, r, n, a, s) {
+      {
+        var f, u = {}, i = null, y = null;
+        n !== void 0 && (pe(n), i = "" + n), rr(r) && (pe(r.key), i = "" + r.key), er(r) && (y = r.ref, nr(r, s));
+        for (f in r)
+          V.call(r, f) && !Qe.hasOwnProperty(f) && (u[f] = r[f]);
+        if (e && e.defaultProps) {
+          var R = e.defaultProps;
+          for (f in R)
+            u[f] === void 0 && (u[f] = R[f]);
+        }
+        if (i || y) {
+          var b = typeof e == "function" ? e.displayName || e.name || "Unknown" : e;
+          i && tr(u, b), y && ar(u, b);
+        }
+        return or(e, i, y, s, a, me.current, u);
+      }
+    }
+    var H = x.ReactCurrentOwner, _e = x.ReactDebugCurrentFrame;
+    function k(e) {
+      if (e) {
+        var r = e._owner, n = B(e.type, e._source, r ? r.type : null);
+        _e.setExtraStackFrame(n);
+      } else
+        _e.setExtraStackFrame(null);
+    }
+    var Z;
+    Z = !1;
+    function Q(e) {
+      return typeof e == "object" && e !== null && e.$$typeof === o;
+    }
+    function Ce() {
+      {
+        if (H.current) {
+          var e = O(H.current.type);
+          if (e)
+            return `
+
+Check the render method of \`` + e + "`.";
+        }
+        return "";
+      }
+    }
+    function ur(e) {
+      return "";
+    }
+    var Te = {};
+    function lr(e) {
+      {
+        var r = Ce();
+        if (!r) {
+          var n = typeof e == "string" ? e : e.displayName || e.name;
+          n && (r = `
+
+Check the top-level render call using <` + n + ">.");
+        }
+        return r;
+      }
+    }
+    function Oe(e, r) {
+      {
+        if (!e._store || e._store.validated || e.key != null)
+          return;
+        e._store.validated = !0;
+        var n = lr(r);
+        if (Te[n])
+          return;
+        Te[n] = !0;
+        var a = "";
+        e && e._owner && e._owner !== H.current && (a = " It was passed a child from " + O(e._owner.type) + "."), k(e), m('Each child in a list should have a unique "key" prop.%s%s See https://reactjs.org/link/warning-keys for more information.', n, a), k(null);
+      }
+    }
+    function Se(e, r) {
+      {
+        if (typeof e != "object")
+          return;
+        if (X(e))
+          for (var n = 0; n < e.length; n++) {
+            var a = e[n];
+            Q(a) && Oe(a, r);
+          }
+        else if (Q(e))
+          e._store && (e._store.validated = !0);
+        else if (e) {
+          var s = Ae(e);
+          if (typeof s == "function" && s !== e.entries)
+            for (var f = s.call(e), u; !(u = f.next()).done; )
+              Q(u.value) && Oe(u.value, r);
+        }
+      }
+    }
+    function sr(e) {
+      {
+        var r = e.type;
+        if (r == null || typeof r == "string")
+          return;
+        var n;
+        if (typeof r == "function")
+          n = r.propTypes;
+        else if (typeof r == "object" && (r.$$typeof === p || // Note: Memo only checks outer props here.
+        // Inner props are checked in the reconciler.
+        r.$$typeof === T))
+          n = r.propTypes;
+        else
+          return;
+        if (n) {
+          var a = O(r);
+          ze(n, e.props, "prop", a, e);
+        } else if (r.PropTypes !== void 0 && !Z) {
+          Z = !0;
+          var s = O(r);
+          m("Component %s declared `PropTypes` instead of `propTypes`. Did you misspell the property assignment?", s || "Unknown");
+        }
+        typeof r.getDefaultProps == "function" && !r.getDefaultProps.isReactClassApproved && m("getDefaultProps is only used on classic React.createClass definitions. Use a static property named `defaultProps` instead.");
+      }
+    }
+    function cr(e) {
+      {
+        for (var r = Object.keys(e.props), n = 0; n < r.length; n++) {
+          var a = r[n];
+          if (a !== "children" && a !== "key") {
+            k(e), m("Invalid prop `%s` supplied to `React.Fragment`. React.Fragment can only have `key` and `children` props.", a), k(null);
+            break;
+          }
+        }
+        e.ref !== null && (k(e), m("Invalid attribute `ref` supplied to `React.Fragment`."), k(null));
+      }
+    }
+    var we = {};
+    function Pe(e, r, n, a, s, f) {
+      {
+        var u = Le(e);
+        if (!u) {
+          var i = "";
+          (e === void 0 || typeof e == "object" && e !== null && Object.keys(e).length === 0) && (i += " You likely forgot to export your component from the file it's defined in, or you might have mixed up default and named imports.");
+          var y = ur();
+          y ? i += y : i += Ce();
+          var R;
+          e === null ? R = "null" : X(e) ? R = "array" : e !== void 0 && e.$$typeof === o ? (R = "<" + (O(e.type) || "Unknown") + " />", i = " Did you accidentally export a JSX literal instead of a component?") : R = typeof e, m("React.jsx: type is invalid -- expected a string (for built-in components) or a class/function (for composite components) but got: %s.%s", R, i);
+        }
+        var b = ir(e, r, n, s, f);
+        if (b == null)
+          return b;
+        if (u) {
+          var C = r.children;
+          if (C !== void 0)
+            if (a)
+              if (X(C)) {
+                for (var D = 0; D < C.length; D++)
+                  Se(C[D], e);
+                Object.freeze && Object.freeze(C);
+              } else
+                m("React.jsx: Static children should always be an array. You are likely explicitly calling React.jsxs or React.jsxDEV. Use the Babel transform instead.");
+            else
+              Se(C, e);
+        }
+        if (V.call(r, "key")) {
+          var P = O(e), E = Object.keys(r).filter(function(Rr) {
+            return Rr !== "key";
+          }), ee = E.length > 0 ? "{key: someKey, " + E.join(": ..., ") + ": ...}" : "{key: someKey}";
+          if (!we[P + ee]) {
+            var hr = E.length > 0 ? "{" + E.join(": ..., ") + ": ...}" : "{}";
+            m(`A props object containing a "key" prop is being spread into JSX:
+  let props = %s;
+  <%s {...props} />
+React keys must be passed directly to JSX without using spread:
+  let props = %s;
+  <%s key={someKey} {...props} />`, ee, P, hr, P), we[P + ee] = !0;
+          }
+        }
+        return e === d ? cr(b) : sr(b), b;
+      }
+    }
+    function fr(e, r, n) {
+      return Pe(e, r, n, !0);
+    }
+    function dr(e, r, n) {
+      return Pe(e, r, n, !1);
+    }
+    var vr = dr, gr = fr;
+    U.Fragment = d, U.jsx = vr, U.jsxs = gr;
+  })()), U;
+}
+var xe;
+function Cr() {
+  return xe || (xe = 1, process.env.NODE_ENV === "production" ? q.exports = Er() : q.exports = _r()), q.exports;
+}
+var ke = Cr();
+function Fr(t) {
+  const o = re(null), l = mr(t.form, t.path, {
+    overrideInitialValue: t.overrideInitialValue ?? !0,
+    defaultValue: typeof t.defaultValue == "function" ? t.defaultValue() : t.defaultValue
+  }), d = {
+    onChange(v) {
+      const { target: c } = v;
+      c === l.boundElement && "value" in c && typeof c.value == "string" && l.setValue(c.value, {
+        shouldTouch: !0,
+        shouldMarkDirty: !0
+      });
+    },
+    onFocus() {
+      l.touch();
+    },
+    onBlur() {
+      (t.form.hookConfigs?.validateMode === "onBlur" || t.form.hookConfigs?.validateMode === "onChange") && t.form.controller.validateField(t.path);
+    }
+  };
+  return I(() => {
+    const { events: v } = t.form.controller;
+    return W(
+      v.on("valueChanged", (c) => {
+        c !== t.path && !F.isDescendant(c, t.path) || t.form.hookConfigs?.validateMode === "onChange" && t.form.controller.validateField(t.path);
+      })
+    );
+  }, []), I(() => (l.bindElement(o.current), () => {
+    t.unbindOnUnmount && t.form.controller.unbindField(t.path);
+  }), []), /* @__PURE__ */ ke.jsx(ke.Fragment, { children: t.render({
+    ref: o,
+    value: l.value,
+    handlers: d,
+    field: l
+  }) });
+}
+export {
+  Fr as FieldRenderer,
+  Sr as useForm,
+  Pr as useFormErrorObserver,
+  mr as useFormField,
+  wr as useFormValuesObserver,
+  J as useRenderControl
+};
+//# sourceMappingURL=index.js.map