@boxcustodia/library 1.7.9 → 1.7.11

package/dist/index.es197.js

@@ -1,220 +1,13 @@
-import * as s from "react";
-import { useFloating as xe, offset as Pe, shift as ye, flip as Ae, size as ve, arrow as Ce, hide as be, limitShift as Se } from "./index.es270.js";
-import { Root as Oe } from "./index.es271.js";
-import { useComposedRefs as T } from "./index.es177.js";
-import { createContextScope as Re } from "./index.es187.js";
-import { Primitive as z } from "./index.es183.js";
-import { useCallbackRef as Ee } from "./index.es103.js";
-import { useLayoutEffect as B } from "./index.es198.js";
-import { useSize as Ne } from "./index.es272.js";
-import { j as f } from "./index.es104.js";
-import { autoUpdate as _e } from "./index.es273.js";
-var N = "Popper", [L, Ue] = Re(N), [$e, Z] = L(N), U = (e) => {
-  const { __scopePopper: i, children: n } = e, [t, a] = s.useState(null);
-  return /* @__PURE__ */ f.jsx($e, { scope: i, anchor: t, onAnchorChange: a, children: n });
-};
-U.displayName = N;
-var q = "PopperAnchor", G = s.forwardRef(
-  (e, i) => {
-    const { __scopePopper: n, virtualRef: t, ...a } = e, r = Z(q, n), o = s.useRef(null), w = T(i, o);
-    return s.useEffect(() => {
-      r.onAnchorChange((t == null ? void 0 : t.current) || o.current);
-    }), t ? null : /* @__PURE__ */ f.jsx(z.div, { ...a, ref: w });
-  }
-);
-G.displayName = q;
-var _ = "PopperContent", [je, He] = L(_), J = s.forwardRef(
-  (e, i) => {
-    var I, Y, M, X, D, F;
-    const {
-      __scopePopper: n,
-      side: t = "bottom",
-      sideOffset: a = 0,
-      align: r = "center",
-      alignOffset: o = 0,
-      arrowPadding: w = 0,
-      avoidCollisions: p = !0,
-      collisionBoundary: c = [],
-      collisionPadding: x = 0,
-      sticky: m = "partial",
-      hideWhenDetached: y = !1,
-      updatePositionStrategy: A = "optimized",
-      onPlaced: l,
-      ...d
-    } = e, v = Z(_, n), [h, C] = s.useState(null), ee = T(i, (P) => C(P)), [E, te] = s.useState(null), g = Ne(E), re = (g == null ? void 0 : g.width) ?? 0, $ = (g == null ? void 0 : g.height) ?? 0, oe = t + (r !== "center" ? "-" + r : ""), ne = typeof x == "number" ? x : { top: 0, right: 0, bottom: 0, left: 0, ...x }, j = Array.isArray(c) ? c : [c], ae = j.length > 0, b = {
-      padding: ne,
-      boundary: j.filter(Ie),
-      // with `strategy: 'fixed'`, this is the only way to get it to respect boundaries
-      altBoundary: ae
-    }, { refs: ie, floatingStyles: H, placement: se, isPositioned: S, middlewareData: u } = xe({
-      // default to `fixed` strategy so users don't have to pick and we also avoid focus scroll issues
-      strategy: "fixed",
-      placement: oe,
-      whileElementsMounted: (...P) => _e(...P, {
-        animationFrame: A === "always"
-      }),
-      elements: {
-        reference: v.anchor
-      },
-      middleware: [
-        Pe({ mainAxis: a + $, alignmentAxis: o }),
-        p && ye({
-          mainAxis: !0,
-          crossAxis: !1,
-          limiter: m === "partial" ? Se() : void 0,
-          ...b
-        }),
-        p && Ae({ ...b }),
-        ve({
-          ...b,
-          apply: ({ elements: P, rects: k, availableWidth: he, availableHeight: ge }) => {
-            const { width: ue, height: we } = k.reference, R = P.floating.style;
-            R.setProperty("--radix-popper-available-width", `${he}px`), R.setProperty("--radix-popper-available-height", `${ge}px`), R.setProperty("--radix-popper-anchor-width", `${ue}px`), R.setProperty("--radix-popper-anchor-height", `${we}px`);
-          }
-        }),
-        E && Ce({ element: E, padding: w }),
-        Ye({ arrowWidth: re, arrowHeight: $ }),
-        y && be({ strategy: "referenceHidden", ...b })
-      ]
-    }), [W, pe] = V(se), O = Ee(l);
-    B(() => {
-      S && (O == null || O());
-    }, [S, O]);
-    const ce = (I = u.arrow) == null ? void 0 : I.x, de = (Y = u.arrow) == null ? void 0 : Y.y, le = ((M = u.arrow) == null ? void 0 : M.centerOffset) !== 0, [fe, me] = s.useState();
-    return B(() => {
-      h && me(window.getComputedStyle(h).zIndex);
-    }, [h]), /* @__PURE__ */ f.jsx(
-      "div",
-      {
-        ref: ie.setFloating,
-        "data-radix-popper-content-wrapper": "",
-        style: {
-          ...H,
-          transform: S ? H.transform : "translate(0, -200%)",
-          // keep off the page when measuring
-          minWidth: "max-content",
-          zIndex: fe,
-          "--radix-popper-transform-origin": [
-            (X = u.transformOrigin) == null ? void 0 : X.x,
-            (D = u.transformOrigin) == null ? void 0 : D.y
-          ].join(" "),
-          // hide the content if using the hide middleware and should be hidden
-          // set visibility to hidden and disable pointer events so the UI behaves
-          // as if the PopperContent isn't there at all
-          ...((F = u.hide) == null ? void 0 : F.referenceHidden) && {
-            visibility: "hidden",
-            pointerEvents: "none"
-          }
-        },
-        dir: e.dir,
-        children: /* @__PURE__ */ f.jsx(
-          je,
-          {
-            scope: n,
-            placedSide: W,
-            onArrowChange: te,
-            arrowX: ce,
-            arrowY: de,
-            shouldHideArrow: le,
-            children: /* @__PURE__ */ f.jsx(
-              z.div,
-              {
-                "data-side": W,
-                "data-align": pe,
-                ...d,
-                ref: ee,
-                style: {
-                  ...d.style,
-                  // if the PopperContent hasn't been placed yet (not all measurements done)
-                  // we prevent animations so that users's animation don't kick in too early referring wrong sides
-                  animation: S ? void 0 : "none"
-                }
-              }
-            )
-          }
-        )
-      }
-    );
-  }
-);
-J.displayName = _;
-var K = "PopperArrow", We = {
-  top: "bottom",
-  right: "left",
-  bottom: "top",
-  left: "right"
-}, Q = s.forwardRef(function(i, n) {
-  const { __scopePopper: t, ...a } = i, r = He(K, t), o = We[r.placedSide];
-  return (
-    // we have to use an extra wrapper because `ResizeObserver` (used by `useSize`)
-    // doesn't report size as we'd expect on SVG elements.
-    // it reports their bounding box which is effectively the largest path inside the SVG.
-    /* @__PURE__ */ f.jsx(
-      "span",
-      {
-        ref: r.onArrowChange,
-        style: {
-          position: "absolute",
-          left: r.arrowX,
-          top: r.arrowY,
-          [o]: 0,
-          transformOrigin: {
-            top: "",
-            right: "0 0",
-            bottom: "center 0",
-            left: "100% 0"
-          }[r.placedSide],
-          transform: {
-            top: "translateY(100%)",
-            right: "translateY(50%) rotate(90deg) translateX(-50%)",
-            bottom: "rotate(180deg)",
-            left: "translateY(50%) rotate(-90deg) translateX(50%)"
-          }[r.placedSide],
-          visibility: r.shouldHideArrow ? "hidden" : void 0
-        },
-        children: /* @__PURE__ */ f.jsx(
-          Oe,
-          {
-            ...a,
-            ref: n,
-            style: {
-              ...a.style,
-              // ensures the element can be measured correctly (mostly for if SVG)
-              display: "block"
-            }
-          }
-        )
-      }
-    )
-  );
-});
-Q.displayName = K;
-function Ie(e) {
-  return e !== null;
-}
-var Ye = (e) => ({
-  name: "transformOrigin",
-  options: e,
-  fn(i) {
-    var v, h, C;
-    const { placement: n, rects: t, middlewareData: a } = i, o = ((v = a.arrow) == null ? void 0 : v.centerOffset) !== 0, w = o ? 0 : e.arrowWidth, p = o ? 0 : e.arrowHeight, [c, x] = V(n), m = { start: "0%", center: "50%", end: "100%" }[x], y = (((h = a.arrow) == null ? void 0 : h.x) ?? 0) + w / 2, A = (((C = a.arrow) == null ? void 0 : C.y) ?? 0) + p / 2;
-    let l = "", d = "";
-    return c === "bottom" ? (l = o ? m : `${y}px`, d = `${-p}px`) : c === "top" ? (l = o ? m : `${y}px`, d = `${t.floating.height + p}px`) : c === "right" ? (l = `${-p}px`, d = o ? m : `${A}px`) : c === "left" && (l = `${t.floating.width + p}px`, d = o ? m : `${A}px`), { data: { x: l, y: d } };
-  }
-});
-function V(e) {
-  const [i, n = "center"] = e.split("-");
-  return [i, n];
+import { isDate as n } from "./index.es111.js";
+import { isSameDay as l } from "./index.es264.js";
+function S(t, i) {
+  return {
+    selectSingleDate: (e) => {
+      i(e);
+    },
+    isSingleSelected: (e) => n(t) && l(e, t)
+  };
 }
-var qe = U, Ge = G, Je = J, Ke = Q;
 export {
-  Ge as Anchor,
-  Ke as Arrow,
-  Je as Content,
-  U as Popper,
-  G as PopperAnchor,
-  Q as PopperArrow,
-  J as PopperContent,
-  qe as Root,
-  Ue as createPopperScope
+  S as default
 };

package/dist/index.es198.js

@@ -1,6 +1,207 @@
-import * as t from "react";
-var e = globalThis != null && globalThis.document ? t.useLayoutEffect : () => {
+import C from "./index.es382.js";
+import x from "./index.es383.js";
+import N from "./index.es384.js";
+import v from "./index.es385.js";
+import A from "./index.es386.js";
+import _ from "./index.es387.js";
+import c from "react";
+import E from "./index.es388.js";
+import { classNamesShape as $ } from "./index.es389.js";
+import { forceReflow as S } from "./index.es390.js";
+var T = function(i, p) {
+  return i && p && p.split(" ").forEach(function(s) {
+    return A(i, s);
+  });
+}, d = function(i, p) {
+  return i && p && p.split(" ").forEach(function(s) {
+    return _(i, s);
+  });
+}, g = /* @__PURE__ */ function(u) {
+  N(i, u);
+  function i() {
+    for (var s, t = arguments.length, a = new Array(t), o = 0; o < t; o++)
+      a[o] = arguments[o];
+    return s = u.call.apply(u, [this].concat(a)) || this, s.appliedClasses = {
+      appear: {},
+      enter: {},
+      exit: {}
+    }, s.onEnter = function(e, r) {
+      var n = s.resolveArguments(e, r), l = n[0], m = n[1];
+      s.removeClasses(l, "exit"), s.addClass(l, m ? "appear" : "enter", "base"), s.props.onEnter && s.props.onEnter(e, r);
+    }, s.onEntering = function(e, r) {
+      var n = s.resolveArguments(e, r), l = n[0], m = n[1], f = m ? "appear" : "enter";
+      s.addClass(l, f, "active"), s.props.onEntering && s.props.onEntering(e, r);
+    }, s.onEntered = function(e, r) {
+      var n = s.resolveArguments(e, r), l = n[0], m = n[1], f = m ? "appear" : "enter";
+      s.removeClasses(l, f), s.addClass(l, f, "done"), s.props.onEntered && s.props.onEntered(e, r);
+    }, s.onExit = function(e) {
+      var r = s.resolveArguments(e), n = r[0];
+      s.removeClasses(n, "appear"), s.removeClasses(n, "enter"), s.addClass(n, "exit", "base"), s.props.onExit && s.props.onExit(e);
+    }, s.onExiting = function(e) {
+      var r = s.resolveArguments(e), n = r[0];
+      s.addClass(n, "exit", "active"), s.props.onExiting && s.props.onExiting(e);
+    }, s.onExited = function(e) {
+      var r = s.resolveArguments(e), n = r[0];
+      s.removeClasses(n, "exit"), s.addClass(n, "exit", "done"), s.props.onExited && s.props.onExited(e);
+    }, s.resolveArguments = function(e, r) {
+      return s.props.nodeRef ? [s.props.nodeRef.current, e] : [e, r];
+    }, s.getClassNames = function(e) {
+      var r = s.props.classNames, n = typeof r == "string", l = n && r ? r + "-" : "", m = n ? "" + l + e : r[e], f = n ? m + "-active" : r[e + "Active"], h = n ? m + "-done" : r[e + "Done"];
+      return {
+        baseClassName: m,
+        activeClassName: f,
+        doneClassName: h
+      };
+    }, s;
+  }
+  var p = i.prototype;
+  return p.addClass = function(t, a, o) {
+    var e = this.getClassNames(a)[o + "ClassName"], r = this.getClassNames("enter"), n = r.doneClassName;
+    a === "appear" && o === "done" && n && (e += " " + n), o === "active" && t && S(t), e && (this.appliedClasses[a][o] = e, T(t, e));
+  }, p.removeClasses = function(t, a) {
+    var o = this.appliedClasses[a], e = o.base, r = o.active, n = o.done;
+    this.appliedClasses[a] = {}, e && d(t, e), r && d(t, r), n && d(t, n);
+  }, p.render = function() {
+    var t = this.props;
+    t.classNames;
+    var a = x(t, ["classNames"]);
+    return /* @__PURE__ */ c.createElement(E, C({}, a, {
+      onEnter: this.onEnter,
+      onEntered: this.onEntered,
+      onEntering: this.onEntering,
+      onExit: this.onExit,
+      onExiting: this.onExiting,
+      onExited: this.onExited
+    }));
+  }, i;
+}(c.Component);
+g.defaultProps = {
+  classNames: ""
 };
+g.propTypes = process.env.NODE_ENV !== "production" ? C({}, E.propTypes, {
+  /**
+   * The animation classNames applied to the component as it appears, enters,
+   * exits or has finished the transition. A single name can be provided, which
+   * will be suffixed for each stage, e.g. `classNames="fade"` applies:
+   *
+   * - `fade-appear`, `fade-appear-active`, `fade-appear-done`
+   * - `fade-enter`, `fade-enter-active`, `fade-enter-done`
+   * - `fade-exit`, `fade-exit-active`, `fade-exit-done`
+   *
+   * A few details to note about how these classes are applied:
+   *
+   * 1. They are _joined_ with the ones that are already defined on the child
+   *    component, so if you want to add some base styles, you can use
+   *    `className` without worrying that it will be overridden.
+   *
+   * 2. If the transition component mounts with `in={false}`, no classes are
+   *    applied yet. You might be expecting `*-exit-done`, but if you think
+   *    about it, a component cannot finish exiting if it hasn't entered yet.
+   *
+   * 2. `fade-appear-done` and `fade-enter-done` will _both_ be applied. This
+   *    allows you to define different behavior for when appearing is done and
+   *    when regular entering is done, using selectors like
+   *    `.fade-enter-done:not(.fade-appear-done)`. For example, you could apply
+   *    an epic entrance animation when element first appears in the DOM using
+   *    [Animate.css](https://daneden.github.io/animate.css/). Otherwise you can
+   *    simply use `fade-enter-done` for defining both cases.
+   *
+   * Each individual classNames can also be specified independently like:
+   *
+   * ```js
+   * classNames={{
+   *  appear: 'my-appear',
+   *  appearActive: 'my-active-appear',
+   *  appearDone: 'my-done-appear',
+   *  enter: 'my-enter',
+   *  enterActive: 'my-active-enter',
+   *  enterDone: 'my-done-enter',
+   *  exit: 'my-exit',
+   *  exitActive: 'my-active-exit',
+   *  exitDone: 'my-done-exit',
+   * }}
+   * ```
+   *
+   * If you want to set these classes using CSS Modules:
+   *
+   * ```js
+   * import styles from './styles.css';
+   * ```
+   *
+   * you might want to use camelCase in your CSS file, that way could simply
+   * spread them instead of listing them one by one:
+   *
+   * ```js
+   * classNames={{ ...styles }}
+   * ```
+   *
+   * @type {string | {
+   *  appear?: string,
+   *  appearActive?: string,
+   *  appearDone?: string,
+   *  enter?: string,
+   *  enterActive?: string,
+   *  enterDone?: string,
+   *  exit?: string,
+   *  exitActive?: string,
+   *  exitDone?: string,
+   * }}
+   */
+  classNames: $,
+  /**
+   * A `<Transition>` callback fired immediately after the 'enter' or 'appear' class is
+   * applied.
+   *
+   * **Note**: when `nodeRef` prop is passed, `node` is not passed.
+   *
+   * @type Function(node: HtmlElement, isAppearing: bool)
+   */
+  onEnter: v.func,
+  /**
+   * A `<Transition>` callback fired immediately after the 'enter-active' or
+   * 'appear-active' class is applied.
+   *
+   * **Note**: when `nodeRef` prop is passed, `node` is not passed.
+   *
+   * @type Function(node: HtmlElement, isAppearing: bool)
+   */
+  onEntering: v.func,
+  /**
+   * A `<Transition>` callback fired immediately after the 'enter' or
+   * 'appear' classes are **removed** and the `done` class is added to the DOM node.
+   *
+   * **Note**: when `nodeRef` prop is passed, `node` is not passed.
+   *
+   * @type Function(node: HtmlElement, isAppearing: bool)
+   */
+  onEntered: v.func,
+  /**
+   * A `<Transition>` callback fired immediately after the 'exit' class is
+   * applied.
+   *
+   * **Note**: when `nodeRef` prop is passed, `node` is not passed
+   *
+   * @type Function(node: HtmlElement)
+   */
+  onExit: v.func,
+  /**
+   * A `<Transition>` callback fired immediately after the 'exit-active' is applied.
+   *
+   * **Note**: when `nodeRef` prop is passed, `node` is not passed
+   *
+   * @type Function(node: HtmlElement)
+   */
+  onExiting: v.func,
+  /**
+   * A `<Transition>` callback fired immediately after the 'exit' classes
+   * are **removed** and the `exit-done` class is added to the DOM node.
+   *
+   * **Note**: when `nodeRef` prop is passed, `node` is not passed
+   *
+   * @type Function(node: HtmlElement)
+   */
+  onExited: v.func
+}) : {};
 export {
-  e as useLayoutEffect
+  g as default
 };

package/dist/index.es199.js

@@ -1,8 +1,6 @@
-import * as u from "react";
-function t(r) {
-  const e = u.useRef({ value: r, previous: r });
-  return u.useMemo(() => (e.current.value !== r && (e.current.previous = e.current.value, e.current.value = r), e.current.previous), [r]);
+function m(t, [a, n]) {
+  return Math.min(n, Math.max(a, t));
 }
 export {
-  t as usePrevious
+  m as clamp
 };

package/dist/index.es2.js

@@ -1,4 +1,4 @@
-import { l as i } from "./index.es105.js";
+import { l as i } from "./index.es108.js";
 import { useState as u } from "react";
 function y(c) {
   const [p = [], n] = u(c);

package/dist/index.es200.js

@@ -1,30 +1,48 @@
-import * as e from "react";
-import { Primitive as a } from "./index.es183.js";
-import { j as o } from "./index.es104.js";
-var t = "VisuallyHidden", d = e.forwardRef(
-  (r, i) => /* @__PURE__ */ o.jsx(
-    a.span,
-    {
-      ...r,
-      ref: i,
-      style: {
-        // See: https://github.com/twbs/bootstrap/blob/main/scss/mixins/_visually-hidden.scss
-        position: "absolute",
-        border: 0,
-        width: 1,
-        height: 1,
-        padding: 0,
-        margin: -1,
-        overflow: "hidden",
-        clip: "rect(0, 0, 0, 0)",
-        whiteSpace: "nowrap",
-        wordWrap: "normal",
-        ...r.style
-      }
+import r from "react";
+import { createContextScope as y } from "./index.es186.js";
+import { useComposedRefs as S } from "./index.es184.js";
+import { createSlot as M } from "./index.es305.js";
+import { j as d } from "./index.es105.js";
+function D(s) {
+  const m = s + "CollectionProvider", [A, E] = y(m), [N, f] = A(
+    m,
+    { collectionRef: { current: null }, itemMap: /* @__PURE__ */ new Map() }
+  ), p = (c) => {
+    const { scope: e, children: l } = c, o = r.useRef(null), t = r.useRef(/* @__PURE__ */ new Map()).current;
+    return /* @__PURE__ */ d.jsx(N, { scope: e, itemMap: t, collectionRef: o, children: l });
+  };
+  p.displayName = m;
+  const a = s + "CollectionSlot", _ = M(a), C = r.forwardRef(
+    (c, e) => {
+      const { scope: l, children: o } = c, t = f(a, l), n = S(e, t.collectionRef);
+      return /* @__PURE__ */ d.jsx(_, { ref: n, children: o });
     }
-  )
-);
-d.displayName = t;
+  );
+  C.displayName = a;
+  const u = s + "CollectionItemSlot", R = "data-radix-collection-item", T = M(u), x = r.forwardRef(
+    (c, e) => {
+      const { scope: l, children: o, ...t } = c, n = r.useRef(null), I = S(e, n), i = f(u, l);
+      return r.useEffect(() => (i.itemMap.set(n, { ref: n, ...t }), () => void i.itemMap.delete(n))), /* @__PURE__ */ d.jsx(T, { [R]: "", ref: I, children: o });
+    }
+  );
+  x.displayName = u;
+  function O(c) {
+    const e = f(s + "CollectionConsumer", c);
+    return r.useCallback(() => {
+      const o = e.collectionRef.current;
+      if (!o) return [];
+      const t = Array.from(o.querySelectorAll(`[${R}]`));
+      return Array.from(e.itemMap.values()).sort(
+        (i, v) => t.indexOf(i.ref.current) - t.indexOf(v.ref.current)
+      );
+    }, [e.collectionRef, e.itemMap]);
+  }
+  return [
+    { Provider: p, Slot: C, ItemSlot: x },
+    O,
+    E
+  ];
+}
 export {
-  d as VisuallyHidden
+  D as createCollection
 };