@cfx-dev/ui-components 0.0.5

package/dist/components/Layout/Scrollable/VirtualScrollable.js

@@ -0,0 +1,426 @@
+import { jsx as R } from "react/jsx-runtime";
+import N, { createElement as k, PureComponent as ne } from "react";
+import { clsx as oe } from "../../../utils/clsx.js";
+import { Scrollable as le } from "./Scrollable.js";
+import { s as se } from "../../../Rail-DoYzqKk4.js";
+function A() {
+  return A = Object.assign ? Object.assign.bind() : function(r) {
+    for (var t = 1; t < arguments.length; t++) {
+      var i = arguments[t];
+      for (var l in i)
+        ({}).hasOwnProperty.call(i, l) && (r[l] = i[l]);
+    }
+    return r;
+  }, A.apply(null, arguments);
+}
+function H(r) {
+  if (r === void 0)
+    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+  return r;
+}
+function F(r, t) {
+  return F = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function(i, l) {
+    return i.__proto__ = l, i;
+  }, F(r, t);
+}
+function ae(r, t) {
+  r.prototype = Object.create(t.prototype), r.prototype.constructor = r, F(r, t);
+}
+var j = Number.isNaN || function(t) {
+  return typeof t == "number" && t !== t;
+};
+function ce(r, t) {
+  return !!(r === t || j(r) && j(t));
+}
+function ue(r, t) {
+  if (r.length !== t.length)
+    return !1;
+  for (var i = 0; i < r.length; i++)
+    if (!ce(r[i], t[i]))
+      return !1;
+  return !0;
+}
+function D(r, t) {
+  t === void 0 && (t = ue);
+  var i, l = [], a, y = !1;
+  function m() {
+    for (var v = [], S = 0; S < arguments.length; S++)
+      v[S] = arguments[S];
+    return y && i === this && t(v, l) || (a = r.apply(this, v), y = !0, i = this, l = v), a;
+  }
+  return m;
+}
+var de = typeof performance == "object" && typeof performance.now == "function", K = de ? function() {
+  return performance.now();
+} : function() {
+  return Date.now();
+};
+function B(r) {
+  cancelAnimationFrame(r.id);
+}
+function fe(r, t) {
+  var i = K();
+  function l() {
+    K() - i >= t ? r.call(null) : a.id = requestAnimationFrame(l);
+  }
+  var a = {
+    id: requestAnimationFrame(l)
+  };
+  return a;
+}
+var L = -1;
+function G(r) {
+  if (r === void 0 && (r = !1), L === -1 || r) {
+    var t = document.createElement("div"), i = t.style;
+    i.width = "50px", i.height = "50px", i.overflow = "scroll", document.body.appendChild(t), L = t.offsetWidth - t.clientWidth, document.body.removeChild(t);
+  }
+  return L;
+}
+var _ = null;
+function J(r) {
+  if (r === void 0 && (r = !1), _ === null || r) {
+    var t = document.createElement("div"), i = t.style;
+    i.width = "50px", i.height = "50px", i.overflow = "scroll", i.direction = "rtl";
+    var l = document.createElement("div"), a = l.style;
+    return a.width = "100px", a.height = "100px", t.appendChild(l), document.body.appendChild(t), t.scrollLeft > 0 ? _ = "positive-descending" : (t.scrollLeft = 1, t.scrollLeft === 0 ? _ = "negative" : _ = "positive-ascending"), document.body.removeChild(t), _;
+  }
+  return _;
+}
+process.env.NODE_ENV;
+var he = 150, pe = function(t, i) {
+  return t;
+}, P = null, M = null;
+process.env.NODE_ENV !== "production" && typeof window < "u" && typeof window.WeakSet < "u" && (P = /* @__PURE__ */ new WeakSet(), M = /* @__PURE__ */ new WeakSet());
+function me(r) {
+  var t, i = r.getItemOffset, l = r.getEstimatedTotalSize, a = r.getItemSize, y = r.getOffsetForIndexAndAlignment, m = r.getStartIndexForOffset, v = r.getStopIndexForStartIndex, S = r.initInstanceProps, I = r.shouldResetStyleCacheOnItemSizeChange, g = r.validateProps;
+  return t = /* @__PURE__ */ function(w) {
+    ae(z, w);
+    function z(p) {
+      var e;
+      return e = w.call(this, p) || this, e._instanceProps = S(e.props, H(e)), e._outerRef = void 0, e._resetIsScrollingTimeoutId = null, e.state = {
+        instance: H(e),
+        isScrolling: !1,
+        scrollDirection: "forward",
+        scrollOffset: typeof e.props.initialScrollOffset == "number" ? e.props.initialScrollOffset : 0,
+        scrollUpdateWasRequested: !1
+      }, e._callOnItemsRendered = void 0, e._callOnItemsRendered = D(function(n, o, s, u) {
+        return e.props.onItemsRendered({
+          overscanStartIndex: n,
+          overscanStopIndex: o,
+          visibleStartIndex: s,
+          visibleStopIndex: u
+        });
+      }), e._callOnScroll = void 0, e._callOnScroll = D(function(n, o, s) {
+        return e.props.onScroll({
+          scrollDirection: n,
+          scrollOffset: o,
+          scrollUpdateWasRequested: s
+        });
+      }), e._getItemStyle = void 0, e._getItemStyle = function(n) {
+        var o = e.props, s = o.direction, u = o.itemSize, f = o.layout, c = e._getItemStyleCache(I && u, I && f, I && s), d;
+        if (c.hasOwnProperty(n))
+          d = c[n];
+        else {
+          var h = i(e.props, n, e._instanceProps), O = a(e.props, n, e._instanceProps), T = s === "horizontal" || f === "horizontal", x = s === "rtl", E = T ? h : 0;
+          c[n] = d = {
+            position: "absolute",
+            left: x ? void 0 : E,
+            right: x ? E : void 0,
+            top: T ? 0 : h,
+            height: T ? "100%" : O,
+            width: T ? O : "100%"
+          };
+        }
+        return d;
+      }, e._getItemStyleCache = void 0, e._getItemStyleCache = D(function(n, o, s) {
+        return {};
+      }), e._onScrollHorizontal = function(n) {
+        var o = n.currentTarget, s = o.clientWidth, u = o.scrollLeft, f = o.scrollWidth;
+        e.setState(function(c) {
+          if (c.scrollOffset === u)
+            return null;
+          var d = e.props.direction, h = u;
+          if (d === "rtl")
+            switch (J()) {
+              case "negative":
+                h = -u;
+                break;
+              case "positive-descending":
+                h = f - s - u;
+                break;
+            }
+          return h = Math.max(0, Math.min(h, f - s)), {
+            isScrolling: !0,
+            scrollDirection: c.scrollOffset < h ? "forward" : "backward",
+            scrollOffset: h,
+            scrollUpdateWasRequested: !1
+          };
+        }, e._resetIsScrollingDebounced);
+      }, e._onScrollVertical = function(n) {
+        var o = n.currentTarget, s = o.clientHeight, u = o.scrollHeight, f = o.scrollTop;
+        e.setState(function(c) {
+          if (c.scrollOffset === f)
+            return null;
+          var d = Math.max(0, Math.min(f, u - s));
+          return {
+            isScrolling: !0,
+            scrollDirection: c.scrollOffset < d ? "forward" : "backward",
+            scrollOffset: d,
+            scrollUpdateWasRequested: !1
+          };
+        }, e._resetIsScrollingDebounced);
+      }, e._outerRefSetter = function(n) {
+        var o = e.props.outerRef;
+        e._outerRef = n, typeof o == "function" ? o(n) : o != null && typeof o == "object" && o.hasOwnProperty("current") && (o.current = n);
+      }, e._resetIsScrollingDebounced = function() {
+        e._resetIsScrollingTimeoutId !== null && B(e._resetIsScrollingTimeoutId), e._resetIsScrollingTimeoutId = fe(e._resetIsScrolling, he);
+      }, e._resetIsScrolling = function() {
+        e._resetIsScrollingTimeoutId = null, e.setState({
+          isScrolling: !1
+        }, function() {
+          e._getItemStyleCache(-1, null);
+        });
+      }, e;
+    }
+    z.getDerivedStateFromProps = function(e, n) {
+      return ve(e, n), g(e), null;
+    };
+    var b = z.prototype;
+    return b.scrollTo = function(e) {
+      e = Math.max(0, e), this.setState(function(n) {
+        return n.scrollOffset === e ? null : {
+          scrollDirection: n.scrollOffset < e ? "forward" : "backward",
+          scrollOffset: e,
+          scrollUpdateWasRequested: !0
+        };
+      }, this._resetIsScrollingDebounced);
+    }, b.scrollToItem = function(e, n) {
+      n === void 0 && (n = "auto");
+      var o = this.props, s = o.itemCount, u = o.layout, f = this.state.scrollOffset;
+      e = Math.max(0, Math.min(e, s - 1));
+      var c = 0;
+      if (this._outerRef) {
+        var d = this._outerRef;
+        u === "vertical" ? c = d.scrollWidth > d.clientWidth ? G() : 0 : c = d.scrollHeight > d.clientHeight ? G() : 0;
+      }
+      this.scrollTo(y(this.props, e, n, f, this._instanceProps, c));
+    }, b.componentDidMount = function() {
+      var e = this.props, n = e.direction, o = e.initialScrollOffset, s = e.layout;
+      if (typeof o == "number" && this._outerRef != null) {
+        var u = this._outerRef;
+        n === "horizontal" || s === "horizontal" ? u.scrollLeft = o : u.scrollTop = o;
+      }
+      this._callPropsCallbacks();
+    }, b.componentDidUpdate = function() {
+      var e = this.props, n = e.direction, o = e.layout, s = this.state, u = s.scrollOffset, f = s.scrollUpdateWasRequested;
+      if (f && this._outerRef != null) {
+        var c = this._outerRef;
+        if (n === "horizontal" || o === "horizontal")
+          if (n === "rtl")
+            switch (J()) {
+              case "negative":
+                c.scrollLeft = -u;
+                break;
+              case "positive-ascending":
+                c.scrollLeft = u;
+                break;
+              default:
+                var d = c.clientWidth, h = c.scrollWidth;
+                c.scrollLeft = h - d - u;
+                break;
+            }
+          else
+            c.scrollLeft = u;
+        else
+          c.scrollTop = u;
+      }
+      this._callPropsCallbacks();
+    }, b.componentWillUnmount = function() {
+      this._resetIsScrollingTimeoutId !== null && B(this._resetIsScrollingTimeoutId);
+    }, b.render = function() {
+      var e = this.props, n = e.children, o = e.className, s = e.direction, u = e.height, f = e.innerRef, c = e.innerElementType, d = e.innerTagName, h = e.itemCount, O = e.itemData, T = e.itemKey, x = T === void 0 ? pe : T, E = e.layout, Q = e.outerElementType, X = e.outerTagName, Y = e.style, Z = e.useIsScrolling, ee = e.width, V = this.state.isScrolling, W = s === "horizontal" || E === "horizontal", te = W ? this._onScrollHorizontal : this._onScrollVertical, U = this._getRangeToRender(), re = U[0], ie = U[1], $ = [];
+      if (h > 0)
+        for (var C = re; C <= ie; C++)
+          $.push(k(n, {
+            data: O,
+            key: x(C, O),
+            index: C,
+            isScrolling: Z ? V : void 0,
+            style: this._getItemStyle(C)
+          }));
+      var q = l(this.props, this._instanceProps);
+      return k(Q || X || "div", {
+        className: o,
+        onScroll: te,
+        ref: this._outerRefSetter,
+        style: A({
+          position: "relative",
+          height: u,
+          width: ee,
+          overflow: "auto",
+          WebkitOverflowScrolling: "touch",
+          willChange: "transform",
+          direction: s
+        }, Y)
+      }, k(c || d || "div", {
+        children: $,
+        ref: f,
+        style: {
+          height: W ? "100%" : q,
+          pointerEvents: V ? "none" : void 0,
+          width: W ? q : "100%"
+        }
+      }));
+    }, b._callPropsCallbacks = function() {
+      if (typeof this.props.onItemsRendered == "function") {
+        var e = this.props.itemCount;
+        if (e > 0) {
+          var n = this._getRangeToRender(), o = n[0], s = n[1], u = n[2], f = n[3];
+          this._callOnItemsRendered(o, s, u, f);
+        }
+      }
+      if (typeof this.props.onScroll == "function") {
+        var c = this.state, d = c.scrollDirection, h = c.scrollOffset, O = c.scrollUpdateWasRequested;
+        this._callOnScroll(d, h, O);
+      }
+    }, b._getRangeToRender = function() {
+      var e = this.props, n = e.itemCount, o = e.overscanCount, s = this.state, u = s.isScrolling, f = s.scrollDirection, c = s.scrollOffset;
+      if (n === 0)
+        return [0, 0, 0, 0];
+      var d = m(this.props, c, this._instanceProps), h = v(this.props, d, c, this._instanceProps), O = !u || f === "backward" ? Math.max(1, o) : 1, T = !u || f === "forward" ? Math.max(1, o) : 1;
+      return [Math.max(0, d - O), Math.max(0, Math.min(n - 1, h + T)), d, h];
+    }, z;
+  }(ne), t.defaultProps = {
+    direction: "ltr",
+    itemData: void 0,
+    layout: "vertical",
+    overscanCount: 2,
+    useIsScrolling: !1
+  }, t;
+}
+var ve = function(t, i) {
+  var l = t.children, a = t.direction, y = t.height, m = t.layout, v = t.innerTagName, S = t.outerTagName, I = t.width, g = i.instance;
+  if (process.env.NODE_ENV !== "production") {
+    (v != null || S != null) && M && !M.has(g) && (M.add(g), console.warn("The innerTagName and outerTagName props have been deprecated. Please use the innerElementType and outerElementType props instead."));
+    var w = a === "horizontal" || m === "horizontal";
+    switch (a) {
+      case "horizontal":
+      case "vertical":
+        P && !P.has(g) && (P.add(g), console.warn('The direction prop should be either "ltr" (default) or "rtl". Please use the layout prop to specify "vertical" (default) or "horizontal" orientation.'));
+        break;
+      case "ltr":
+      case "rtl":
+        break;
+      default:
+        throw Error('An invalid "direction" prop has been specified. Value should be either "ltr" or "rtl". ' + ('"' + a + '" was specified.'));
+    }
+    switch (m) {
+      case "horizontal":
+      case "vertical":
+        break;
+      default:
+        throw Error('An invalid "layout" prop has been specified. Value should be either "horizontal" or "vertical". ' + ('"' + m + '" was specified.'));
+    }
+    if (l == null)
+      throw Error('An invalid "children" prop has been specified. Value should be a React component. ' + ('"' + (l === null ? "null" : typeof l) + '" was specified.'));
+    if (w && typeof I != "number")
+      throw Error('An invalid "width" prop has been specified. Horizontal lists must specify a number for width. ' + ('"' + (I === null ? "null" : typeof I) + '" was specified.'));
+    if (!w && typeof y != "number")
+      throw Error('An invalid "height" prop has been specified. Vertical lists must specify a number for height. ' + ('"' + (y === null ? "null" : typeof y) + '" was specified.'));
+  }
+}, ge = /* @__PURE__ */ me({
+  getItemOffset: function(t, i) {
+    var l = t.itemSize;
+    return i * l;
+  },
+  getItemSize: function(t, i) {
+    var l = t.itemSize;
+    return l;
+  },
+  getEstimatedTotalSize: function(t) {
+    var i = t.itemCount, l = t.itemSize;
+    return l * i;
+  },
+  getOffsetForIndexAndAlignment: function(t, i, l, a, y, m) {
+    var v = t.direction, S = t.height, I = t.itemCount, g = t.itemSize, w = t.layout, z = t.width, b = v === "horizontal" || w === "horizontal", p = b ? z : S, e = Math.max(0, I * g - p), n = Math.min(e, i * g), o = Math.max(0, i * g - p + g + m);
+    switch (l === "smart" && (a >= o - p && a <= n + p ? l = "auto" : l = "center"), l) {
+      case "start":
+        return n;
+      case "end":
+        return o;
+      case "center": {
+        var s = Math.round(o + (n - o) / 2);
+        return s < Math.ceil(p / 2) ? 0 : s > e + Math.floor(p / 2) ? e : s;
+      }
+      case "auto":
+      default:
+        return a >= o && a <= n ? a : a < o ? o : n;
+    }
+  },
+  getStartIndexForOffset: function(t, i) {
+    var l = t.itemCount, a = t.itemSize;
+    return Math.max(0, Math.min(l - 1, Math.floor(i / a)));
+  },
+  getStopIndexForStartIndex: function(t, i, l) {
+    var a = t.direction, y = t.height, m = t.itemCount, v = t.itemSize, S = t.layout, I = t.width, g = a === "horizontal" || S === "horizontal", w = i * v, z = g ? I : y, b = Math.ceil((z + l - w) / v);
+    return Math.max(0, Math.min(
+      m - 1,
+      i + b - 1
+      // -1 is because stop index is inclusive
+    ));
+  },
+  initInstanceProps: function(t) {
+  },
+  shouldResetStyleCacheOnItemSizeChange: !0,
+  validateProps: function(t) {
+    var i = t.itemSize;
+    if (process.env.NODE_ENV !== "production" && typeof i != "number")
+      throw Error('An invalid "itemSize" prop has been specified. Value should be a number. ' + ('"' + (i === null ? "null" : typeof i) + '" was specified.'));
+  }
+});
+function Se() {
+  const [r, t] = N.useState([500, 500]), i = N.useRef(null);
+  return N.useEffect(() => {
+    const l = () => {
+      if (i.current) {
+        const a = i.current.getBoundingClientRect();
+        t([a.width, a.height]);
+      }
+    };
+    return l(), window.addEventListener("resize", l), () => {
+      window.removeEventListener("resize", l);
+    };
+  }, []), [i, ...r];
+}
+const ye = N.forwardRef(function(t, i) {
+  return /* @__PURE__ */ R(le, { scrollerRef: i, ...t });
+});
+function Te(r) {
+  const {
+    className: t,
+    itemCount: i,
+    itemHeight: l,
+    renderItem: a,
+    initialScrollOffset: y,
+    onScrollUpdate: m
+  } = r, v = m ? (w) => m == null ? void 0 : m(w.scrollOffset) : void 0, [S, I, g] = Se();
+  return /* @__PURE__ */ R("div", { ref: S, className: oe(se.virtual, t), children: /* @__PURE__ */ R(
+    ge,
+    {
+      outerElementType: ye,
+      width: I,
+      height: g,
+      itemCount: i,
+      itemSize: l,
+      initialScrollOffset: y,
+      onScroll: v,
+      children: ({
+        index: w,
+        style: z
+      }) => /* @__PURE__ */ R("div", { style: z, children: a(w) })
+    }
+  ) });
+}
+export {
+  Te as VirtualScrollable
+};

