@consumidor-positivo/aurora 0.0.195 → 0.0.197

package/dist/react-if.esm-BV55Vzhf.js

@@ -0,0 +1,570 @@
+import * as $dbSRa$react from "react";
+import $dbSRa$react__default, { Fragment, useState, useMemo, useRef, useEffect } from "react";
+var render = function render2(props) {
+  if (typeof props.children === "function") {
+    return $dbSRa$react__default.createElement(Fragment, null, props.children());
+  }
+  return $dbSRa$react__default.createElement(Fragment, null, props.children || null);
+};
+var Case = function Case2(_ref) {
+  var _ref$children = _ref.children, children = _ref$children === void 0 ? null : _ref$children;
+  return render({
+    children
+  });
+};
+var Default = function Default2(_ref) {
+  var _ref$children = _ref.children, children = _ref$children === void 0 ? null : _ref$children;
+  return render({
+    children
+  });
+};
+var Else = function Else2(props) {
+  return render(props);
+};
+var Fallback = function Fallback2(props) {
+  return render(props);
+};
+function asyncGeneratorStep(n, t, e, r, o, a, c) {
+  try {
+    var i = n[a](c), u = i.value;
+  } catch (n2) {
+    return void e(n2);
+  }
+  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(n2) {
+        asyncGeneratorStep(a, r, o, _next, _throw, "next", n2);
+      }
+      function _throw(n2) {
+        asyncGeneratorStep(a, r, o, _next, _throw, "throw", n2);
+      }
+      _next(void 0);
+    });
+  };
+}
+function _extends() {
+  return _extends = Object.assign ? Object.assign.bind() : function(n) {
+    for (var e = 1; e < arguments.length; e++) {
+      var t = arguments[e];
+      for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]);
+    }
+    return n;
+  }, _extends.apply(null, arguments);
+}
+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(t2, r2, e2, n2) {
+    return Object.defineProperty(t2, r2, {
+      value: e2,
+      enumerable: !n2,
+      configurable: !n2,
+      writable: !n2
+    });
+  }
+  try {
+    c({}, "");
+  } catch (t2) {
+    c = function(t3, r2, e2) {
+      return t3[r2] = e2;
+    };
+  }
+  function h(r2, e2, n2, o2) {
+    var i2 = e2 && e2.prototype instanceof Generator ? e2 : Generator, a2 = Object.create(i2.prototype);
+    return c(a2, "_invoke", /* @__PURE__ */ function(r3, e3, n3) {
+      var o3 = 1;
+      return function(i3, a3) {
+        if (3 === o3) throw Error("Generator is already running");
+        if (4 === o3) {
+          if ("throw" === i3) throw a3;
+          return {
+            value: t,
+            done: true
+          };
+        }
+        for (n3.method = i3, n3.arg = a3; ; ) {
+          var u2 = n3.delegate;
+          if (u2) {
+            var c2 = d(u2, n3);
+            if (c2) {
+              if (c2 === f) continue;
+              return c2;
+            }
+          }
+          if ("next" === n3.method) n3.sent = n3._sent = n3.arg;
+          else if ("throw" === n3.method) {
+            if (1 === o3) throw o3 = 4, n3.arg;
+            n3.dispatchException(n3.arg);
+          } else "return" === n3.method && n3.abrupt("return", n3.arg);
+          o3 = 3;
+          var h2 = s(r3, e3, n3);
+          if ("normal" === h2.type) {
+            if (o3 = n3.done ? 4 : 2, h2.arg === f) continue;
+            return {
+              value: h2.arg,
+              done: n3.done
+            };
+          }
+          "throw" === h2.type && (o3 = 4, n3.method = "throw", n3.arg = h2.arg);
+        }
+      };
+    }(r2, n2, new Context(o2 || [])), true), a2;
+  }
+  function s(t2, r2, e2) {
+    try {
+      return {
+        type: "normal",
+        arg: t2.call(r2, e2)
+      };
+    } catch (t3) {
+      return {
+        type: "throw",
+        arg: t3
+      };
+    }
+  }
+  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(t2) {
+    ["next", "throw", "return"].forEach(function(r2) {
+      c(t2, r2, function(t3) {
+        return this._invoke(r2, t3);
+      });
+    });
+  }
+  function AsyncIterator(t2, r2) {
+    function e2(o3, i2, a2, u2) {
+      var c2 = s(t2[o3], t2, i2);
+      if ("throw" !== c2.type) {
+        var h2 = c2.arg, f2 = h2.value;
+        return f2 && "object" == typeof f2 && n.call(f2, "__await") ? r2.resolve(f2.__await).then(function(t3) {
+          e2("next", t3, a2, u2);
+        }, function(t3) {
+          e2("throw", t3, a2, u2);
+        }) : r2.resolve(f2).then(function(t3) {
+          h2.value = t3, a2(h2);
+        }, function(t3) {
+          return e2("throw", t3, a2, u2);
+        });
+      }
+      u2(c2.arg);
+    }
+    var o2;
+    c(this, "_invoke", function(t3, n2) {
+      function i2() {
+        return new r2(function(r3, o3) {
+          e2(t3, n2, r3, o3);
+        });
+      }
+      return o2 = o2 ? o2.then(i2, i2) : i2();
+    }, true);
+  }
+  function d(r2, e2) {
+    var n2 = e2.method, o2 = r2.i[n2];
+    if (o2 === t) return e2.delegate = null, "throw" === n2 && r2.i.return && (e2.method = "return", e2.arg = t, d(r2, e2), "throw" === e2.method) || "return" !== n2 && (e2.method = "throw", e2.arg = new TypeError("The iterator does not provide a '" + n2 + "' method")), f;
+    var i2 = s(o2, r2.i, e2.arg);
+    if ("throw" === i2.type) return e2.method = "throw", e2.arg = i2.arg, e2.delegate = null, f;
+    var a2 = i2.arg;
+    return a2 ? a2.done ? (e2[r2.r] = a2.value, e2.next = r2.n, "return" !== e2.method && (e2.method = "next", e2.arg = t), e2.delegate = null, f) : a2 : (e2.method = "throw", e2.arg = new TypeError("iterator result is not an object"), e2.delegate = null, f);
+  }
+  function w(t2) {
+    this.tryEntries.push(t2);
+  }
+  function m(r2) {
+    var e2 = r2[4] || {};
+    e2.type = "normal", e2.arg = t, r2[4] = e2;
+  }
+  function Context(t2) {
+    this.tryEntries = [[-1]], t2.forEach(w, this), this.reset(true);
+  }
+  function x(r2) {
+    if (null != r2) {
+      var e2 = r2[i];
+      if (e2) return e2.call(r2);
+      if ("function" == typeof r2.next) return r2;
+      if (!isNaN(r2.length)) {
+        var o2 = -1, a2 = function e3() {
+          for (; ++o2 < r2.length; ) if (n.call(r2, o2)) return e3.value = r2[o2], e3.done = false, e3;
+          return e3.value = t, e3.done = true, e3;
+        };
+        return a2.next = a2;
+      }
+    }
+    throw new TypeError(typeof r2 + " is not iterable");
+  }
+  return GeneratorFunction.prototype = GeneratorFunctionPrototype, c(v, "constructor", GeneratorFunctionPrototype), c(GeneratorFunctionPrototype, "constructor", GeneratorFunction), GeneratorFunction.displayName = c(GeneratorFunctionPrototype, u, "GeneratorFunction"), r.isGeneratorFunction = function(t2) {
+    var r2 = "function" == typeof t2 && t2.constructor;
+    return !!r2 && (r2 === GeneratorFunction || "GeneratorFunction" === (r2.displayName || r2.name));
+  }, r.mark = function(t2) {
+    return Object.setPrototypeOf ? Object.setPrototypeOf(t2, GeneratorFunctionPrototype) : (t2.__proto__ = GeneratorFunctionPrototype, c(t2, u, "GeneratorFunction")), t2.prototype = Object.create(v), t2;
+  }, r.awrap = function(t2) {
+    return {
+      __await: t2
+    };
+  }, g(AsyncIterator.prototype), c(AsyncIterator.prototype, a, function() {
+    return this;
+  }), r.AsyncIterator = AsyncIterator, r.async = function(t2, e2, n2, o2, i2) {
+    void 0 === i2 && (i2 = Promise);
+    var a2 = new AsyncIterator(h(t2, e2, n2, o2), i2);
+    return r.isGeneratorFunction(e2) ? a2 : a2.next().then(function(t3) {
+      return t3.done ? t3.value : a2.next();
+    });
+  }, g(v), c(v, u, "Generator"), c(v, i, function() {
+    return this;
+  }), c(v, "toString", function() {
+    return "[object Generator]";
+  }), r.keys = function(t2) {
+    var r2 = Object(t2), e2 = [];
+    for (var n2 in r2) e2.unshift(n2);
+    return function t3() {
+      for (; e2.length; ) if ((n2 = e2.pop()) in r2) return t3.value = n2, t3.done = false, t3;
+      return t3.done = true, t3;
+    };
+  }, r.values = x, Context.prototype = {
+    constructor: Context,
+    reset: function(r2) {
+      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), !r2) for (var e2 in this) "t" === e2.charAt(0) && n.call(this, e2) && !isNaN(+e2.slice(1)) && (this[e2] = t);
+    },
+    stop: function() {
+      this.done = true;
+      var t2 = this.tryEntries[0][4];
+      if ("throw" === t2.type) throw t2.arg;
+      return this.rval;
+    },
+    dispatchException: function(r2) {
+      if (this.done) throw r2;
+      var e2 = this;
+      function n2(t2) {
+        a2.type = "throw", a2.arg = r2, e2.next = t2;
+      }
+      for (var o2 = e2.tryEntries.length - 1; o2 >= 0; --o2) {
+        var i2 = this.tryEntries[o2], a2 = i2[4], u2 = this.prev, c2 = i2[1], h2 = i2[2];
+        if (-1 === i2[0]) return n2("end"), false;
+        if (!c2 && !h2) throw Error("try statement without catch or finally");
+        if (null != i2[0] && i2[0] <= u2) {
+          if (u2 < c2) return this.method = "next", this.arg = t, n2(c2), true;
+          if (u2 < h2) return n2(h2), false;
+        }
+      }
+    },
+    abrupt: function(t2, r2) {
+      for (var e2 = this.tryEntries.length - 1; e2 >= 0; --e2) {
+        var n2 = this.tryEntries[e2];
+        if (n2[0] > -1 && n2[0] <= this.prev && this.prev < n2[2]) {
+          var o2 = n2;
+          break;
+        }
+      }
+      o2 && ("break" === t2 || "continue" === t2) && o2[0] <= r2 && r2 <= o2[2] && (o2 = null);
+      var i2 = o2 ? o2[4] : {};
+      return i2.type = t2, i2.arg = r2, o2 ? (this.method = "next", this.next = o2[2], f) : this.complete(i2);
+    },
+    complete: function(t2, r2) {
+      if ("throw" === t2.type) throw t2.arg;
+      return "break" === t2.type || "continue" === t2.type ? this.next = t2.arg : "return" === t2.type ? (this.rval = this.arg = t2.arg, this.method = "return", this.next = "end") : "normal" === t2.type && r2 && (this.next = r2), f;
+    },
+    finish: function(t2) {
+      for (var r2 = this.tryEntries.length - 1; r2 >= 0; --r2) {
+        var e2 = this.tryEntries[r2];
+        if (e2[2] === t2) return this.complete(e2[4], e2[3]), m(e2), f;
+      }
+    },
+    catch: function(t2) {
+      for (var r2 = this.tryEntries.length - 1; r2 >= 0; --r2) {
+        var e2 = this.tryEntries[r2];
+        if (e2[0] === t2) {
+          var n2 = e2[4];
+          if ("throw" === n2.type) {
+            var o2 = n2.arg;
+            m(e2);
+          }
+          return o2;
+        }
+      }
+      throw Error("illegal catch attempt");
+    },
+    delegateYield: function(r2, e2, n2) {
+      return this.delegate = {
+        i: x(r2),
+        r: e2,
+        n: n2
+      }, "next" === this.method && (this.arg = t), f;
+    }
+  }, r;
+}
+var Then = function Then2(props) {
+  return render(props);
+};
+function isFunction(input) {
+  return typeof input === "function";
+}
+function hasThen(input) {
+  return Reflect.has(input, "then") && isFunction(input.then);
+}
+function hasCatch(input) {
+  return Reflect.has(input, "catch") && isFunction(input["catch"]);
+}
+function isThenable(input) {
+  if (typeof input !== "object" || input === null) return false;
+  return input instanceof Promise || input !== Promise.prototype && hasThen(input) && hasCatch(input);
+}
+var shallowArraysEqual = function shallowArraysEqual2(a, b) {
+  if (!Array.isArray(a) || !Array.isArray(b)) throw new Error("shallowArraysEqual only accepts arrays as parameters");
+  if (a.length !== b.length) return false;
+  for (var i = 0; i < a.length; ++i) {
+    if (a[i] !== b[i]) return false;
+  }
+  return true;
+};
+var createCancellablePromise = function createCancellablePromise2(promise) {
+  if (!isThenable(promise)) {
+    throw new Error("Argument of createCancellablePromise should be a Promise");
+  }
+  var isCancelled = {
+    value: false
+  };
+  var wrappedPromise = new Promise(/* @__PURE__ */ function() {
+    var _ref = _asyncToGenerator(/* @__PURE__ */ _regeneratorRuntime().mark(function _callee(res, rej) {
+      var d;
+      return _regeneratorRuntime().wrap(function _callee$(_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            _context.prev = 0;
+            _context.next = 3;
+            return promise;
+          case 3:
+            d = _context.sent;
+            if (!isCancelled.value) {
+              res(d);
+            }
+            _context.next = 10;
+            break;
+          case 7:
+            _context.prev = 7;
+            _context.t0 = _context["catch"](0);
+            if (!isCancelled.value) {
+              rej(_context.t0);
+            }
+          case 10:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee, null, [[0, 7]]);
+    }));
+    return function(_x, _x2) {
+      return _ref.apply(this, arguments);
+    };
+  }());
+  Object.keys(promise).forEach(function(key) {
+    wrappedPromise[key] = promise[key];
+  });
+  return {
+    promise: wrappedPromise,
+    cancel: function cancel() {
+      isCancelled.value = true;
+    }
+  };
+};
+var useSingleton = function useSingleton2(callback, dependencies) {
+  if (dependencies === void 0) {
+    dependencies = [];
+  }
+  var hasRan = useRef(false);
+  var lastDependencies = useRef([]);
+  if (typeof callback !== "function") {
+    throw new Error("Incorrect callback parameter for useSingleton hook; expected a function, but got: '" + typeof callback + "'.");
+  }
+  if (!Array.isArray(dependencies)) {
+    throw new Error("Incorrect dependencies parameter for useSingleton; expected an array, but got: '" + typeof dependencies + "'.");
+  }
+  var hasDependencies = Array.isArray(dependencies) && dependencies.length > 0;
+  if (hasDependencies) {
+    var hasAnyDependencyChanged = !shallowArraysEqual(lastDependencies.current, dependencies);
+    if (hasAnyDependencyChanged) {
+      lastDependencies.current = dependencies;
+    } else if (hasRan.current) {
+      return;
+    }
+  } else if (hasRan.current) {
+    return;
+  }
+  callback();
+  hasRan.current = true;
+};
+function IfAsync(_ref) {
+  var promise = _ref.promise, _ref$keepAlive = _ref.keepAlive, keepAlive = _ref$keepAlive === void 0 ? false : _ref$keepAlive, children = _ref.children;
+  var _useState = useState(null), isResolved = _useState[0], setIsResolved = _useState[1];
+  var _useState2 = useState(null), returnValue = _useState2[0], setReturnValue = _useState2[1];
+  var cancellablePromise = useMemo(function() {
+    return createCancellablePromise(promise);
+  }, [promise]);
+  var history = useRef([]);
+  useEffect(function() {
+    return function() {
+      if (!keepAlive) {
+        cancellablePromise.cancel();
+      }
+    };
+  }, [cancellablePromise, cancellablePromise.promise, keepAlive]);
+  useSingleton(/* @__PURE__ */ _asyncToGenerator(/* @__PURE__ */ _regeneratorRuntime().mark(function _callee() {
+    var data;
+    return _regeneratorRuntime().wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          setIsResolved(null);
+          setReturnValue(null);
+          _context.prev = 2;
+          _context.next = 5;
+          return cancellablePromise.promise;
+        case 5:
+          data = _context.sent;
+          setReturnValue(data);
+          setIsResolved(true);
+          history.current.push(cancellablePromise);
+          _context.next = 16;
+          break;
+        case 11:
+          _context.prev = 11;
+          _context.t0 = _context["catch"](2);
+          setReturnValue(_context.t0);
+          setIsResolved(false);
+          history.current.push(cancellablePromise);
+        case 16:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee, null, [[2, 11]]);
+  })), [cancellablePromise.promise]);
+  if (!children || !isThenable(promise)) {
+    return null;
+  }
+  if (isResolved === null) {
+    var hasFallback = $dbSRa$react.Children.toArray(children).find(function(c) {
+      return c.type === Fallback;
+    });
+    return $dbSRa$react.createElement(Fragment, null, hasFallback || null);
+  }
+  if (!isResolved) {
+    var hasElse = $dbSRa$react.Children.toArray(children).find(function(c) {
+      return c.type === Else;
+    });
+    if (!hasElse) return $dbSRa$react.createElement(Fragment, null, null);
+    var elseElement = hasElse;
+    var hasElseProps = hasElse.props;
+    if (typeof hasElseProps.children === "function") {
+      elseElement = _extends({}, hasElse, {
+        props: _extends({}, hasElseProps, {
+          children: function children2() {
+            return hasElseProps.children(returnValue, history.current, cancellablePromise.promise);
+          }
+        })
+      });
+    }
+    return $dbSRa$react.createElement(Fragment, null, elseElement);
+  }
+  var hasThen2 = $dbSRa$react.Children.toArray(children).find(function(c) {
+    return c.type === Then;
+  });
+  if (!hasThen2) return $dbSRa$react.createElement(Fragment, null, null);
+  var thenElement = hasThen2;
+  var hasThenProps = hasThen2.props;
+  if (typeof hasThenProps.children === "function") {
+    thenElement = _extends({}, hasThen2, {
+      props: _extends({}, hasThenProps, {
+        children: function children2() {
+          return hasThenProps.children(returnValue, history.current, cancellablePromise.promise);
+        }
+      })
+    });
+  }
+  return $dbSRa$react.createElement(Fragment, null, thenElement);
+}
+var getConditionResult = function getConditionResult2(condition) {
+  var conditionResult = Boolean(typeof condition === "function" ? condition() : condition);
+  return conditionResult;
+};
+function tinyWarning(condition, message) {
+  if (process.env.NODE_ENV !== "production") {
+    if (condition) {
+      if (typeof console !== "undefined") {
+        console.warn(message);
+      }
+      try {
+        throw new Error(message);
+      } catch (x) {
+      }
+    }
+  }
+}
+var If = function If2(_ref) {
+  var condition = _ref.condition, _ref$keepAlive = _ref.keepAlive, keepAlive = _ref$keepAlive === void 0 ? false : _ref$keepAlive, children = _ref.children;
+  if (!children) {
+    return null;
+  }
+  tinyWarning(!Array.isArray(children) && !(children.type === Else || children.type === Then) || !$dbSRa$react__default.Children.toArray(children).every(function(child) {
+    return child.type === Else || child.type === Then || child.type === Fallback;
+  }), "The <If> component should contain <Then /> <Else /> or <Fallback /> components as its children");
+  if (isThenable(condition)) {
+    return $dbSRa$react__default.createElement(IfAsync, {
+      promise: condition,
+      keepAlive
+    }, children);
+  }
+  var conditionResult = getConditionResult(condition);
+  return $dbSRa$react__default.createElement(Fragment, null, $dbSRa$react__default.Children.toArray(children).find(function(c) {
+    return c.type !== Else !== !conditionResult;
+  }) || null);
+};
+var Switch = function Switch2(_ref) {
+  var _ref2;
+  var children = _ref.children;
+  var matchingCase = void 0;
+  var defaultCase = void 0;
+  if (isFunction(children)) {
+    children = children();
+  }
+  $dbSRa$react.Children.forEach(children, function(child) {
+    if (!$dbSRa$react.isValidElement(child)) {
+      return;
+    }
+    if (!matchingCase && child.type === Case) {
+      var childProps = child.props;
+      var conditionResult = getConditionResult(childProps.condition);
+      if (conditionResult) {
+        matchingCase = child;
+      }
+    } else if (!defaultCase && child.type === Default) {
+      defaultCase = child;
+    }
+  });
+  return (_ref2 = matchingCase != null ? matchingCase : defaultCase) != null ? _ref2 : null;
+};
+export {
+  Case as C,
+  Default as D,
+  Else as E,
+  If as I,
+  Switch as S,
+  Then as T
+};
+//# sourceMappingURL=react-if.esm-BV55Vzhf.js.map