@tsed/react-formio 2.3.6 → 3.0.0-alpha.10

package/dist/organisms/form/useForm.js

@@ -0,0 +1,776 @@
+import { Form as oe } from "formiojs";
+import { useRef as $, useState as ae, useEffect as G } from "react";
+var re = { exports: {} };
+/*!
+ * EventEmitter2
+ * https://github.com/hij1nx/EventEmitter2
+ *
+ * Copyright (c) 2013 hij1nx
+ * Licensed under the MIT license.
+ */
+(function(g, _) {
+  (function(h) {
+    var p = Object.hasOwnProperty, L = Array.isArray ? Array.isArray : function(r) {
+      return Object.prototype.toString.call(r) === "[object Array]";
+    }, x = 10, F = typeof process == "object" && typeof process.nextTick == "function", T = typeof Symbol == "function", A = typeof Reflect == "object", S = typeof setImmediate == "function", I = S ? setImmediate : setTimeout, w = T ? A && typeof Reflect.ownKeys == "function" ? Reflect.ownKeys : function(e) {
+      var r = Object.getOwnPropertyNames(e);
+      return r.push.apply(r, Object.getOwnPropertySymbols(e)), r;
+    } : Object.keys;
+    function M() {
+      this._events = {}, this._conf && O.call(this, this._conf);
+    }
+    function O(e) {
+      e && (this._conf = e, e.delimiter && (this.delimiter = e.delimiter), e.maxListeners !== h && (this._maxListeners = e.maxListeners), e.wildcard && (this.wildcard = e.wildcard), e.newListener && (this._newListener = e.newListener), e.removeListener && (this._removeListener = e.removeListener), e.verboseMemoryLeak && (this.verboseMemoryLeak = e.verboseMemoryLeak), e.ignoreErrors && (this.ignoreErrors = e.ignoreErrors), this.wildcard && (this.listenerTree = {}));
+    }
+    function U(e, r) {
+      var t = "(node) warning: possible EventEmitter memory leak detected. " + e + " listeners added. Use emitter.setMaxListeners() to increase limit.";
+      if (this.verboseMemoryLeak && (t += " Event name: " + r + "."), typeof process < "u" && process.emitWarning) {
+        var i = new Error(t);
+        i.name = "MaxListenersExceededWarning", i.emitter = this, i.count = e, process.emitWarning(i);
+      } else
+        console.error(t), console.trace && console.trace();
+    }
+    var P = function(e, r, t) {
+      var i = arguments.length;
+      switch (i) {
+        case 0:
+          return [];
+        case 1:
+          return [e];
+        case 2:
+          return [e, r];
+        case 3:
+          return [e, r, t];
+        default:
+          for (var s = new Array(i); i--; )
+            s[i] = arguments[i];
+          return s;
+      }
+    };
+    function j(e, r) {
+      for (var t = {}, i, s = e.length, n = 0, o = 0; o < s; o++)
+        i = e[o], t[i] = o < n ? r[o] : h;
+      return t;
+    }
+    function J(e, r, t) {
+      this._emitter = e, this._target = r, this._listeners = {}, this._listenersCount = 0;
+      var i, s;
+      if ((t.on || t.off) && (i = t.on, s = t.off), r.addEventListener ? (i = r.addEventListener, s = r.removeEventListener) : r.addListener ? (i = r.addListener, s = r.removeListener) : r.on && (i = r.on, s = r.off), !i && !s)
+        throw Error("target does not implement any known event API");
+      if (typeof i != "function")
+        throw TypeError("on method must be a function");
+      if (typeof s != "function")
+        throw TypeError("off method must be a function");
+      this._on = i, this._off = s;
+      var n = e._observers;
+      n ? n.push(this) : e._observers = [this];
+    }
+    Object.assign(J.prototype, {
+      subscribe: function(e, r, t) {
+        var i = this, s = this._target, n = this._emitter, o = this._listeners, f = function() {
+          var a = P.apply(null, arguments), l = {
+            data: a,
+            name: r,
+            original: e
+          };
+          if (t) {
+            var u = t.call(s, l);
+            u !== !1 && n.emit.apply(n, [l.name].concat(a));
+            return;
+          }
+          n.emit.apply(n, [r].concat(a));
+        };
+        if (o[e])
+          throw Error("Event '" + e + "' is already listening");
+        this._listenersCount++, n._newListener && n._removeListener && !i._onNewListener ? (this._onNewListener = function(a) {
+          a === r && o[e] === null && (o[e] = f, i._on.call(s, e, f));
+        }, n.on("newListener", this._onNewListener), this._onRemoveListener = function(a) {
+          a === r && !n.hasListeners(a) && o[e] && (o[e] = null, i._off.call(s, e, f));
+        }, o[e] = null, n.on("removeListener", this._onRemoveListener)) : (o[e] = f, i._on.call(s, e, f));
+      },
+      unsubscribe: function(e) {
+        var r = this, t = this._listeners, i = this._emitter, s, n, o = this._off, f = this._target, a;
+        if (e && typeof e != "string")
+          throw TypeError("event must be a string");
+        function l() {
+          r._onNewListener && (i.off("newListener", r._onNewListener), i.off("removeListener", r._onRemoveListener), r._onNewListener = null, r._onRemoveListener = null);
+          var u = X.call(i, r);
+          i._observers.splice(u, 1);
+        }
+        if (e) {
+          if (s = t[e], !s) return;
+          o.call(f, e, s), delete t[e], --this._listenersCount || l();
+        } else {
+          for (n = w(t), a = n.length; a-- > 0; )
+            e = n[a], o.call(f, e, t[e]);
+          this._listeners = {}, this._listenersCount = 0, l();
+        }
+      }
+    });
+    function C(e, r, t, i) {
+      var s = Object.assign({}, r);
+      if (!e) return s;
+      if (typeof e != "object")
+        throw TypeError("options must be an object");
+      var n = Object.keys(e), o = n.length, f, a, l;
+      function u(v) {
+        throw Error('Invalid "' + f + '" option value' + (v ? ". Reason: " + v : ""));
+      }
+      for (var y = 0; y < o; y++) {
+        if (f = n[y], !p.call(r, f))
+          throw Error('Unknown "' + f + '" option');
+        a = e[f], a !== h && (l = t[f], s[f] = l ? l(a, u) : a);
+      }
+      return s;
+    }
+    function z(e, r) {
+      return (typeof e != "function" || !e.hasOwnProperty("prototype")) && r("value must be a constructor"), e;
+    }
+    function H(e) {
+      var r = "value must be type of " + e.join("|"), t = e.length, i = e[0], s = e[1];
+      return t === 1 ? function(n, o) {
+        if (typeof n === i)
+          return n;
+        o(r);
+      } : t === 2 ? function(n, o) {
+        var f = typeof n;
+        if (f === i || f === s) return n;
+        o(r);
+      } : function(n, o) {
+        for (var f = typeof n, a = t; a-- > 0; )
+          if (f === e[a]) return n;
+        o(r);
+      };
+    }
+    var W = H(["function"]), te = H(["object", "function"]);
+    function Q(e, r, t) {
+      var i, s, n = 0, o, f = new e(function(a, l, u) {
+        t = C(t, {
+          timeout: 0,
+          overload: !1
+        }, {
+          timeout: function(b, E) {
+            return b *= 1, (typeof b != "number" || b < 0 || !Number.isFinite(b)) && E("timeout must be a positive number"), b;
+          }
+        }), i = !t.overload && typeof e.prototype.cancel == "function" && typeof u == "function";
+        function y() {
+          s && (s = null), n && (clearTimeout(n), n = 0);
+        }
+        var v = function(b) {
+          y(), a(b);
+        }, m = function(b) {
+          y(), l(b);
+        };
+        i ? r(v, m, u) : (s = [function(b) {
+          m(b || Error("canceled"));
+        }], r(v, m, function(b) {
+          if (o)
+            throw Error("Unable to subscribe on cancel event asynchronously");
+          if (typeof b != "function")
+            throw TypeError("onCancel callback must be a function");
+          s.push(b);
+        }), o = !0), t.timeout > 0 && (n = setTimeout(function() {
+          var b = Error("timeout");
+          b.code = "ETIMEDOUT", n = 0, f.cancel(b), l(b);
+        }, t.timeout));
+      });
+      return i || (f.cancel = function(a) {
+        if (s) {
+          for (var l = s.length, u = 1; u < l; u++)
+            s[u](a);
+          s[0](a), s = null;
+        }
+      }), f;
+    }
+    function X(e) {
+      var r = this._observers;
+      if (!r)
+        return -1;
+      for (var t = r.length, i = 0; i < t; i++)
+        if (r[i]._target === e) return i;
+      return -1;
+    }
+    function d(e, r, t, i, s) {
+      if (!t)
+        return null;
+      if (i === 0) {
+        var n = typeof r;
+        if (n === "string") {
+          var o, f, a = 0, l = 0, u = this.delimiter, y = u.length;
+          if ((f = r.indexOf(u)) !== -1) {
+            o = new Array(5);
+            do
+              o[a++] = r.slice(l, f), l = f + y;
+            while ((f = r.indexOf(u, l)) !== -1);
+            o[a++] = r.slice(l), r = o, s = a;
+          } else
+            r = [r], s = 1;
+        } else n === "object" ? s = r.length : (r = [r], s = 1);
+      }
+      var v = null, m, b, E, B, D, N = r[i], q = r[i + 1], R, k;
+      if (i === s)
+        t._listeners && (typeof t._listeners == "function" ? (e && e.push(t._listeners), v = [t]) : (e && e.push.apply(e, t._listeners), v = [t]));
+      else if (N === "*") {
+        for (R = w(t), f = R.length; f-- > 0; )
+          m = R[f], m !== "_listeners" && (k = d(e, r, t[m], i + 1, s), k && (v ? v.push.apply(v, k) : v = k));
+        return v;
+      } else if (N === "**") {
+        for (D = i + 1 === s || i + 2 === s && q === "*", D && t._listeners && (v = d(e, r, t, s, s)), R = w(t), f = R.length; f-- > 0; )
+          m = R[f], m !== "_listeners" && (m === "*" || m === "**" ? (t[m]._listeners && !D && (k = d(e, r, t[m], s, s), k && (v ? v.push.apply(v, k) : v = k)), k = d(e, r, t[m], i, s)) : m === q ? k = d(e, r, t[m], i + 2, s) : k = d(e, r, t[m], i, s), k && (v ? v.push.apply(v, k) : v = k));
+        return v;
+      } else t[N] && (v = d(e, r, t[N], i + 1, s));
+      if (b = t["*"], b && d(e, r, b, i + 1, s), E = t["**"], E)
+        if (i < s)
+          for (E._listeners && d(e, r, E, s, s), R = w(E), f = R.length; f-- > 0; )
+            m = R[f], m !== "_listeners" && (m === q ? d(e, r, E[m], i + 2, s) : m === N ? d(e, r, E[m], i + 1, s) : (B = {}, B[m] = E[m], d(e, r, { "**": B }, i + 1, s)));
+        else E._listeners ? d(e, r, E, s, s) : E["*"] && E["*"]._listeners && d(e, r, E["*"], s, s);
+      return v;
+    }
+    function ie(e, r, t) {
+      var i = 0, s = 0, n, o = this.delimiter, f = o.length, a;
+      if (typeof e == "string")
+        if ((n = e.indexOf(o)) !== -1) {
+          a = new Array(5);
+          do
+            a[i++] = e.slice(s, n), s = n + f;
+          while ((n = e.indexOf(o, s)) !== -1);
+          a[i++] = e.slice(s);
+        } else
+          a = [e], i = 1;
+      else
+        a = e, i = e.length;
+      if (i > 1) {
+        for (n = 0; n + 1 < i; n++)
+          if (a[n] === "**" && a[n + 1] === "**")
+            return;
+      }
+      var l = this.listenerTree, u;
+      for (n = 0; n < i; n++)
+        if (u = a[n], l = l[u] || (l[u] = {}), n === i - 1)
+          return l._listeners ? (typeof l._listeners == "function" && (l._listeners = [l._listeners]), t ? l._listeners.unshift(r) : l._listeners.push(r), !l._listeners.warned && this._maxListeners > 0 && l._listeners.length > this._maxListeners && (l._listeners.warned = !0, U.call(this, l._listeners.length, u))) : l._listeners = r, !0;
+      return !0;
+    }
+    function Y(e, r, t, i) {
+      for (var s = w(e), n = s.length, o, f, a, l = e._listeners, u; n-- > 0; )
+        f = s[n], o = e[f], f === "_listeners" ? a = t : a = t ? t.concat(f) : [f], u = i || typeof f == "symbol", l && r.push(u ? a : a.join(this.delimiter)), typeof o == "object" && Y.call(this, o, r, a, u);
+      return r;
+    }
+    function K(e) {
+      for (var r = w(e), t = r.length, i, s, n; t-- > 0; )
+        s = r[t], i = e[s], i && (n = !0, s !== "_listeners" && !K(i) && delete e[s]);
+      return n;
+    }
+    function Z(e, r, t) {
+      this.emitter = e, this.event = r, this.listener = t;
+    }
+    Z.prototype.off = function() {
+      return this.emitter.off(this.event, this.listener), this;
+    };
+    function se(e, r, t) {
+      if (t === !0)
+        s = !0;
+      else if (t === !1)
+        i = !0;
+      else {
+        if (!t || typeof t != "object")
+          throw TypeError("options should be an object or true");
+        var i = t.async, s = t.promisify, n = t.nextTick, o = t.objectify;
+      }
+      if (i || n || s) {
+        var f = r, a = r._origin || r;
+        if (n && !F)
+          throw Error("process.nextTick is not supported");
+        s === h && (s = r.constructor.name === "AsyncFunction"), r = function() {
+          var l = arguments, u = this, y = this.event;
+          return s ? n ? Promise.resolve() : new Promise(function(v) {
+            I(v);
+          }).then(function() {
+            return u.event = y, f.apply(u, l);
+          }) : (n ? process.nextTick : I)(function() {
+            u.event = y, f.apply(u, l);
+          });
+        }, r._async = !0, r._origin = a;
+      }
+      return [r, o ? new Z(this, e, r) : this];
+    }
+    function c(e) {
+      this._events = {}, this._newListener = !1, this._removeListener = !1, this.verboseMemoryLeak = !1, O.call(this, e);
+    }
+    c.EventEmitter2 = c, c.prototype.listenTo = function(e, r, t) {
+      if (typeof e != "object")
+        throw TypeError("target musts be an object");
+      var i = this;
+      t = C(t, {
+        on: h,
+        off: h,
+        reducers: h
+      }, {
+        on: W,
+        off: W,
+        reducers: te
+      });
+      function s(n) {
+        if (typeof n != "object")
+          throw TypeError("events must be an object");
+        var o = t.reducers, f = X.call(i, e), a;
+        f === -1 ? a = new J(i, e, t) : a = i._observers[f];
+        for (var l = w(n), u = l.length, y, v = typeof o == "function", m = 0; m < u; m++)
+          y = l[m], a.subscribe(
+            y,
+            n[y] || y,
+            v ? o : o && o[y]
+          );
+      }
+      return L(r) ? s(j(r)) : s(typeof r == "string" ? j(r.split(/\s+/)) : r), this;
+    }, c.prototype.stopListeningTo = function(e, r) {
+      var t = this._observers;
+      if (!t)
+        return !1;
+      var i = t.length, s, n = !1;
+      if (e && typeof e != "object")
+        throw TypeError("target should be an object");
+      for (; i-- > 0; )
+        s = t[i], (!e || s._target === e) && (s.unsubscribe(r), n = !0);
+      return n;
+    }, c.prototype.delimiter = ".", c.prototype.setMaxListeners = function(e) {
+      e !== h && (this._maxListeners = e, this._conf || (this._conf = {}), this._conf.maxListeners = e);
+    }, c.prototype.getMaxListeners = function() {
+      return this._maxListeners;
+    }, c.prototype.event = "", c.prototype.once = function(e, r, t) {
+      return this._once(e, r, !1, t);
+    }, c.prototype.prependOnceListener = function(e, r, t) {
+      return this._once(e, r, !0, t);
+    }, c.prototype._once = function(e, r, t, i) {
+      return this._many(e, 1, r, t, i);
+    }, c.prototype.many = function(e, r, t, i) {
+      return this._many(e, r, t, !1, i);
+    }, c.prototype.prependMany = function(e, r, t, i) {
+      return this._many(e, r, t, !0, i);
+    }, c.prototype._many = function(e, r, t, i, s) {
+      var n = this;
+      if (typeof t != "function")
+        throw new Error("many only accepts instances of Function");
+      function o() {
+        return --r === 0 && n.off(e, o), t.apply(this, arguments);
+      }
+      return o._origin = t, this._on(e, o, i, s);
+    }, c.prototype.emit = function() {
+      if (!this._events && !this._all)
+        return !1;
+      this._events || M.call(this);
+      var e = arguments[0], r, t = this.wildcard, i, s, n, o, f;
+      if (e === "newListener" && !this._newListener && !this._events.newListener)
+        return !1;
+      if (t && (r = e, e !== "newListener" && e !== "removeListener" && typeof e == "object")) {
+        if (s = e.length, T) {
+          for (n = 0; n < s; n++)
+            if (typeof e[n] == "symbol") {
+              f = !0;
+              break;
+            }
+        }
+        f || (e = e.join(this.delimiter));
+      }
+      var a = arguments.length, l;
+      if (this._all && this._all.length)
+        for (l = this._all.slice(), n = 0, s = l.length; n < s; n++)
+          switch (this.event = e, a) {
+            case 1:
+              l[n].call(this, e);
+              break;
+            case 2:
+              l[n].call(this, e, arguments[1]);
+              break;
+            case 3:
+              l[n].call(this, e, arguments[1], arguments[2]);
+              break;
+            default:
+              l[n].apply(this, arguments);
+          }
+      if (t)
+        l = [], d.call(this, l, r, this.listenerTree, 0, s);
+      else if (l = this._events[e], typeof l == "function") {
+        switch (this.event = e, a) {
+          case 1:
+            l.call(this);
+            break;
+          case 2:
+            l.call(this, arguments[1]);
+            break;
+          case 3:
+            l.call(this, arguments[1], arguments[2]);
+            break;
+          default:
+            for (i = new Array(a - 1), o = 1; o < a; o++) i[o - 1] = arguments[o];
+            l.apply(this, i);
+        }
+        return !0;
+      } else l && (l = l.slice());
+      if (l && l.length) {
+        if (a > 3)
+          for (i = new Array(a - 1), o = 1; o < a; o++) i[o - 1] = arguments[o];
+        for (n = 0, s = l.length; n < s; n++)
+          switch (this.event = e, a) {
+            case 1:
+              l[n].call(this);
+              break;
+            case 2:
+              l[n].call(this, arguments[1]);
+              break;
+            case 3:
+              l[n].call(this, arguments[1], arguments[2]);
+              break;
+            default:
+              l[n].apply(this, i);
+          }
+        return !0;
+      } else if (!this.ignoreErrors && !this._all && e === "error")
+        throw arguments[1] instanceof Error ? arguments[1] : new Error("Uncaught, unspecified 'error' event.");
+      return !!this._all;
+    }, c.prototype.emitAsync = function() {
+      if (!this._events && !this._all)
+        return !1;
+      this._events || M.call(this);
+      var e = arguments[0], r = this.wildcard, t, i, s, n, o, f;
+      if (e === "newListener" && !this._newListener && !this._events.newListener)
+        return Promise.resolve([!1]);
+      if (r && (t = e, e !== "newListener" && e !== "removeListener" && typeof e == "object")) {
+        if (n = e.length, T) {
+          for (o = 0; o < n; o++)
+            if (typeof e[o] == "symbol") {
+              i = !0;
+              break;
+            }
+        }
+        i || (e = e.join(this.delimiter));
+      }
+      var a = [], l = arguments.length, u;
+      if (this._all)
+        for (o = 0, n = this._all.length; o < n; o++)
+          switch (this.event = e, l) {
+            case 1:
+              a.push(this._all[o].call(this, e));
+              break;
+            case 2:
+              a.push(this._all[o].call(this, e, arguments[1]));
+              break;
+            case 3:
+              a.push(this._all[o].call(this, e, arguments[1], arguments[2]));
+              break;
+            default:
+              a.push(this._all[o].apply(this, arguments));
+          }
+      if (r ? (u = [], d.call(this, u, t, this.listenerTree, 0)) : u = this._events[e], typeof u == "function")
+        switch (this.event = e, l) {
+          case 1:
+            a.push(u.call(this));
+            break;
+          case 2:
+            a.push(u.call(this, arguments[1]));
+            break;
+          case 3:
+            a.push(u.call(this, arguments[1], arguments[2]));
+            break;
+          default:
+            for (s = new Array(l - 1), f = 1; f < l; f++) s[f - 1] = arguments[f];
+            a.push(u.apply(this, s));
+        }
+      else if (u && u.length) {
+        if (u = u.slice(), l > 3)
+          for (s = new Array(l - 1), f = 1; f < l; f++) s[f - 1] = arguments[f];
+        for (o = 0, n = u.length; o < n; o++)
+          switch (this.event = e, l) {
+            case 1:
+              a.push(u[o].call(this));
+              break;
+            case 2:
+              a.push(u[o].call(this, arguments[1]));
+              break;
+            case 3:
+              a.push(u[o].call(this, arguments[1], arguments[2]));
+              break;
+            default:
+              a.push(u[o].apply(this, s));
+          }
+      } else if (!this.ignoreErrors && !this._all && e === "error")
+        return arguments[1] instanceof Error ? Promise.reject(arguments[1]) : Promise.reject("Uncaught, unspecified 'error' event.");
+      return Promise.all(a);
+    }, c.prototype.on = function(e, r, t) {
+      return this._on(e, r, !1, t);
+    }, c.prototype.prependListener = function(e, r, t) {
+      return this._on(e, r, !0, t);
+    }, c.prototype.onAny = function(e) {
+      return this._onAny(e, !1);
+    }, c.prototype.prependAny = function(e) {
+      return this._onAny(e, !0);
+    }, c.prototype.addListener = c.prototype.on, c.prototype._onAny = function(e, r) {
+      if (typeof e != "function")
+        throw new Error("onAny only accepts instances of Function");
+      return this._all || (this._all = []), r ? this._all.unshift(e) : this._all.push(e), this;
+    }, c.prototype._on = function(e, r, t, i) {
+      if (typeof e == "function")
+        return this._onAny(e, r), this;
+      if (typeof r != "function")
+        throw new Error("on only accepts instances of Function");
+      this._events || M.call(this);
+      var s = this, n;
+      return i !== h && (n = se.call(this, e, r, i), r = n[0], s = n[1]), this._newListener && this.emit("newListener", e, r), this.wildcard ? (ie.call(this, e, r, t), s) : (this._events[e] ? (typeof this._events[e] == "function" && (this._events[e] = [this._events[e]]), t ? this._events[e].unshift(r) : this._events[e].push(r), !this._events[e].warned && this._maxListeners > 0 && this._events[e].length > this._maxListeners && (this._events[e].warned = !0, U.call(this, this._events[e].length, e))) : this._events[e] = r, s);
+    }, c.prototype.off = function(e, r) {
+      if (typeof r != "function")
+        throw new Error("removeListener only takes instances of Function");
+      var t, i = [];
+      if (this.wildcard) {
+        var s = typeof e == "string" ? e.split(this.delimiter) : e.slice();
+        if (i = d.call(this, null, s, this.listenerTree, 0), !i) return this;
+      } else {
+        if (!this._events[e]) return this;
+        t = this._events[e], i.push({ _listeners: t });
+      }
+      for (var n = 0; n < i.length; n++) {
+        var o = i[n];
+        if (t = o._listeners, L(t)) {
+          for (var f = -1, a = 0, l = t.length; a < l; a++)
+            if (t[a] === r || t[a].listener && t[a].listener === r || t[a]._origin && t[a]._origin === r) {
+              f = a;
+              break;
+            }
+          if (f < 0)
+            continue;
+          return this.wildcard ? o._listeners.splice(f, 1) : this._events[e].splice(f, 1), t.length === 0 && (this.wildcard ? delete o._listeners : delete this._events[e]), this._removeListener && this.emit("removeListener", e, r), this;
+        } else (t === r || t.listener && t.listener === r || t._origin && t._origin === r) && (this.wildcard ? delete o._listeners : delete this._events[e], this._removeListener && this.emit("removeListener", e, r));
+      }
+      return this.listenerTree && K(this.listenerTree), this;
+    }, c.prototype.offAny = function(e) {
+      var r = 0, t = 0, i;
+      if (e && this._all && this._all.length > 0) {
+        for (i = this._all, r = 0, t = i.length; r < t; r++)
+          if (e === i[r])
+            return i.splice(r, 1), this._removeListener && this.emit("removeListenerAny", e), this;
+      } else {
+        if (i = this._all, this._removeListener)
+          for (r = 0, t = i.length; r < t; r++)
+            this.emit("removeListenerAny", i[r]);
+        this._all = [];
+      }
+      return this;
+    }, c.prototype.removeListener = c.prototype.off, c.prototype.removeAllListeners = function(e) {
+      if (e === h)
+        return !this._events || M.call(this), this;
+      if (this.wildcard) {
+        var r = d.call(this, null, e, this.listenerTree, 0), t, i;
+        if (!r) return this;
+        for (i = 0; i < r.length; i++)
+          t = r[i], t._listeners = null;
+        this.listenerTree && K(this.listenerTree);
+      } else this._events && (this._events[e] = null);
+      return this;
+    }, c.prototype.listeners = function(e) {
+      var r = this._events, t, i, s, n, o;
+      if (e === h) {
+        if (this.wildcard)
+          throw Error("event name required for wildcard emitter");
+        if (!r)
+          return [];
+        for (t = w(r), n = t.length, s = []; n-- > 0; )
+          i = r[t[n]], typeof i == "function" ? s.push(i) : s.push.apply(s, i);
+        return s;
+      } else {
+        if (this.wildcard) {
+          if (o = this.listenerTree, !o) return [];
+          var f = [], a = typeof e == "string" ? e.split(this.delimiter) : e.slice();
+          return d.call(this, f, a, o, 0), f;
+        }
+        return r ? (i = r[e], i ? typeof i == "function" ? [i] : i : []) : [];
+      }
+    }, c.prototype.eventNames = function(e) {
+      var r = this._events;
+      return this.wildcard ? Y.call(this, this.listenerTree, [], null, e) : r ? w(r) : [];
+    }, c.prototype.listenerCount = function(e) {
+      return this.listeners(e).length;
+    }, c.prototype.hasListeners = function(e) {
+      if (this.wildcard) {
+        var r = [], t = typeof e == "string" ? e.split(this.delimiter) : e.slice();
+        return d.call(this, r, t, this.listenerTree, 0), r.length > 0;
+      }
+      var i = this._events, s = this._all;
+      return !!(s && s.length || i && (e === h ? w(i).length : i[e]));
+    }, c.prototype.listenersAny = function() {
+      return this._all ? this._all : [];
+    }, c.prototype.waitFor = function(e, r) {
+      var t = this, i = typeof r;
+      return i === "number" ? r = { timeout: r } : i === "function" && (r = { filter: r }), r = C(r, {
+        timeout: 0,
+        filter: h,
+        handleError: !1,
+        Promise,
+        overload: !1
+      }, {
+        filter: W,
+        Promise: z
+      }), Q(r.Promise, function(s, n, o) {
+        function f() {
+          var a = r.filter;
+          if (!(a && !a.apply(t, arguments)))
+            if (t.off(e, f), r.handleError) {
+              var l = arguments[0];
+              l ? n(l) : s(P.apply(null, arguments).slice(1));
+            } else
+              s(P.apply(null, arguments));
+        }
+        o(function() {
+          t.off(e, f);
+        }), t._on(e, f, !1);
+      }, {
+        timeout: r.timeout,
+        overload: r.overload
+      });
+    };
+    function ne(e, r, t) {
+      t = C(t, {
+        Promise,
+        timeout: 0,
+        overload: !1
+      }, {
+        Promise: z
+      });
+      var i = t.Promise;
+      return Q(i, function(s, n, o) {
+        var f;
+        if (typeof e.addEventListener == "function") {
+          f = function() {
+            s(P.apply(null, arguments));
+          }, o(function() {
+            e.removeEventListener(r, f);
+          }), e.addEventListener(
+            r,
+            f,
+            { once: !0 }
+          );
+          return;
+        }
+        var a = function() {
+          l && e.removeListener("error", l), s(P.apply(null, arguments));
+        }, l;
+        r !== "error" && (l = function(u) {
+          e.removeListener(r, a), n(u);
+        }, e.once("error", l)), o(function() {
+          l && e.removeListener("error", l), e.removeListener(r, a);
+        }), e.once(r, a);
+      }, {
+        timeout: t.timeout,
+        overload: t.overload
+      });
+    }
+    var V = c.prototype;
+    Object.defineProperties(c, {
+      defaultMaxListeners: {
+        get: function() {
+          return V._maxListeners;
+        },
+        set: function(e) {
+          if (typeof e != "number" || e < 0 || Number.isNaN(e))
+            throw TypeError("n must be a non-negative number");
+          V._maxListeners = e;
+        },
+        enumerable: !0
+      },
+      once: {
+        value: ne,
+        writable: !0,
+        configurable: !0
+      }
+    }), Object.defineProperties(V, {
+      _maxListeners: {
+        value: x,
+        writable: !0,
+        configurable: !0
+      },
+      _observers: { value: null, writable: !0, configurable: !0 }
+    }), g.exports = c;
+  })();
+})(re);
+var le = re.exports;
+const fe = () => new le.EventEmitter2({
+  wildcard: !1,
+  maxListeners: 0
+});
+function ee(g, ..._) {
+  const [h, ...p] = _;
+  if (h.startsWith("formio.")) {
+    const L = `on${h.charAt(7).toUpperCase()}${h.slice(8)}`;
+    L in g && g[L](...p);
+  }
+  g.otherEvents && g.otherEvents[h] && g.otherEvents[h](...p);
+}
+const ue = async (g, _, h, p = {}) => {
+  p != null && p.events || (p.events = fe()), typeof _ != "string" && (_ = structuredClone(_));
+  const x = await new g(h, _, p).ready;
+  return x.toJSON = () => ({ __WEBFORM__: !0 }), x;
+};
+function ce(g) {
+  const { FormClass: _ = oe, form: h, src: p, url: L, options: x, submission: F, onFormReady: T, onAsyncSubmit: A, ...S } = g;
+  return {
+    FormClass: _,
+    formSource: h !== void 0 ? h : p,
+    handlers: S,
+    options: x,
+    url: L,
+    submission: F,
+    onFormReady: T,
+    onAsyncSubmit: A
+  };
+}
+function he(g, _) {
+  return async (h, p) => {
+    try {
+      const L = await g(h);
+      p(null), _.current.onSubmit(L, !0);
+    } catch (L) {
+      p(L.errors || L);
+    } finally {
+      _.current.submissionInProcess = !1;
+    }
+  };
+}
+function _e(g) {
+  const _ = $(null), h = $(null), { formSource: p, FormClass: L, options: x, url: F, submission: T, handlers: A, onFormReady: S, onAsyncSubmit: I } = ce(g), [w, M] = ae(!1);
+  return G(() => {
+    let O = !1;
+    return (async () => {
+      if (h.current === null) {
+        console.warn("Form element not found");
+        return;
+      }
+      if (typeof p > "u") {
+        console.warn("Form source not found");
+        return;
+      }
+      let P = x || {};
+      I && (P.hooks = P.hooks || {}, P.hooks.customValidation = he(g.onAsyncSubmit, _));
+      const j = await ue(L, p, h.current, x);
+      if (j) {
+        if (O) {
+          j.destroy(!0);
+          return;
+        }
+        typeof p == "string" ? j.src = p : typeof p == "object" && (T && j.setSubmission(T), F && (j.url = F)), S && S(j), h.current.className = "formio-form-ready", _.current = j, M(!0);
+      } else
+        console.warn("Failed to create form instance");
+    })(), () => {
+      O = !0, _.current && _.current.destroy(!0);
+    };
+  }, [p, F]), G(() => (w && _.current && Object.keys(A).length > 0 && _.current.onAny((...O) => {
+    w && ee(A, ...O);
+  }), () => {
+    w && _.current && Object.keys(A).length > 0 && _.current.offAny((...O) => ee(A, ...O));
+  }), [w, A]), G(() => {
+    w && _.current && T && _.current.setSubmission(T);
+  }, [w, T]), {
+    element: h,
+    instance: _.current
+  };
+}
+export {
+  _e as useForm
+};
+//# sourceMappingURL=useForm.js.map