@gobolt/genesis 0.0.7

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from './components';
+export * from './providers';

package/dist/index.js

@@ -0,0 +1,20 @@
+import { default as e } from "./components/atoms/button/Button.js";
+import { default as a } from "./components/atoms/input/Input.js";
+import { default as p } from "./components/atoms/select/Select.js";
+import { default as s } from "./components/atoms/checkbox/Checkbox.js";
+import { default as x } from "./components/atoms/typography/Typography.js";
+import { F as d } from "./Form-Cylpi4M4.js";
+import { default as c } from "./components/molecules/error-boundary-fallback/ErrorBoundaryFallback.js";
+import { GenesisProvider as k } from "./providers/GenesisProvider.js";
+import { useBreakpoint as B } from "./providers/ThemeProvider.js";
+export {
+  e as Button,
+  s as Checkbox,
+  c as ErrorBoundaryFallback,
+  d as Form,
+  k as GenesisProvider,
+  a as Input,
+  p as Select,
+  x as Typography,
+  B as useBreakpoint
+};

package/dist/isVisible-CNQjrJPN.js

@@ -0,0 +1,366 @@
+import { i as Z, j as W, e as q, k as z, l as D, b as H } from "./index-BWys7dkb.js";
+import $ from "react";
+function J(i) {
+  var c = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}, f = [];
+  return $.Children.forEach(i, function(u) {
+    u == null && !c.keepEmpty || (Array.isArray(u) ? f = f.concat(J(u)) : Z(u) && u.props ? f = f.concat(J(u.props.children, c)) : f.push(u));
+  }), f;
+}
+function nt(i, c) {
+  var f = Object.assign({}, i);
+  return Array.isArray(c) && c.forEach(function(u) {
+    delete f[u];
+  }), f;
+}
+function B(i) {
+  return i !== void 0;
+}
+function ot(i, c) {
+  var f = c || {}, u = f.defaultValue, l = f.value, m = f.onChange, p = f.postState, x = W(function() {
+    return B(l) ? l : B(u) ? typeof u == "function" ? u() : u : typeof i == "function" ? i() : i;
+  }), d = q(x, 2), h = d[0], G = d[1], E = l !== void 0 ? l : h, A = p ? p(E) : E, C = z(m), T = W([E]), L = q(T, 2), g = L[0], P = L[1];
+  D(function() {
+    var w = g[0];
+    h !== w && C(h, w);
+  }, [g]), D(function() {
+    B(l) || G(l);
+  }, [l]);
+  var k = z(function(w, O) {
+    G(w, O), P([E], O);
+  });
+  return [A, k];
+}
+function tt() {
+  tt = function() {
+    return c;
+  };
+  var i, c = {}, f = Object.prototype, u = f.hasOwnProperty, l = Object.defineProperty || function(r, t, e) {
+    r[t] = e.value;
+  }, m = typeof Symbol == "function" ? Symbol : {}, p = m.iterator || "@@iterator", x = m.asyncIterator || "@@asyncIterator", d = m.toStringTag || "@@toStringTag";
+  function h(r, t, e) {
+    return Object.defineProperty(r, t, {
+      value: e,
+      enumerable: !0,
+      configurable: !0,
+      writable: !0
+    }), r[t];
+  }
+  try {
+    h({}, "");
+  } catch {
+    h = function(e, n, a) {
+      return e[n] = a;
+    };
+  }
+  function G(r, t, e, n) {
+    var a = t && t.prototype instanceof P ? t : P, o = Object.create(a.prototype), s = new M(n || []);
+    return l(o, "_invoke", {
+      value: Q(r, e, s)
+    }), o;
+  }
+  function E(r, t, e) {
+    try {
+      return {
+        type: "normal",
+        arg: r.call(t, e)
+      };
+    } catch (n) {
+      return {
+        type: "throw",
+        arg: n
+      };
+    }
+  }
+  c.wrap = G;
+  var A = "suspendedStart", C = "suspendedYield", T = "executing", L = "completed", g = {};
+  function P() {
+  }
+  function k() {
+  }
+  function w() {
+  }
+  var O = {};
+  h(O, p, function() {
+    return this;
+  });
+  var N = Object.getPrototypeOf, F = N && N(N(R([])));
+  F && F !== f && u.call(F, p) && (O = F);
+  var S = w.prototype = P.prototype = Object.create(O);
+  function Y(r) {
+    ["next", "throw", "return"].forEach(function(t) {
+      h(r, t, function(e) {
+        return this._invoke(t, e);
+      });
+    });
+  }
+  function I(r, t) {
+    function e(a, o, s, v) {
+      var y = E(r[a], r, o);
+      if (y.type !== "throw") {
+        var _ = y.arg, b = _.value;
+        return b && H(b) == "object" && u.call(b, "__await") ? t.resolve(b.__await).then(function(j) {
+          e("next", j, s, v);
+        }, function(j) {
+          e("throw", j, s, v);
+        }) : t.resolve(b).then(function(j) {
+          _.value = j, s(_);
+        }, function(j) {
+          return e("throw", j, s, v);
+        });
+      }
+      v(y.arg);
+    }
+    var n;
+    l(this, "_invoke", {
+      value: function(o, s) {
+        function v() {
+          return new t(function(y, _) {
+            e(o, s, y, _);
+          });
+        }
+        return n = n ? n.then(v, v) : v();
+      }
+    });
+  }
+  function Q(r, t, e) {
+    var n = A;
+    return function(a, o) {
+      if (n === T) throw Error("Generator is already running");
+      if (n === L) {
+        if (a === "throw") throw o;
+        return {
+          value: i,
+          done: !0
+        };
+      }
+      for (e.method = a, e.arg = o; ; ) {
+        var s = e.delegate;
+        if (s) {
+          var v = U(s, e);
+          if (v) {
+            if (v === g) continue;
+            return v;
+          }
+        }
+        if (e.method === "next") e.sent = e._sent = e.arg;
+        else if (e.method === "throw") {
+          if (n === A) throw n = L, e.arg;
+          e.dispatchException(e.arg);
+        } else e.method === "return" && e.abrupt("return", e.arg);
+        n = T;
+        var y = E(r, t, e);
+        if (y.type === "normal") {
+          if (n = e.done ? L : C, y.arg === g) continue;
+          return {
+            value: y.arg,
+            done: e.done
+          };
+        }
+        y.type === "throw" && (n = L, e.method = "throw", e.arg = y.arg);
+      }
+    };
+  }
+  function U(r, t) {
+    var e = t.method, n = r.iterator[e];
+    if (n === i) return t.delegate = null, e === "throw" && r.iterator.return && (t.method = "return", t.arg = i, U(r, t), t.method === "throw") || e !== "return" && (t.method = "throw", t.arg = new TypeError("The iterator does not provide a '" + e + "' method")), g;
+    var a = E(n, r.iterator, t.arg);
+    if (a.type === "throw") return t.method = "throw", t.arg = a.arg, t.delegate = null, g;
+    var o = a.arg;
+    return o ? o.done ? (t[r.resultName] = o.value, t.next = r.nextLoc, t.method !== "return" && (t.method = "next", t.arg = i), t.delegate = null, g) : o : (t.method = "throw", t.arg = new TypeError("iterator result is not an object"), t.delegate = null, g);
+  }
+  function X(r) {
+    var t = {
+      tryLoc: r[0]
+    };
+    1 in r && (t.catchLoc = r[1]), 2 in r && (t.finallyLoc = r[2], t.afterLoc = r[3]), this.tryEntries.push(t);
+  }
+  function V(r) {
+    var t = r.completion || {};
+    t.type = "normal", delete t.arg, r.completion = t;
+  }
+  function M(r) {
+    this.tryEntries = [{
+      tryLoc: "root"
+    }], r.forEach(X, this), this.reset(!0);
+  }
+  function R(r) {
+    if (r || r === "") {
+      var t = r[p];
+      if (t) return t.call(r);
+      if (typeof r.next == "function") return r;
+      if (!isNaN(r.length)) {
+        var e = -1, n = function a() {
+          for (; ++e < r.length; ) if (u.call(r, e)) return a.value = r[e], a.done = !1, a;
+          return a.value = i, a.done = !0, a;
+        };
+        return n.next = n;
+      }
+    }
+    throw new TypeError(H(r) + " is not iterable");
+  }
+  return k.prototype = w, l(S, "constructor", {
+    value: w,
+    configurable: !0
+  }), l(w, "constructor", {
+    value: k,
+    configurable: !0
+  }), k.displayName = h(w, d, "GeneratorFunction"), c.isGeneratorFunction = function(r) {
+    var t = typeof r == "function" && r.constructor;
+    return !!t && (t === k || (t.displayName || t.name) === "GeneratorFunction");
+  }, c.mark = function(r) {
+    return Object.setPrototypeOf ? Object.setPrototypeOf(r, w) : (r.__proto__ = w, h(r, d, "GeneratorFunction")), r.prototype = Object.create(S), r;
+  }, c.awrap = function(r) {
+    return {
+      __await: r
+    };
+  }, Y(I.prototype), h(I.prototype, x, function() {
+    return this;
+  }), c.AsyncIterator = I, c.async = function(r, t, e, n, a) {
+    a === void 0 && (a = Promise);
+    var o = new I(G(r, t, e, n), a);
+    return c.isGeneratorFunction(t) ? o : o.next().then(function(s) {
+      return s.done ? s.value : o.next();
+    });
+  }, Y(S), h(S, d, "Generator"), h(S, p, function() {
+    return this;
+  }), h(S, "toString", function() {
+    return "[object Generator]";
+  }), c.keys = function(r) {
+    var t = Object(r), e = [];
+    for (var n in t) e.push(n);
+    return e.reverse(), function a() {
+      for (; e.length; ) {
+        var o = e.pop();
+        if (o in t) return a.value = o, a.done = !1, a;
+      }
+      return a.done = !0, a;
+    };
+  }, c.values = R, M.prototype = {
+    constructor: M,
+    reset: function(t) {
+      if (this.prev = 0, this.next = 0, this.sent = this._sent = i, this.done = !1, this.delegate = null, this.method = "next", this.arg = i, this.tryEntries.forEach(V), !t) for (var e in this) e.charAt(0) === "t" && u.call(this, e) && !isNaN(+e.slice(1)) && (this[e] = i);
+    },
+    stop: function() {
+      this.done = !0;
+      var t = this.tryEntries[0].completion;
+      if (t.type === "throw") throw t.arg;
+      return this.rval;
+    },
+    dispatchException: function(t) {
+      if (this.done) throw t;
+      var e = this;
+      function n(_, b) {
+        return s.type = "throw", s.arg = t, e.next = _, b && (e.method = "next", e.arg = i), !!b;
+      }
+      for (var a = this.tryEntries.length - 1; a >= 0; --a) {
+        var o = this.tryEntries[a], s = o.completion;
+        if (o.tryLoc === "root") return n("end");
+        if (o.tryLoc <= this.prev) {
+          var v = u.call(o, "catchLoc"), y = u.call(o, "finallyLoc");
+          if (v && y) {
+            if (this.prev < o.catchLoc) return n(o.catchLoc, !0);
+            if (this.prev < o.finallyLoc) return n(o.finallyLoc);
+          } else if (v) {
+            if (this.prev < o.catchLoc) return n(o.catchLoc, !0);
+          } else {
+            if (!y) throw Error("try statement without catch or finally");
+            if (this.prev < o.finallyLoc) return n(o.finallyLoc);
+          }
+        }
+      }
+    },
+    abrupt: function(t, e) {
+      for (var n = this.tryEntries.length - 1; n >= 0; --n) {
+        var a = this.tryEntries[n];
+        if (a.tryLoc <= this.prev && u.call(a, "finallyLoc") && this.prev < a.finallyLoc) {
+          var o = a;
+          break;
+        }
+      }
+      o && (t === "break" || t === "continue") && o.tryLoc <= e && e <= o.finallyLoc && (o = null);
+      var s = o ? o.completion : {};
+      return s.type = t, s.arg = e, o ? (this.method = "next", this.next = o.finallyLoc, g) : this.complete(s);
+    },
+    complete: function(t, e) {
+      if (t.type === "throw") throw t.arg;
+      return t.type === "break" || t.type === "continue" ? this.next = t.arg : t.type === "return" ? (this.rval = this.arg = t.arg, this.method = "return", this.next = "end") : t.type === "normal" && e && (this.next = e), g;
+    },
+    finish: function(t) {
+      for (var e = this.tryEntries.length - 1; e >= 0; --e) {
+        var n = this.tryEntries[e];
+        if (n.finallyLoc === t) return this.complete(n.completion, n.afterLoc), V(n), g;
+      }
+    },
+    catch: function(t) {
+      for (var e = this.tryEntries.length - 1; e >= 0; --e) {
+        var n = this.tryEntries[e];
+        if (n.tryLoc === t) {
+          var a = n.completion;
+          if (a.type === "throw") {
+            var o = a.arg;
+            V(n);
+          }
+          return o;
+        }
+      }
+      throw Error("illegal catch attempt");
+    },
+    delegateYield: function(t, e, n) {
+      return this.delegate = {
+        iterator: R(t),
+        resultName: e,
+        nextLoc: n
+      }, this.method === "next" && (this.arg = i), g;
+    }
+  }, c;
+}
+function K(i, c, f, u, l, m, p) {
+  try {
+    var x = i[m](p), d = x.value;
+  } catch (h) {
+    return void f(h);
+  }
+  x.done ? c(d) : Promise.resolve(d).then(u, l);
+}
+function at(i) {
+  return function() {
+    var c = this, f = arguments;
+    return new Promise(function(u, l) {
+      var m = i.apply(c, f);
+      function p(d) {
+        K(m, u, l, p, x, "next", d);
+      }
+      function x(d) {
+        K(m, u, l, p, x, "throw", d);
+      }
+      p(void 0);
+    });
+  };
+}
+const it = function(i) {
+  if (!i)
+    return !1;
+  if (i instanceof Element) {
+    if (i.offsetParent)
+      return !0;
+    if (i.getBBox) {
+      var c = i.getBBox(), f = c.width, u = c.height;
+      if (f || u)
+        return !0;
+    }
+    if (i.getBoundingClientRect) {
+      var l = i.getBoundingClientRect(), m = l.width, p = l.height;
+      if (m || p)
+        return !0;
+    }
+  }
+  return !1;
+};
+export {
+  at as _,
+  tt as a,
+  it as i,
+  nt as o,
+  J as t,
+  ot as u
+};