@boxcustodia/library 0.0.1 → 0.0.3

package/dist/index.es134.js

@@ -0,0 +1,199 @@
+import i from "./index.es175.js";
+import { forwardRef as f, createElement as s, useRef as $, useEffect as F, Fragment as M, useCallback as y, Children as N } from "react";
+import { composeEventHandlers as g } from "./index.es176.js";
+import { useComposedRefs as C } from "./index.es177.js";
+import { createContextScope as T } from "./index.es178.js";
+import { useId as _ } from "./index.es179.js";
+import { useControllableState as S } from "./index.es180.js";
+import { DismissableLayer as L } from "./index.es181.js";
+import { FocusScope as k } from "./index.es182.js";
+import { Portal as w } from "./index.es183.js";
+import { Presence as x } from "./index.es184.js";
+import { Primitive as D } from "./index.es135.js";
+import { useFocusGuards as j } from "./index.es185.js";
+import G from "./index.es186.js";
+import { hideOthers as H } from "./index.es154.js";
+import { Slot as K } from "./index.es187.js";
+const O = "Dialog", [P, De] = T(O), [U, d] = P(O), V = (e) => {
+  const { __scopeDialog: r, children: t, open: c, defaultOpen: n, onOpenChange: o, modal: a = !0 } = e, l = $(null), u = $(null), [b = !1, m] = S({
+    prop: c,
+    defaultProp: n,
+    onChange: o
+  });
+  return /* @__PURE__ */ s(U, {
+    scope: r,
+    triggerRef: l,
+    contentRef: u,
+    contentId: _(),
+    titleId: _(),
+    descriptionId: _(),
+    open: b,
+    onOpenChange: m,
+    onOpenToggle: y(
+      () => m(
+        (I) => !I
+      ),
+      [
+        m
+      ]
+    ),
+    modal: a
+  }, t);
+}, R = "DialogPortal", [Y, h] = P(R, {
+  forceMount: void 0
+}), Z = (e) => {
+  const { __scopeDialog: r, forceMount: t, children: c, container: n } = e, o = d(R, r);
+  return /* @__PURE__ */ s(Y, {
+    scope: r,
+    forceMount: t
+  }, N.map(
+    c,
+    (a) => /* @__PURE__ */ s(x, {
+      present: t || o.open
+    }, /* @__PURE__ */ s(w, {
+      asChild: !0,
+      container: n
+    }, a))
+  ));
+}, v = "DialogOverlay", q = /* @__PURE__ */ f((e, r) => {
+  const t = h(v, e.__scopeDialog), { forceMount: c = t.forceMount, ...n } = e, o = d(v, e.__scopeDialog);
+  return o.modal ? /* @__PURE__ */ s(x, {
+    present: c || o.open
+  }, /* @__PURE__ */ s(z, i({}, n, {
+    ref: r
+  }))) : null;
+}), z = /* @__PURE__ */ f((e, r) => {
+  const { __scopeDialog: t, ...c } = e, n = d(v, t);
+  return (
+    // Make sure `Content` is scrollable even when it doesn't live inside `RemoveScroll`
+    // ie. when `Overlay` and `Content` are siblings
+    /* @__PURE__ */ s(G, {
+      as: K,
+      allowPinchZoom: !0,
+      shards: [
+        n.contentRef
+      ]
+    }, /* @__PURE__ */ s(D.div, i({
+      "data-state": A(n.open)
+    }, c, {
+      ref: r,
+      style: {
+        pointerEvents: "auto",
+        ...c.style
+      }
+    })))
+  );
+}), p = "DialogContent", B = /* @__PURE__ */ f((e, r) => {
+  const t = h(p, e.__scopeDialog), { forceMount: c = t.forceMount, ...n } = e, o = d(p, e.__scopeDialog);
+  return /* @__PURE__ */ s(x, {
+    present: c || o.open
+  }, o.modal ? /* @__PURE__ */ s(J, i({}, n, {
+    ref: r
+  })) : /* @__PURE__ */ s(Q, i({}, n, {
+    ref: r
+  })));
+}), J = /* @__PURE__ */ f((e, r) => {
+  const t = d(p, e.__scopeDialog), c = $(null), n = C(r, t.contentRef, c);
+  return F(() => {
+    const o = c.current;
+    if (o) return H(o);
+  }, []), /* @__PURE__ */ s(E, i({}, e, {
+    ref: n,
+    trapFocus: t.open,
+    disableOutsidePointerEvents: !0,
+    onCloseAutoFocus: g(e.onCloseAutoFocus, (o) => {
+      var a;
+      o.preventDefault(), (a = t.triggerRef.current) === null || a === void 0 || a.focus();
+    }),
+    onPointerDownOutside: g(e.onPointerDownOutside, (o) => {
+      const a = o.detail.originalEvent, l = a.button === 0 && a.ctrlKey === !0;
+      (a.button === 2 || l) && o.preventDefault();
+    }),
+    onFocusOutside: g(
+      e.onFocusOutside,
+      (o) => o.preventDefault()
+    )
+  }));
+}), Q = /* @__PURE__ */ f((e, r) => {
+  const t = d(p, e.__scopeDialog), c = $(!1), n = $(!1);
+  return /* @__PURE__ */ s(E, i({}, e, {
+    ref: r,
+    trapFocus: !1,
+    disableOutsidePointerEvents: !1,
+    onCloseAutoFocus: (o) => {
+      var a;
+      if ((a = e.onCloseAutoFocus) === null || a === void 0 || a.call(e, o), !o.defaultPrevented) {
+        var l;
+        c.current || (l = t.triggerRef.current) === null || l === void 0 || l.focus(), o.preventDefault();
+      }
+      c.current = !1, n.current = !1;
+    },
+    onInteractOutside: (o) => {
+      var a, l;
+      (a = e.onInteractOutside) === null || a === void 0 || a.call(e, o), o.defaultPrevented || (c.current = !0, o.detail.originalEvent.type === "pointerdown" && (n.current = !0));
+      const u = o.target;
+      ((l = t.triggerRef.current) === null || l === void 0 ? void 0 : l.contains(u)) && o.preventDefault(), o.detail.originalEvent.type === "focusin" && n.current && o.preventDefault();
+    }
+  }));
+}), E = /* @__PURE__ */ f((e, r) => {
+  const { __scopeDialog: t, trapFocus: c, onOpenAutoFocus: n, onCloseAutoFocus: o, ...a } = e, l = d(p, t), u = $(null), b = C(r, u);
+  return j(), /* @__PURE__ */ s(M, null, /* @__PURE__ */ s(k, {
+    asChild: !0,
+    loop: !0,
+    trapped: c,
+    onMountAutoFocus: n,
+    onUnmountAutoFocus: o
+  }, /* @__PURE__ */ s(L, i({
+    role: "dialog",
+    id: l.contentId,
+    "aria-describedby": l.descriptionId,
+    "aria-labelledby": l.titleId,
+    "data-state": A(l.open)
+  }, a, {
+    ref: b,
+    onDismiss: () => l.onOpenChange(!1)
+  }))), !1);
+}), W = "DialogTitle", me = /* @__PURE__ */ f((e, r) => {
+  const { __scopeDialog: t, ...c } = e, n = d(W, t);
+  return /* @__PURE__ */ s(D.h2, i({
+    id: n.titleId
+  }, c, {
+    ref: r
+  }));
+}), X = "DialogDescription", _e = /* @__PURE__ */ f((e, r) => {
+  const { __scopeDialog: t, ...c } = e, n = d(X, t);
+  return /* @__PURE__ */ s(D.p, i({
+    id: n.descriptionId
+  }, c, {
+    ref: r
+  }));
+}), ee = "DialogClose", ve = /* @__PURE__ */ f((e, r) => {
+  const { __scopeDialog: t, ...c } = e, n = d(ee, t);
+  return /* @__PURE__ */ s(D.button, i({
+    type: "button"
+  }, c, {
+    ref: r,
+    onClick: g(
+      e.onClick,
+      () => n.onOpenChange(!1)
+    )
+  }));
+});
+function A(e) {
+  return e ? "open" : "closed";
+}
+const xe = V, Ce = Z, Oe = q, Pe = B;
+export {
+  Pe as Content,
+  V as Dialog,
+  ve as DialogClose,
+  B as DialogContent,
+  _e as DialogDescription,
+  q as DialogOverlay,
+  Z as DialogPortal,
+  me as DialogTitle,
+  Oe as Overlay,
+  Ce as Portal,
+  xe as Root,
+  De as createDialogScope
+};