package/dist/components/Loaf/Loaf.d.ts

@@ -0,0 +1,12 @@
+import { default as React } from 'react';
+
+export type LoafSize = 'small' | 'normal' | 'large';
+export type LoafColor = 'normal' | 'gold' | 'error';
+export interface LoafProps {
+    size?: LoafSize;
+    color?: LoafColor;
+    bright?: boolean;
+    className?: string;
+    children: React.ReactNode;
+}
+export declare const Loaf: React.ForwardRefExoticComponent<LoafProps & React.RefAttributes<HTMLDivElement>>;

package/dist/components/Loaf/Loaf.js

@@ -0,0 +1,27 @@
+import { jsx as c } from "react/jsx-runtime";
+import i from "react";
+import { clsx as m } from "../../utils/clsx.js";
+import '../../assets/Loaf.css';const n = "_root_gg27t_1", f = "_bright_gg27t_14", o = {
+  root: n,
+  "color-normal": "_color-normal_gg27t_10",
+  bright: f,
+  "color-gold": "_color-gold_gg27t_17",
+  "color-error": "_color-error_gg27t_24",
+  "size-small": "_size-small_gg27t_32",
+  "size-normal": "_size-normal_gg27t_39",
+  "size-large": "_size-large_gg27t_46"
+}, p = i.forwardRef(function(r, t) {
+  const {
+    size: l = "normal",
+    color: s = "normal",
+    bright: _ = !1,
+    children: g,
+    className: a
+  } = r, e = m(o.root, o[`size-${l}`], o[`color-${s}`], a, {
+    [o.bright]: _
+  });
+  return /* @__PURE__ */ c("div", { ref: t, className: e, children: g });
+});
+export {
+  p as Loaf
+};

