@boxcustodia/library 1.7.4 → 1.7.6

package/dist/index.es160.js

@@ -1,15 +1,94 @@
-import c from "./index.es204.js";
-/**
- * @license lucide-react v0.487.0 - ISC
- *
- * This source code is licensed under the ISC license.
- * See the LICENSE file in the root directory of this source tree.
- */
-const e = [
-  ["circle", { cx: "12", cy: "12", r: "10", key: "1mglay" }],
-  ["path", { d: "m9 12 2 2 4-4", key: "dzmm74" }]
-], r = c("circle-check", e);
+import { mergeProps as y } from "./index.es297.js";
+import { mergeRefs as $ } from "./index.es302.js";
+import { useObjectRef as m } from "./index.es303.js";
+import x, { useMemo as i, useContext as p } from "react";
+const b = Symbol("default");
+function R({ values: t, children: l }) {
+  for (let [e, s] of t)
+    l = /* @__PURE__ */ x.createElement(e.Provider, {
+      value: s
+    }, l);
+  return l;
+}
+function g(t) {
+  let { className: l, style: e, children: s, defaultClassName: n, defaultChildren: f, defaultStyle: r, values: u } = t;
+  return i(() => {
+    let a, d, o;
+    return typeof l == "function" ? a = l({
+      ...u,
+      defaultClassName: n
+    }) : a = l, typeof e == "function" ? d = e({
+      ...u,
+      defaultStyle: r || {}
+    }) : d = e, typeof s == "function" ? o = s({
+      ...u,
+      defaultChildren: f
+    }) : s == null ? o = f : o = s, {
+      className: a ?? n,
+      style: d || r ? {
+        ...r,
+        ...d
+      } : void 0,
+      children: o ?? f,
+      "data-rac": ""
+    };
+  }, [
+    l,
+    e,
+    s,
+    n,
+    f,
+    r,
+    u
+  ]);
+}
+function P(t, l) {
+  return (e) => l(typeof t == "function" ? t(e) : t, e);
+}
+function C(t, l) {
+  let e = p(t);
+  if (l === null)
+    return null;
+  if (e && typeof e == "object" && "slots" in e && e.slots) {
+    let s = l || b;
+    if (!e.slots[s]) {
+      let n = new Intl.ListFormat().format(Object.keys(e.slots).map((r) => `"${r}"`)), f = l ? `Invalid slot "${l}".` : "A slot prop is required.";
+      throw new Error(`${f} Valid slot names are ${n}.`);
+    }
+    return e.slots[s];
+  }
+  return e;
+}
+function j(t, l, e) {
+  let s = C(e, t.slot) || {}, { ref: n, ...f } = s, r = m(i(() => $(l, n), [
+    l,
+    n
+  ])), u = y(f, t);
+  return "style" in f && f.style && "style" in t && t.style && (typeof f.style == "function" || typeof t.style == "function" ? u.style = (a) => {
+    let d = typeof f.style == "function" ? f.style(a) : f.style, o = {
+      ...a.defaultStyle,
+      ...d
+    }, c = typeof t.style == "function" ? t.style({
+      ...a,
+      defaultStyle: o
+    }) : t.style;
+    return {
+      ...o,
+      ...c
+    };
+  } : u.style = {
+    ...f.style,
+    ...t.style
+  }), [
+    u,
+    r
+  ];
+}
 export {
-  e as __iconNode,
-  r as default
+  b as DEFAULT_SLOT,
+  R as Provider,
+  P as composeRenderProps,
+  j as useContextProps,
+  g as useRenderProps,
+  C as useSlottedContext
 };

package/dist/index.es161.js