package/dist/index.es135.js

@@ -0,0 +1,44 @@
+import s from "./index.es175.js";
+import { forwardRef as m, useEffect as n, createElement as p } from "react";
+import { flushSync as d } from "react-dom";
+import { Slot as $ } from "./index.es187.js";
+const l = [
+  "a",
+  "button",
+  "div",
+  "form",
+  "h2",
+  "h3",
+  "img",
+  "input",
+  "label",
+  "li",
+  "nav",
+  "ol",
+  "p",
+  "span",
+  "svg",
+  "ul"
+], E = l.reduce((e, t) => {
+  const r = /* @__PURE__ */ m((i, o) => {
+    const { asChild: c, ...f } = i, a = c ? $ : t;
+    return n(() => {
+      window[Symbol.for("radix-ui")] = !0;
+    }, []), /* @__PURE__ */ p(a, s({}, f, {
+      ref: o
+    }));
+  });
+  return r.displayName = `Primitive.${t}`, {
+    ...e,
+    [t]: r
+  };
+}, {});
+function b(e, t) {
+  e && d(
+    () => e.dispatchEvent(t)
+  );
+}
+export {
+  E as Primitive,
+  b as dispatchDiscreteCustomEvent
+};

package/dist/index.es136.js

@@ -0,0 +1,15 @@
+function o(r) {
+  var f, n, t = "";
+  if (typeof r == "string" || typeof r == "number") t += r;
+  else if (typeof r == "object") if (Array.isArray(r)) for (f = 0; f < r.length; f++) r[f] && (n = o(r[f])) && (t && (t += " "), t += n);
+  else for (f in r) r[f] && (t && (t += " "), t += f);
+  return t;
+}
+function a() {
+  for (var r, f, n = 0, t = ""; n < arguments.length; ) (r = arguments[n++]) && (f = o(r)) && (t && (t += " "), t += f);
+  return t;
+}
+export {
+  a as clsx,
+  a as default
+};

