@turnkey/react-wallet-kit 1.0.0-beta.0

package/dist/_virtual/_rollupPluginBabelHelpers.mjs

@@ -0,0 +1,420 @@
+function _arrayLikeToArray(r, a) {
+  (null == a || a > r.length) && (a = r.length);
+  for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
+  return n;
+}
+function _arrayWithHoles(r) {
+  if (Array.isArray(r)) return r;
+}
+function _arrayWithoutHoles(r) {
+  if (Array.isArray(r)) return _arrayLikeToArray(r);
+}
+function asyncGeneratorStep(n, t, e, r, o, a, c) {
+  try {
+    var i = n[a](c),
+      u = i.value;
+  } catch (n) {
+    return void e(n);
+  }
+  i.done ? t(u) : Promise.resolve(u).then(r, o);
+}
+function _asyncToGenerator(n) {
+  return function () {
+    var t = this,
+      e = arguments;
+    return new Promise(function (r, o) {
+      var a = n.apply(t, e);
+      function _next(n) {
+        asyncGeneratorStep(a, r, o, _next, _throw, "next", n);
+      }
+      function _throw(n) {
+        asyncGeneratorStep(a, r, o, _next, _throw, "throw", n);
+      }
+      _next(void 0);
+    });
+  };
+}
+function _defineProperty(e, r, t) {
+  return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+    value: t,
+    enumerable: true,
+    configurable: true,
+    writable: true
+  }) : e[r] = t, e;
+}
+function _iterableToArray(r) {
+  if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r);
+}
+function _iterableToArrayLimit(r, l) {
+  var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
+  if (null != t) {
+    var e,
+      n,
+      i,
+      u,
+      a = [],
+      f = true,
+      o = false;
+    try {
+      if (i = (t = t.call(r)).next, 0 === l) {
+        if (Object(t) !== t) return;
+        f = !1;
+      } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0);
+    } catch (r) {
+      o = true, n = r;
+    } finally {
+      try {
+        if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return;
+      } finally {
+        if (o) throw n;
+      }
+    }
+    return a;
+  }
+}
+function _nonIterableRest() {
+  throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _nonIterableSpread() {
+  throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function ownKeys(e, r) {
+  var t = Object.keys(e);
+  if (Object.getOwnPropertySymbols) {
+    var o = Object.getOwnPropertySymbols(e);
+    r && (o = o.filter(function (r) {
+      return Object.getOwnPropertyDescriptor(e, r).enumerable;
+    })), t.push.apply(t, o);
+  }
+  return t;
+}
+function _objectSpread2(e) {
+  for (var r = 1; r < arguments.length; r++) {
+    var t = null != arguments[r] ? arguments[r] : {};
+    r % 2 ? ownKeys(Object(t), true).forEach(function (r) {
+      _defineProperty(e, r, t[r]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) {
+      Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r));
+    });
+  }
+  return e;
+}
+function _objectWithoutProperties(e, t) {
+  if (null == e) return {};
+  var o,
+    r,
+    i = _objectWithoutPropertiesLoose(e, t);
+  if (Object.getOwnPropertySymbols) {
+    var n = Object.getOwnPropertySymbols(e);
+    for (r = 0; r < n.length; r++) o = n[r], -1 === t.indexOf(o) && {}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]);
+  }
+  return i;
+}
+function _objectWithoutPropertiesLoose(r, e) {
+  if (null == r) return {};
+  var t = {};
+  for (var n in r) if ({}.hasOwnProperty.call(r, n)) {
+    if (-1 !== e.indexOf(n)) continue;
+    t[n] = r[n];
+  }
+  return t;
+}
+function _regeneratorRuntime() {
+  _regeneratorRuntime = function () {
+    return r;
+  };
+  var t,
+    r = {},
+    e = Object.prototype,
+    n = e.hasOwnProperty,
+    o = "function" == typeof Symbol ? Symbol : {},
+    i = o.iterator || "@@iterator",
+    a = o.asyncIterator || "@@asyncIterator",
+    u = o.toStringTag || "@@toStringTag";
+  function c(t, r, e, n) {
+    Object.defineProperty(t, r, {
+      value: e,
+      enumerable: !n,
+      configurable: !n,
+      writable: !n
+    });
+  }
+  try {
+    c({}, "");
+  } catch (t) {
+    c = function (t, r, e) {
+      return t[r] = e;
+    };
+  }
+  function h(r, e, n, o) {
+    var i = e && e.prototype instanceof Generator ? e : Generator,
+      a = Object.create(i.prototype);
+    return c(a, "_invoke", function (r, e, n) {
+      var o = 1;
+      return function (i, a) {
+        if (3 === o) throw Error("Generator is already running");
+        if (4 === o) {
+          if ("throw" === i) throw a;
+          return {
+            value: t,
+            done: true
+          };
+        }
+        for (n.method = i, n.arg = a;;) {
+          var u = n.delegate;
+          if (u) {
+            var c = d(u, n);
+            if (c) {
+              if (c === f) continue;
+              return c;
+            }
+          }
+          if ("next" === n.method) n.sent = n._sent = n.arg;else if ("throw" === n.method) {
+            if (1 === o) throw o = 4, n.arg;
+            n.dispatchException(n.arg);
+          } else "return" === n.method && n.abrupt("return", n.arg);
+          o = 3;
+          var h = s(r, e, n);
+          if ("normal" === h.type) {
+            if (o = n.done ? 4 : 2, h.arg === f) continue;
+            return {
+              value: h.arg,
+              done: n.done
+            };
+          }
+          "throw" === h.type && (o = 4, n.method = "throw", n.arg = h.arg);
+        }
+      };
+    }(r, n, new Context(o || [])), true), a;
+  }
+  function s(t, r, e) {
+    try {
+      return {
+        type: "normal",
+        arg: t.call(r, e)
+      };
+    } catch (t) {
+      return {
+        type: "throw",
+        arg: t
+      };
+    }
+  }
+  r.wrap = h;
+  var f = {};
+  function Generator() {}
+  function GeneratorFunction() {}
+  function GeneratorFunctionPrototype() {}
+  var l = {};
+  c(l, i, function () {
+    return this;
+  });
+  var p = Object.getPrototypeOf,
+    y = p && p(p(x([])));
+  y && y !== e && n.call(y, i) && (l = y);
+  var v = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(l);
+  function g(t) {
+    ["next", "throw", "return"].forEach(function (r) {
+      c(t, r, function (t) {
+        return this._invoke(r, t);
+      });
+    });
+  }
+  function AsyncIterator(t, r) {
+    function e(o, i, a, u) {
+      var c = s(t[o], t, i);
+      if ("throw" !== c.type) {
+        var h = c.arg,
+          f = h.value;
+        return f && "object" == typeof f && n.call(f, "__await") ? r.resolve(f.__await).then(function (t) {
+          e("next", t, a, u);
+        }, function (t) {
+          e("throw", t, a, u);
+        }) : r.resolve(f).then(function (t) {
+          h.value = t, a(h);
+        }, function (t) {
+          return e("throw", t, a, u);
+        });
+      }
+      u(c.arg);
+    }
+    var o;
+    c(this, "_invoke", function (t, n) {
+      function i() {
+        return new r(function (r, o) {
+          e(t, n, r, o);
+        });
+      }
+      return o = o ? o.then(i, i) : i();
+    }, true);
+  }
+  function d(r, e) {
+    var n = e.method,
+      o = r.i[n];
+    if (o === t) return e.delegate = null, "throw" === n && r.i.return && (e.method = "return", e.arg = t, d(r, e), "throw" === e.method) || "return" !== n && (e.method = "throw", e.arg = new TypeError("The iterator does not provide a '" + n + "' method")), f;
+    var i = s(o, r.i, e.arg);
+    if ("throw" === i.type) return e.method = "throw", e.arg = i.arg, e.delegate = null, f;
+    var a = i.arg;
+    return a ? a.done ? (e[r.r] = a.value, e.next = r.n, "return" !== e.method && (e.method = "next", e.arg = t), e.delegate = null, f) : a : (e.method = "throw", e.arg = new TypeError("iterator result is not an object"), e.delegate = null, f);
+  }
+  function w(t) {
+    this.tryEntries.push(t);
+  }
+  function m(r) {
+    var e = r[4] || {};
+    e.type = "normal", e.arg = t, r[4] = e;
+  }
+  function Context(t) {
+    this.tryEntries = [[-1]], t.forEach(w, this), this.reset(true);
+  }
+  function x(r) {
+    if (null != r) {
+      var e = r[i];
+      if (e) return e.call(r);
+      if ("function" == typeof r.next) return r;
+      if (!isNaN(r.length)) {
+        var o = -1,
+          a = function e() {
+            for (; ++o < r.length;) if (n.call(r, o)) return e.value = r[o], e.done = false, e;
+            return e.value = t, e.done = true, e;
+          };
+        return a.next = a;
+      }
+    }
+    throw new TypeError(typeof r + " is not iterable");
+  }
+  return GeneratorFunction.prototype = GeneratorFunctionPrototype, c(v, "constructor", GeneratorFunctionPrototype), c(GeneratorFunctionPrototype, "constructor", GeneratorFunction), c(GeneratorFunctionPrototype, u, GeneratorFunction.displayName = "GeneratorFunction"), r.isGeneratorFunction = function (t) {
+    var r = "function" == typeof t && t.constructor;
+    return !!r && (r === GeneratorFunction || "GeneratorFunction" === (r.displayName || r.name));
+  }, r.mark = function (t) {
+    return Object.setPrototypeOf ? Object.setPrototypeOf(t, GeneratorFunctionPrototype) : (t.__proto__ = GeneratorFunctionPrototype, c(t, u, "GeneratorFunction")), t.prototype = Object.create(v), t;
+  }, r.awrap = function (t) {
+    return {
+      __await: t
+    };
+  }, g(AsyncIterator.prototype), c(AsyncIterator.prototype, a, function () {
+    return this;
+  }), r.AsyncIterator = AsyncIterator, r.async = function (t, e, n, o, i) {
+    void 0 === i && (i = Promise);
+    var a = new AsyncIterator(h(t, e, n, o), i);
+    return r.isGeneratorFunction(e) ? a : a.next().then(function (t) {
+      return t.done ? t.value : a.next();
+    });
+  }, g(v), c(v, u, "Generator"), c(v, i, function () {
+    return this;
+  }), c(v, "toString", function () {
+    return "[object Generator]";
+  }), r.keys = function (t) {
+    var r = Object(t),
+      e = [];
+    for (var n in r) e.unshift(n);
+    return function t() {
+      for (; e.length;) if ((n = e.pop()) in r) return t.value = n, t.done = false, t;
+      return t.done = true, t;
+    };
+  }, r.values = x, Context.prototype = {
+    constructor: Context,
+    reset: function (r) {
+      if (this.prev = this.next = 0, this.sent = this._sent = t, this.done = false, this.delegate = null, this.method = "next", this.arg = t, this.tryEntries.forEach(m), !r) for (var e in this) "t" === e.charAt(0) && n.call(this, e) && !isNaN(+e.slice(1)) && (this[e] = t);
+    },
+    stop: function () {
+      this.done = true;
+      var t = this.tryEntries[0][4];
+      if ("throw" === t.type) throw t.arg;
+      return this.rval;
+    },
+    dispatchException: function (r) {
+      if (this.done) throw r;
+      var e = this;
+      function n(t) {
+        a.type = "throw", a.arg = r, e.next = t;
+      }
+      for (var o = e.tryEntries.length - 1; o >= 0; --o) {
+        var i = this.tryEntries[o],
+          a = i[4],
+          u = this.prev,
+          c = i[1],
+          h = i[2];
+        if (-1 === i[0]) return n("end"), false;
+        if (!c && !h) throw Error("try statement without catch or finally");
+        if (null != i[0] && i[0] <= u) {
+          if (u < c) return this.method = "next", this.arg = t, n(c), true;
+          if (u < h) return n(h), false;
+        }
+      }
+    },
+    abrupt: function (t, r) {
+      for (var e = this.tryEntries.length - 1; e >= 0; --e) {
+        var n = this.tryEntries[e];
+        if (n[0] > -1 && n[0] <= this.prev && this.prev < n[2]) {
+          var o = n;
+          break;
+        }
+      }
+      o && ("break" === t || "continue" === t) && o[0] <= r && r <= o[2] && (o = null);
+      var i = o ? o[4] : {};
+      return i.type = t, i.arg = r, o ? (this.method = "next", this.next = o[2], f) : this.complete(i);
+    },
+    complete: function (t, r) {
+      if ("throw" === t.type) throw t.arg;
+      return "break" === t.type || "continue" === t.type ? this.next = t.arg : "return" === t.type ? (this.rval = this.arg = t.arg, this.method = "return", this.next = "end") : "normal" === t.type && r && (this.next = r), f;
+    },
+    finish: function (t) {
+      for (var r = this.tryEntries.length - 1; r >= 0; --r) {
+        var e = this.tryEntries[r];
+        if (e[2] === t) return this.complete(e[4], e[3]), m(e), f;
+      }
+    },
+    catch: function (t) {
+      for (var r = this.tryEntries.length - 1; r >= 0; --r) {
+        var e = this.tryEntries[r];
+        if (e[0] === t) {
+          var n = e[4];
+          if ("throw" === n.type) {
+            var o = n.arg;
+            m(e);
+          }
+          return o;
+        }
+      }
+      throw Error("illegal catch attempt");
+    },
+    delegateYield: function (r, e, n) {
+      return this.delegate = {
+        i: x(r),
+        r: e,
+        n: n
+      }, "next" === this.method && (this.arg = t), f;
+    }
+  }, r;
+}
+function _slicedToArray(r, e) {
+  return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest();
+}
+function _toConsumableArray(r) {
+  return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread();
+}
+function _toPrimitive(t, r) {
+  if ("object" != typeof t || !t) return t;
+  var e = t[Symbol.toPrimitive];
+  if (void 0 !== e) {
+    var i = e.call(t, r);
+    if ("object" != typeof i) return i;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return ("string" === r ? String : Number)(t);
+}
+function _toPropertyKey(t) {
+  var i = _toPrimitive(t, "string");
+  return "symbol" == typeof i ? i : i + "";
+}
+function _unsupportedIterableToArray(r, a) {
+  if (r) {
+    if ("string" == typeof r) return _arrayLikeToArray(r, a);
+    var t = {}.toString.call(r).slice(8, -1);
+    return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0;
+  }
+}
+
+export { _arrayLikeToArray as arrayLikeToArray, _arrayWithHoles as arrayWithHoles, _arrayWithoutHoles as arrayWithoutHoles, _asyncToGenerator as asyncToGenerator, _defineProperty as defineProperty, _iterableToArray as iterableToArray, _iterableToArrayLimit as iterableToArrayLimit, _nonIterableRest as nonIterableRest, _nonIterableSpread as nonIterableSpread, _objectSpread2 as objectSpread2, _objectWithoutProperties as objectWithoutProperties, _objectWithoutPropertiesLoose as objectWithoutPropertiesLoose, _regeneratorRuntime as regeneratorRuntime, _slicedToArray as slicedToArray, _toConsumableArray as toConsumableArray, _toPrimitive as toPrimitive, _toPropertyKey as toPropertyKey, _unsupportedIterableToArray as unsupportedIterableToArray };
+//# sourceMappingURL=_rollupPluginBabelHelpers.mjs.map

package/dist/_virtual/_rollupPluginBabelHelpers.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"_rollupPluginBabelHelpers.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/components/auth/Action.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="react" />
+interface ActionPageProps {
+    title: string;
+    icon: React.ReactNode;
+    closeOnComplete?: boolean;
+    action?: () => Promise<void>;
+}
+export declare function ActionPage(props: ActionPageProps): import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=Action.d.ts.map

package/dist/components/auth/Action.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Action.d.ts","sourceRoot":"","sources":["../../../src/components/auth/Action.tsx"],"names":[],"mappings":";AAKA,UAAU,eAAe;IACvB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,KAAK,CAAC,SAAS,CAAC;IACtB,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,MAAM,CAAC,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC9B;AAED,wBAAgB,UAAU,CAAC,KAAK,EAAE,eAAe,2CA2DhD"}

package/dist/components/auth/Action.js

@@ -0,0 +1,76 @@
+'use strict';
+
+var jsxRuntime = require('react/jsx-runtime');
+var react = require('react');
+var Hook = require('../../providers/modal/Hook.js');
+var Spinners = require('../design/Spinners.js');
+var clsx = require('clsx');
+
+function ActionPage(props) {
+  const {
+    title,
+    icon,
+    closeOnComplete = true,
+    action
+  } = props;
+  const {
+    popPage,
+    closeModal,
+    isMobile
+  } = Hook.useModal();
+  const hasRun = react.useRef(false);
+  const iconRef = react.useRef(null);
+  const [spinnerSize, setSpinnerSize] = react.useState(40);
+  react.useEffect(() => {
+    if (iconRef.current) {
+      const rect = iconRef.current.getBoundingClientRect();
+      const size = Math.max(rect.width, rect.height);
+      setSpinnerSize(size + 50);
+    }
+  }, []);
+  react.useEffect(() => {
+    if (hasRun.current) return;
+    hasRun.current = true;
+    const runAction = async () => {
+      if (action) {
+        try {
+          await action();
+        } catch (error) {
+          popPage();
+          throw new Error(`${error}`);
+        }
+        if (closeOnComplete) {
+          closeModal();
+        }
+      }
+    };
+    runAction();
+  }, []);
+  return jsxRuntime.jsx("div", {
+    className: clsx("flex items-center justify-center py-10", isMobile ? "w-full" : "w-96"),
+    children: jsxRuntime.jsxs("div", {
+      className: "flex flex-col items-center justify-center gap-8",
+      children: [jsxRuntime.jsxs("div", {
+        className: "relative flex items-center justify-center",
+        children: [jsxRuntime.jsx("div", {
+          ref: iconRef,
+          className: "flex items-center justify-center",
+          children: icon
+        }), jsxRuntime.jsx(Spinners.Spinner, {
+          className: "absolute",
+          style: {
+            width: spinnerSize,
+            height: spinnerSize
+          },
+          strokeWidth: 1
+        })]
+      }), jsxRuntime.jsx("span", {
+        className: "text-lg font-semibold",
+        children: title
+      })]
+    })
+  });
+}
+
+exports.ActionPage = ActionPage;
+//# sourceMappingURL=Action.js.map

package/dist/components/auth/Action.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Action.js","sources":["../../../src/components/auth/Action.tsx"],"sourcesContent":[null],"names":["ActionPage","props","title","icon","closeOnComplete","action","popPage","closeModal","isMobile","useModal","hasRun","useRef","iconRef","spinnerSize","setSpinnerSize","useState","useEffect","current","rect","getBoundingClientRect","size","Math","max","width","height","runAction","error","Error","_jsx","className","clsx","children","_jsxs","ref","Spinner","style","strokeWidth"],"mappings":";;;;;;;;AAYM,SAAUA,UAAUA,CAACC,KAAsB,EAAA;EAC/C,MAAM;IAAEC,KAAK;IAAEC,IAAI;AAAEC,IAAAA,eAAe,GAAG,IAAI;AAAEC,IAAAA;AAAQ,GAAA,GAAGJ,KAAK;EAC7D,MAAM;IAAEK,OAAO;IAAEC,UAAU;AAAEC,IAAAA;GAAU,GAAGC,aAAQ,EAAE;AACpD,EAAA,MAAMC,MAAM,GAAGC,YAAM,CAAC,KAAK,CAAC;AAC5B,EAAA,MAAMC,OAAO,GAAGD,YAAM,CAAiB,IAAI,CAAC;EAC5C,MAAM,CAACE,WAAW,EAAEC,cAAc,CAAC,GAAGC,cAAQ,CAAS,EAAE,CAAC;AAE1DC,EAAAA,eAAS,CAAC,MAAK;IACb,IAAIJ,OAAO,CAACK,OAAO,EAAE;MACnB,MAAMC,IAAI,GAAGN,OAAO,CAACK,OAAO,CAACE,qBAAqB,EAAE;AACpD,MAAA,MAAMC,IAAI,GAAGC,IAAI,CAACC,GAAG,CAACJ,IAAI,CAACK,KAAK,EAAEL,IAAI,CAACM,MAAM,CAAC;AAC9CV,MAAAA,cAAc,CAACM,IAAI,GAAG,EAAE,CAAC;AAC3B;GACD,EAAE,EAAE,CAAC;AAENJ,EAAAA,eAAS,CAAC,MAAK;IACb,IAAIN,MAAM,CAACO,OAAO,EAAE;IACpBP,MAAM,CAACO,OAAO,GAAG,IAAI;AACrB,IAAA,MAAMQ,SAAS,GAAG,YAAW;AAC3B,MAAA,IAAIpB,MAAM,EAAE;QACV,IAAI;UACF,MAAMA,MAAM,EAAE;SACf,CAAC,OAAOqB,KAAK,EAAE;AACdpB,UAAAA,OAAO,EAAE;AACT,UAAA,MAAM,IAAIqB,KAAK,CAAC,CAAGD,EAAAA,KAAK,EAAE,CAAC;AAC7B;AACA,QAAA,IAAItB,eAAe,EAAE;AACnBG,UAAAA,UAAU,EAAE;AACd;AACF;KACD;AACDkB,IAAAA,SAAS,EAAE;GACZ,EAAE,EAAE,CAAC;EAEN,OACEG;IACEC,SAAS,EAAEC,IAAI,CACb,wCAAwC,EACxCtB,QAAQ,GAAG,QAAQ,GAAG,MAAM,CAC7B;AAEDuB,IAAAA,QAAA,EAAAC,eAAA,CAAA,KAAA,EAAA;AAAKH,MAAAA,SAAS,EAAC,iDAAiD;AAAAE,MAAAA,QAAA,EAAA,CAC9DC;AAAKH,QAAAA,SAAS,EAAC,2CAA2C;AACxDE,QAAAA,QAAA,EAAA,CAAAH,cAAA,CAAA,KAAA,EAAA;AAAKK,UAAAA,GAAG,EAAErB,OAAO;AAAEiB,UAAAA,SAAS,EAAC,kCAAkC;oBAC5D1B;AAAI,SAAA,CACD,EACNyB,cAAA,CAACM,gBAAO,EAAA;AACNL,UAAAA,SAAS,EAAC,UAAU;AACpBM,UAAAA,KAAK,EAAE;AACLZ,YAAAA,KAAK,EAAEV,WAAW;AAClBW,YAAAA,MAAM,EAAEX;WACT;AACDuB,UAAAA,WAAW,EAAE;AACb,SAAA,CAAA;AAAA,OAAA,CACE,EACNR,cAAM,CAAA,MAAA,EAAA;AAAAC,QAAAA,SAAS,EAAC,uBAAuB;kBAAE3B;AAAK,OAAA,CAAQ;KAClD;AAAA,GAAA,CACF;AAEV;;;;"}

package/dist/components/auth/Action.mjs

@@ -0,0 +1,97 @@
+import { slicedToArray as _slicedToArray, asyncToGenerator as _asyncToGenerator, regeneratorRuntime as _regeneratorRuntime } from '../../_virtual/_rollupPluginBabelHelpers.mjs';
+import { jsx, jsxs } from 'react/jsx-runtime';
+import { useRef, useState, useEffect } from 'react';
+import { useModal } from '../../providers/modal/Hook.mjs';
+import { Spinner } from '../design/Spinners.mjs';
+import clsx from 'clsx';
+
+function ActionPage(props) {
+  var title = props.title,
+    icon = props.icon,
+    _props$closeOnComplet = props.closeOnComplete,
+    closeOnComplete = _props$closeOnComplet === void 0 ? true : _props$closeOnComplet,
+    action = props.action;
+  var _useModal = useModal(),
+    popPage = _useModal.popPage,
+    closeModal = _useModal.closeModal,
+    isMobile = _useModal.isMobile;
+  var hasRun = useRef(false);
+  var iconRef = useRef(null);
+  var _useState = useState(40),
+    _useState2 = _slicedToArray(_useState, 2),
+    spinnerSize = _useState2[0],
+    setSpinnerSize = _useState2[1];
+  useEffect(function () {
+    if (iconRef.current) {
+      var rect = iconRef.current.getBoundingClientRect();
+      var size = Math.max(rect.width, rect.height);
+      setSpinnerSize(size + 50);
+    }
+  }, []);
+  useEffect(function () {
+    if (hasRun.current) return;
+    hasRun.current = true;
+    var runAction = /*#__PURE__*/function () {
+      var _ref = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
+        return _regeneratorRuntime().wrap(function _callee$(_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              if (!action) {
+                _context.next = 11;
+                break;
+              }
+              _context.prev = 1;
+              _context.next = 4;
+              return action();
+            case 4:
+              _context.next = 10;
+              break;
+            case 6:
+              _context.prev = 6;
+              _context.t0 = _context["catch"](1);
+              popPage();
+              throw new Error("".concat(_context.t0));
+            case 10:
+              if (closeOnComplete) {
+                closeModal();
+              }
+            case 11:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, null, [[1, 6]]);
+      }));
+      return function runAction() {
+        return _ref.apply(this, arguments);
+      };
+    }();
+    runAction();
+  }, []);
+  return jsx("div", {
+    className: clsx("flex items-center justify-center py-10", isMobile ? "w-full" : "w-96"),
+    children: jsxs("div", {
+      className: "flex flex-col items-center justify-center gap-8",
+      children: [jsxs("div", {
+        className: "relative flex items-center justify-center",
+        children: [jsx("div", {
+          ref: iconRef,
+          className: "flex items-center justify-center",
+          children: icon
+        }), jsx(Spinner, {
+          className: "absolute",
+          style: {
+            width: spinnerSize,
+            height: spinnerSize
+          },
+          strokeWidth: 1
+        })]
+      }), jsx("span", {
+        className: "text-lg font-semibold",
+        children: title
+      })]
+    })
+  });
+}
+
+export { ActionPage };
+//# sourceMappingURL=Action.mjs.map