@@ -1,16 +1,354 @@
-import e from "./index.es204.js";
-/**
- * @license lucide-react v0.487.0 - ISC
- *
- * This source code is licensed under the ISC license.
- * See the LICENSE file in the root directory of this source tree.
- */
-const c = [
-  ["circle", { cx: "12", cy: "12", r: "10", key: "1mglay" }],
-  ["line", { x1: "12", x2: "12", y1: "8", y2: "12", key: "1pkeuh" }],
-  ["line", { x1: "12", x2: "12.01", y1: "16", y2: "16", key: "4dfq90" }]
-], l = e("circle-alert", c);
+import { ButtonContext as O } from "./index.es159.js";
+import { CheckboxContext as A } from "./index.es292.js";
+import { CollectionRendererContext as N, DefaultCollectionRenderer as W, usePersistedKeys as G } from "./index.es304.js";
+import { useRenderProps as E, Provider as z, DEFAULT_SLOT as U, useContextProps as j } from "./index.es160.js";
+import { createBranchComponent as q, createLeafComponent as D, CollectionBuilder as J, Collection as Q } from "./index.es88.js";
+import { useCachedChildren as X } from "./index.es305.js";
+import { mergeProps as S } from "./index.es297.js";
+import { filterDOMProps as V } from "./index.es298.js";
+import { useObjectRef as Y } from "./index.es303.js";
+import { useControlledState as Z } from "./index.es306.js";
+import n, { forwardRef as ee, useContext as w, createContext as F, useEffect as I, useRef as te, useMemo as ae } from "react";
+import { useTreeItem as H } from "./index.es307.js";
+import { useTree as le } from "./index.es308.js";
+import { useHover as re } from "./index.es301.js";
+import { useFocusRing as T } from "./index.es300.js";
+import { FocusScope as oe } from "./index.es309.js";
+import { useGridListSelectionCheckbox as ne } from "./index.es310.js";
+import { useTreeState as se } from "./index.es311.js";
+class ie {
+  // TODO: should this collection's getters reflect the flattened structure or the original structure
+  // If we respresent the flattened structure, it is easier for the keyboard nav but harder to find all the nodes
+  *[Symbol.iterator]() {
+    yield* this.flattenedRows;
+  }
+  get size() {
+    return this.flattenedRows.length;
+  }
+  getKeys() {
+    return this.keyMap.keys();
+  }
+  getItem(e) {
+    return this.keyMap.get(e) || null;
+  }
+  at(e) {
+    return this.flattenedRows[e];
+  }
+  getFirstKey() {
+    var e;
+    return (e = this.flattenedRows[0]) === null || e === void 0 ? void 0 : e.key;
+  }
+  getLastKey() {
+    var e;
+    return (e = this.flattenedRows[this.size - 1]) === null || e === void 0 ? void 0 : e.key;
+  }
+  getKeyAfter(e) {
+    var t;
+    let o = this.flattenedRows.findIndex((l) => l.key === e);
+    return (t = this.flattenedRows[o + 1]) === null || t === void 0 ? void 0 : t.key;
+  }
+  getKeyBefore(e) {
+    var t;
+    let o = this.flattenedRows.findIndex((l) => l.key === e);
+    return (t = this.flattenedRows[o - 1]) === null || t === void 0 ? void 0 : t.key;
+  }
+  // Note that this will return Content nodes in addition to nested TreeItems
+  getChildren(e) {
+    let t = this.keyMap;
+    return {
+      *[Symbol.iterator]() {
+        let o = t.get(e), l = (o == null ? void 0 : o.firstChildKey) != null ? t.get(o.firstChildKey) : null;
+        for (; l; )
+          yield l, l = l.nextKey != null ? t.get(l.nextKey) : void 0;
+      }
+    };
+  }
+  getTextValue(e) {
+    let t = this.getItem(e);
+    return t ? t.textValue : "";
+  }
+  constructor(e) {
+    this.keyMap = /* @__PURE__ */ new Map();
+    let { collection: t, expandedKeys: o } = e, { flattenedRows: l, keyMap: s } = fe(t, {
+      expandedKeys: o
+    });
+    this.flattenedRows = l, this.keyMap = s;
+  }
+}
+const de = /* @__PURE__ */ F(null), _ = /* @__PURE__ */ F(null), Te = /* @__PURE__ */ ee(function(e, t) {
+  return [e, t] = j(e, t, de), /* @__PURE__ */ n.createElement(J, {
+    content: /* @__PURE__ */ n.createElement(Q, e)
+  }, (o) => /* @__PURE__ */ n.createElement(ce, {
+    props: e,
+    collection: o,
+    treeRef: t
+  }));
+});
+function ce({ props: r, collection: e, treeRef: t }) {
+  let { selectionMode: o = "none", expandedKeys: l, defaultExpandedKeys: s, onExpandedChange: a, disabledBehavior: i = "all" } = r, { CollectionRoot: f, isVirtualized: d, layoutDelegate: $ } = w(N), [u, p] = Z(l ? B(l) : void 0, s ? B(s) : /* @__PURE__ */ new Set(), a), P = ae(() => new ie({
+    collection: e,
+    expandedKeys: u
+  }), [
+    e,
+    u
+  ]), c = se({
+    ...r,
+    selectionMode: o,
+    expandedKeys: u,
+    onExpandedChange: p,
+    collection: P,
+    children: void 0,
+    disabledBehavior: i
+  }), { gridProps: m } = le({
+    ...r,
+    isVirtualized: d,
+    layoutDelegate: $
+  }, c, t), { focusProps: R, isFocused: b, isFocusVisible: v } = T(), h = {
+    isEmpty: c.collection.size === 0,
+    isFocused: b,
+    isFocusVisible: v,
+    state: c
+  }, x = E({
+    className: r.className,
+    style: r.style,
+    defaultClassName: "react-aria-Tree",
+    values: h
+  }), y = null;
+  if (c.collection.size === 0 && r.renderEmptyState) {
+    let { isEmpty: k, ...M } = h, C = r.renderEmptyState({
+      ...M
+    }), K = {
+      "aria-level": 1,
+      "aria-posinset": 1,
+      "aria-setsize": 1
+    };
+    y = /* @__PURE__ */ n.createElement("div", {
+      role: "row",
+      style: {
+        display: "contents"
+      },
+      ...K
+    }, /* @__PURE__ */ n.createElement("div", {
+      role: "gridcell",
+      style: {
+        display: "contents"
+      }
+    }, C));
+  }
+  return /* @__PURE__ */ n.createElement(oe, null, /* @__PURE__ */ n.createElement("div", {
+    ...V(r),
+    ...x,
+    ...S(m, R),
+    ref: t,
+    slot: r.slot || void 0,
+    onScroll: r.onScroll,
+    "data-empty": c.collection.size === 0 || void 0,
+    "data-focused": b || void 0,
+    "data-focus-visible": v || void 0
+  }, /* @__PURE__ */ n.createElement(z, {
+    values: [
+      [
+        _,
+        c
+      ]
+    ]
+  }, /* @__PURE__ */ n.createElement(f, {
+    collection: c.collection,
+    persistedKeys: G(c.selectionManager.focusedKey),
+    scrollRef: t
+  })), y));
+}
+const Se = /* @__PURE__ */ D("content", function(e) {
+  let t = w(L), o = E({
+    children: e.children,
+    values: t
+  });
+  return /* @__PURE__ */ n.createElement(N.Provider, {
+    value: W
+  }, o.children);
+}), L = /* @__PURE__ */ F(null), Ve = /* @__PURE__ */ q("item", (r, e, t) => {
+  var o;
+  let l = w(_);
+  e = Y(e);
+  let { rowProps: s, gridCellProps: a, expandButtonProps: i, descriptionProps: f, ...d } = H({
+    node: t
+  }, l, e), $ = s["aria-expanded"] === !0, u = r.hasChildItems || ((o = [
+    ...l.collection.getChildren(t.key)
+  ]) === null || o === void 0 ? void 0 : o.length) > 1, p = s["aria-level"] || 1, { hoverProps: P, isHovered: c } = re({
+    isDisabled: !d.allowsSelection && !d.hasAction,
+    onHoverStart: r.onHoverStart,
+    onHoverChange: r.onHoverChange,
+    onHoverEnd: r.onHoverEnd
+  }), { isFocusVisible: m, focusProps: R } = T(), { isFocusVisible: b, focusProps: v } = T({
+    within: !0
+  }), { checkboxProps: h } = ne({
+    key: t.key
+  }, l), x = l.selectionManager.selectionMode, y = l.selectionManager.selectionBehavior, k = n.useMemo(() => ({
+    ...d,
+    isHovered: c,
+    isFocusVisible: m,
+    isExpanded: $,
+    hasChildItems: u,
+    level: p,
+    selectionMode: x,
+    selectionBehavior: y,
+    isFocusVisibleWithin: b,
+    state: l,
+    id: t.key
+  }), [
+    d,
+    c,
+    m,
+    x,
+    y,
+    $,
+    u,
+    p,
+    b,
+    l,
+    t.key
+  ]), M = E({
+    ...r,
+    id: void 0,
+    children: t.rendered,
+    defaultClassName: "react-aria-TreeItem",
+    defaultStyle: {
+      // @ts-ignore
+      "--tree-item-level": p
+    },
+    values: k
+  });
+  I(() => {
+    !t.textValue && process.env.NODE_ENV !== "production" && console.warn("A `textValue` prop is required for <TreeItem> elements in order to support accessibility features such as type to select.");
+  }, [
+    t.textValue
+  ]);
+  let C = te(null);
+  I(() => {
+    u && !C.current && process.env.NODE_ENV !== "production" && console.warn("Expandable tree items must contain a expand button so screen reader users can expand/collapse the item.");
+  }, []);
+  let K = X({
+    items: l.collection.getChildren(t.key),
+    children: (g) => {
+      switch (g.type) {
+        case "content":
+          return g.render(g);
+        // Skip item since we don't render the nested rows as children of the parent row, the flattened collection
+        // will render them each as siblings instead
+        case "loader":
+        case "item":
+          return /* @__PURE__ */ n.createElement(n.Fragment, null);
+        default:
+          throw new Error("Unsupported element type in TreeRow: " + g.type);
+      }
+    }
+  });
+  return /* @__PURE__ */ n.createElement(n.Fragment, null, /* @__PURE__ */ n.createElement("div", {
+    ...S(V(r), s, R, P, v),
+    ...M,
+    ref: e,
+    // TODO: missing selectionBehavior, hasAction and allowsSelection data attribute equivalents (available in renderProps). Do we want those?
+    "data-expanded": u && $ || void 0,
+    "data-has-child-items": u || void 0,
+    "data-level": p,
+    "data-selected": d.isSelected || void 0,
+    "data-disabled": d.isDisabled || void 0,
+    "data-hovered": c || void 0,
+    "data-focused": d.isFocused || void 0,
+    "data-focus-visible": m || void 0,
+    "data-pressed": d.isPressed || void 0,
+    "data-selection-mode": l.selectionManager.selectionMode === "none" ? void 0 : l.selectionManager.selectionMode
+  }, /* @__PURE__ */ n.createElement("div", {
+    ...a,
+    style: {
+      display: "contents"
+    }
+  }, /* @__PURE__ */ n.createElement(z, {
+    values: [
+      [
+        A,
+        {
+          slots: {
+            selection: h
+          }
+        }
+      ],
+      // TODO: support description in the tree row
+      // TODO: don't think I need to pass isExpanded to the button here since it can be sourced from the renderProps? Might be worthwhile passing it down?
+      [
+        O,
+        {
+          slots: {
+            [U]: {},
+            chevron: {
+              ...i,
+              ref: C
+            }
+          }
+        }
+      ],
+      [
+        L,
+        {
+          ...k
+        }
+      ]
+    ]
+  }, K))));
+});
+D("loader", function(e, t, o) {
+  let l = w(_), { rowProps: s } = H({
+    node: o
+  }, l, t), a = s["aria-level"] || 1, i = {
+    "aria-level": s["aria-level"],
+    "aria-posinset": s["aria-posinset"],
+    "aria-setsize": s["aria-setsize"]
+  }, f = E({
+    ...e,
+    id: void 0,
+    children: o.rendered,
+    defaultClassName: "react-aria-TreeLoader",
+    values: {
+      level: a
+    }
+  });
+  return /* @__PURE__ */ n.createElement(n.Fragment, null, /* @__PURE__ */ n.createElement("div", {
+    role: "row",
+    ref: t,
+    ...S(V(e), i),
+    ...f,
+    "data-level": a
+  }, /* @__PURE__ */ n.createElement("div", {
+    role: "gridcell",
+    "aria-colindex": 1
+  }, f.children)));
+});
+function B(r) {
+  return r ? r === "all" ? "all" : new Set(r) : /* @__PURE__ */ new Set();
+}
+function fe(r, e) {
+  let { expandedKeys: t = /* @__PURE__ */ new Set() } = e, o = /* @__PURE__ */ new Map(), l = [], s = (a) => {
+    if (a.type === "item" || a.type === "loader") {
+      let i = a == null ? void 0 : a.parentKey, f = {
+        ...a
+      };
+      i != null ? ([
+        ...r.getChildren(i)
+      ][0].type !== "item" && (f.index = (a == null ? void 0 : a.index) != null ? (a == null ? void 0 : a.index) - 1 : 0), a.type === "loader" && (f.level = a.level + 1), o.set(f.key, f)) : o.set(a.key, a), (a.level === 0 || i != null && t.has(i) && l.find((d) => d.key === i)) && l.push(o.get(a.key) || a);
+    } else a.type !== null && o.set(a.key, a);
+    for (let i of r.getChildren(a.key)) s(i);
+  };
+  for (let a of r) s(a);
+  return {
+    flattenedRows: l,
+    keyMap: o
+  };
+}
 export {
-  c as __iconNode,
-  l as default
+  Te as Tree,
+  de as TreeContext,
+  Ve as TreeItem,
+  Se as TreeItemContent,
+  L as TreeItemContentContext,
+  _ as TreeStateContext
 };