package/dist/index.es137.js

@@ -0,0 +1,14 @@
+import * as e from "react";
+function c(o, n) {
+  typeof o == "function" ? o(n) : o != null && (o.current = n);
+}
+function u(...o) {
+  return (n) => o.forEach((t) => c(t, n));
+}
+function i(...o) {
+  return e.useCallback(u(...o), o);
+}
+export {
+  u as composeRefs,
+  i as useComposedRefs
+};

package/dist/index.es138.js

@@ -0,0 +1,207 @@
+import C from "./index.es175.js";
+import x from "./index.es324.js";
+import N from "./index.es325.js";
+import v from "./index.es326.js";
+import A from "./index.es327.js";
+import _ from "./index.es328.js";
+import c from "react";
+import E from "./index.es329.js";
+import { classNamesShape as $ } from "./index.es330.js";
+import { forceReflow as S } from "./index.es331.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 {
+  g as default
+};

package/dist/index.es139.js

@@ -0,0 +1,13 @@
+import * as r from "react";
+function o(t) {
+  const e = r.useRef(t);
+  return r.useEffect(() => {
+    e.current = t;
+  }), r.useMemo(() => (...n) => {
+    var u;
+    return (u = e.current) == null ? void 0 : u.call(e, ...n);
+  }, []);
+}
+export {
+  o as useCallbackRef
+};

package/dist/index.es14.js