package/dist/components/Modal/Modal.d.ts

@@ -0,0 +1,18 @@
+import { default as React } from 'react';
+
+export interface ModalProps {
+    children: React.ReactNode;
+    onClose?: () => void;
+    backdropClassName?: string;
+    contentClassName?: string;
+    disableBackdropClose?: boolean;
+}
+export declare function Modal(props: ModalProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Modal {
+    var Header: ({ children, }: {
+        children?: React.ReactNode;
+    }) => import("react/jsx-runtime").JSX.Element;
+    var Footer: ({ children, }: {
+        children?: React.ReactNode;
+    }) => import("react/jsx-runtime").JSX.Element;
+}

package/dist/components/Modal/Modal.js

@@ -0,0 +1,42 @@
+import { jsxs as n, jsx as o } from "react/jsx-runtime";
+import { Button as _ } from "../Button/Button.js";
+import { I as f } from "../../Icons-B26SczGZ.js";
+import { Overlay as s } from "../Overlay/Overlay.js";
+import { n as c } from "../../functional-C0pE183N.js";
+import { b as h } from "../../hooks-Bv1kQUpO.js";
+import '../../assets/Modal.css';const v = "_root_1v8ee_1", C = "_close_1v8ee_27", u = "_header_1v8ee_37", N = "_footer_1v8ee_47", r = {
+  root: v,
+  "modal-appearance": "_modal-appearance_1v8ee_1",
+  close: C,
+  header: u,
+  footer: N
+};
+function l(a) {
+  const {
+    onClose: e = c,
+    children: d,
+    backdropClassName: i,
+    contentClassName: m,
+    disableBackdropClose: p = !1
+  } = a, t = p ? c : e;
+  return h(t), /* @__PURE__ */ n(s, { children: [
+    /* @__PURE__ */ o(s.Backdrop, { onClick: t, className: i }),
+    /* @__PURE__ */ o(s.Content, { className: m, children: /* @__PURE__ */ n("div", { className: r.root, children: [
+      !!e && /* @__PURE__ */ o("div", { className: r.close, children: /* @__PURE__ */ o(_, { size: "large", theme: "transparent", icon: f.exit, onClick: e }) }),
+      d
+    ] }) })
+  ] });
+}
+l.Header = function({
+  children: e
+}) {
+  return /* @__PURE__ */ o("div", { className: r.header, children: e });
+};
+l.Footer = function({
+  children: e
+}) {
+  return /* @__PURE__ */ o("div", { className: r.footer, children: e });
+};
+export {
+  l as Modal
+};

package/dist/components/NavList/NavList.d.ts

@@ -0,0 +1,14 @@
+import { default as React } from 'react';
+import { ValueOrGetter } from '../../utils/getValue';
+
+export interface NavListItem {
+    id: string;
+    icon?: ValueOrGetter<React.ReactNode>;
+    label: ValueOrGetter<React.ReactNode>;
+}
+export interface NavListProps {
+    items: NavListItem[];
+    activeItemId: string;
+    onActivate?(id: string): void;
+}
+export declare const NavList: React.ForwardRefExoticComponent<NavListProps & React.RefAttributes<HTMLDivElement>>;

package/dist/components/NavList/NavList.js

@@ -0,0 +1,33 @@
+import { jsxs as l, jsx as i } from "react/jsx-runtime";
+import d from "react";
+import { Interactive as _ } from "../Interactive/Interactive.js";
+import { clsx as v } from "../../utils/clsx.js";
+import { n as f } from "../../functional-C0pE183N.js";
+import { getValue as c } from "../../utils/getValue.js";
+import '../../assets/NavList.css';const p = "_root_2ug76_1", u = "_item_2ug76_5", N = "_active_2ug76_23", g = "_icon_2ug76_33", t = {
+  root: p,
+  item: u,
+  active: N,
+  icon: g
+}, k = d.forwardRef(function(e, n) {
+  const {
+    items: r,
+    activeItemId: s,
+    onActivate: a = f
+  } = e, m = r.map((o) => /* @__PURE__ */ l(
+    _,
+    {
+      className: v(t.item, { [t.active]: o.id === s }),
+      onClick: () => a(o.id),
+      children: [
+        !!o.icon && /* @__PURE__ */ i("div", { className: t.icon, children: c(o.icon) }),
+        /* @__PURE__ */ i("div", { className: t.label, children: c(o.label) })
+      ]
+    },
+    o.id
+  ));
+  return /* @__PURE__ */ i("div", { ref: n, className: t.root, children: m });
+});
+export {
+  k as NavList
+};

package/dist/components/OnScreenSensor.d.ts

@@ -0,0 +1,5 @@
+export interface OnScreenSensorProps {
+    onEnter?(): void;
+    onLeave?(): void;
+}
+export declare function OnScreenSensor(props: OnScreenSensorProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/OnScreenSensor.js

@@ -0,0 +1,26 @@
+import { jsx as p } from "react/jsx-runtime";
+import t from "react";
+import { n as o } from "../functional-C0pE183N.js";
+import { u as s } from "../hooks-Bv1kQUpO.js";
+const l = {
+  width: "0",
+  height: "0"
+};
+function h(c) {
+  const {
+    onEnter: f = o,
+    onLeave: i = o
+  } = c, u = s(f), m = s(i), e = t.useRef(null);
+  return t.useEffect(() => {
+    if (!e.current)
+      return;
+    const n = new IntersectionObserver((a) => {
+      const [r] = a;
+      r && (r.isIntersecting ? u.current() : m.current());
+    });
+    return n.observe(e.current), () => n.disconnect();
+  }, []), /* @__PURE__ */ p("span", { ref: e, style: l });
+}
+export {
+  h as OnScreenSensor
+};

package/dist/components/Overlay/Overlay.d.ts

@@ -0,0 +1,20 @@
+import { default as React } from 'react';
+
+export interface OverlayProps {
+    children: React.ReactNode;
+    className?: string;
+}
+export declare function Overlay(props: OverlayProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Overlay {
+    var Backdrop: React.ForwardRefExoticComponent<OverlayBackdropProps & React.RefAttributes<HTMLDivElement>>;
+    var Content: React.ForwardRefExoticComponent<OverlayContentProps & React.RefAttributes<HTMLDivElement>>;
+}
+export interface OverlayBackdropProps {
+    children?: React.ReactNode;
+    className?: string;
+    onClick?(): void;
+}
+export interface OverlayContentProps {
+    children?: React.ReactNode;
+    className?: string;
+}

package/dist/components/Overlay/Overlay.js

@@ -0,0 +1,28 @@
+import { jsx as r } from "react/jsx-runtime";
+import n from "react";
+import { F as s } from "../../Combination-AG9vHdSx.js";
+import { Interactive as i } from "../Interactive/Interactive.js";
+import { clsx as a } from "../../utils/clsx.js";
+import { a as m } from "../../outlet-C4wpavcH.js";
+import '../../assets/Overlay.css';const u = "_root_15udb_1", f = "_backdrop_15udb_9", _ = "_content_15udb_27", e = {
+  root: u,
+  backdrop: f,
+  "backdrop-appearance": "_backdrop-appearance_15udb_1",
+  content: _
+}, p = m("overlay-outlet");
+function l(c) {
+  const {
+    className: o,
+    children: t
+  } = c, d = a(e.root, o);
+  return /* @__PURE__ */ r(p, { children: /* @__PURE__ */ r("div", { className: d, children: t }) });
+}
+l.Backdrop = n.forwardRef(function(o, t) {
+  return /* @__PURE__ */ r(i, { ref: t, onClick: o.onClick, className: a(e.backdrop, o.className), children: o.children });
+});
+l.Content = n.forwardRef(function(o, t) {
+  return /* @__PURE__ */ r("div", { ref: t, className: a(e.content, o.className), children: /* @__PURE__ */ r(s, { children: o.children }) });
+});
+export {
+  l as Overlay
+};

package/dist/components/Popover/Popover.d.ts

@@ -0,0 +1,12 @@
+import { default as React } from 'react';
+import { InteractiveProps } from '../Interactive/Interactive';
+
+type PopoverPosition = 'top-right';
+export interface PopoverProps extends Omit<InteractiveProps, 'children'> {
+    at: PopoverPosition;
+    popover: React.ReactNode;
+    children: (active: boolean) => React.ReactNode;
+    active?: boolean;
+}
+export declare const Popover: React.ForwardRefExoticComponent<Omit<PopoverProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export {};