package/dist/components/auth/Action.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Action.mjs","sources":["../../../src/components/auth/Action.tsx"],"sourcesContent":[null],"names":["ActionPage","props","title","icon","_props$closeOnComplet","closeOnComplete","action","_useModal","useModal","popPage","closeModal","isMobile","hasRun","useRef","iconRef","_useState","useState","_useState2","_slicedToArray","spinnerSize","setSpinnerSize","useEffect","current","rect","getBoundingClientRect","size","Math","max","width","height","runAction","_ref","_asyncToGenerator","_regeneratorRuntime","mark","_callee","wrap","_callee$","_context","prev","next","t0","Error","concat","stop","apply","arguments","_jsx","className","clsx","children","_jsxs","ref","Spinner","style","strokeWidth"],"mappings":"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"}

package/dist/components/auth/Email.d.ts

@@ -0,0 +1,6 @@
+interface EmailInputProps {
+    onContinue?: (email: string) => void;
+}
+export declare function EmailInput(props: EmailInputProps): import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=Email.d.ts.map

package/dist/components/auth/Email.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Email.d.ts","sourceRoot":"","sources":["../../../src/components/auth/Email.tsx"],"names":[],"mappings":"AAWA,UAAU,eAAe;IACvB,UAAU,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;CACtC;AAED,wBAAgB,UAAU,CAAC,KAAK,EAAE,eAAe,2CAiFhD"}