@@ -0,0 +1,27 @@
+import { l as o } from "./index.es98.js";
+import { useState as i, useCallback as r } from "react";
+function O(e) {
+  const [u, n] = i(e), f = r(() => n(e), [e]), b = r(
+    (s) => {
+      n((t) => {
+        if (o.isFunction(s)) {
+          const c = s(t);
+          return o.isObject(c) ? {
+            ...t,
+            ...c
+          } : t;
+        } else if (o.isObject(s))
+          return {
+            ...t,
+            ...s
+          };
+        return t;
+      });
+    },
+    []
+  );
+  return [u, b, f];
+}
+export {
+  O as default
+};

package/dist/index.es140.js

@@ -0,0 +1,23 @@
+import { l as o } from "./index.es98.js";
+import { isSameDay as t } from "./index.es223.js";
+function m(i, l) {
+  return {
+    selectMultipleDate: (r) => {
+      if (!i) return l([r]);
+      const n = o.findIndex(
+        i,
+        (s) => t(s, r)
+      );
+      if (n === -1) return l([...i, r]);
+      const u = [
+        ...i.slice(0, n),
+        ...i.slice(n + 1)
+      ];
+      l(u);
+    },
+    isMultipleSelected: (r) => o.isArray(i) && i.some((n) => t(n, r))
+  };
+}
+export {
+  m as default
+};

package/dist/index.es141.js

@@ -0,0 +1,39 @@
+import { isDateRange as f } from "./index.es99.js";
+import { isBefore as R } from "./index.es222.js";
+import { eachDayOfInterval as l } from "./index.es198.js";
+import { startOfDay as o } from "./index.es196.js";
+import { isWithinInterval as y } from "./index.es227.js";
+import { isSameDay as e } from "./index.es223.js";
+function w(r, i, u) {
+  const D = (n) => {
+    if (r == null ? void 0 : r.start) {
+      const { start: t, end: s } = r;
+      if (R(n, t) || t && s) {
+        i({ start: n, end: void 0 });
+        return;
+      }
+      if (g(t, n)) return;
+      i({
+        start: t,
+        end: n
+      });
+    } else
+      i({ start: n, end: void 0 });
+  }, g = (n, a) => !u || !n || !a ? !1 : l({ start: o(n), end: a }).some((m) => u(m));
+  return {
+    selectRangeDate: D,
+    isInRange: (n) => {
+      if (!f(r) || !r) return !1;
+      const { start: a, end: t } = r;
+      return a && !t ? e(n, a) : !a || !t ? !1 : y(n, {
+        start: o(a),
+        end: o(t)
+      });
+    },
+    isFirstDayFromRange: (n) => !r || !f(r) || !r.start ? !1 : e(n, r.start),
+    isLastDayFromRange: (n) => !r || !f(r) || !r.end ? !1 : e(n, r.end)
+  };
+}
+export {
+  w as default
+};

package/dist/index.es142.js

@@ -0,0 +1,13 @@
+import { isDate as n } from "./index.es101.js";
+import { isSameDay as l } from "./index.es223.js";
+function S(t, i) {
+  return {
+    selectSingleDate: (e) => {
+      i(e);
+    },
+    isSingleSelected: (e) => n(t) && l(e, t)
+  };
+}
+export {
+  S as default
+};

package/dist/index.es143.js

@@ -0,0 +1,8 @@
+var o = typeof globalThis < "u" ? globalThis : typeof window < "u" ? window : typeof global < "u" ? global : typeof self < "u" ? self : {};
+function l(e) {
+  return e && e.__esModule && Object.prototype.hasOwnProperty.call(e, "default") ? e.default : e;
+}
+export {
+  o as commonjsGlobal,
+  l as getDefaultExportFromCjs
+};

package/dist/index.es144.js

@@ -0,0 +1,4 @@
+var o = { exports: {} };
+export {
+  o as __module
+};

package/dist/index.es145.js

@@ -0,0 +1,9 @@
+function h(f, c, { checkForDefaultPrevented: p = !0 } = {}) {
+  return function(s) {
+    if (f == null || f(s), p === !1 || !s.defaultPrevented)
+      return c == null ? void 0 : c(s);
+  };
+}
+export {
+  h as composeEventHandlers
+};