@new-black/lyra 1.8.0 → 1.9.0

package/dist/lyra129.js

@@ -1,666 +1,184 @@
-import { ButtonContext as ne } from "./lyra104.js";
-import { CheckboxContext as ee } from "./lyra170.js";
-import { CollectionRendererContext as x, DefaultCollectionRenderer as te } from "./lyra383.js";
-import { useContextProps as de, useRenderProps as S, Provider as M, DEFAULT_SLOT as Y } from "./lyra106.js";
-import { DragAndDropContext as k, useRenderDropIndicator as ce, DropIndicatorContext as ue, useDndPersistedKeys as fe } from "./lyra400.js";
-import { createBranchComponent as q, createLeafComponent as J, Collection as Q, CollectionBuilder as pe } from "./lyra384.js";
-import { useCachedChildren as be } from "./lyra398.js";
-import { BaseCollection as he, CollectionNode as Z } from "./lyra409.js";
-import { useTableState as me } from "./lyra410.js";
-import { buildHeaderRows as ge } from "./lyra411.js";
-import { mergeProps as E } from "./lyra139.js";
-import { mergeRefs as $e } from "./lyra124.js";
-import { filterDOMProps as R } from "./lyra202.js";
-import { useObjectRef as _ } from "./lyra125.js";
-import a, { forwardRef as oe, createContext as V, useMemo as re, useContext as c, useCallback as ve, useRef as H, useEffect as le } from "react";
-import "react-dom";
-import { useMultipleSelectionState as ye } from "./lyra402.js";
-import { useTableRowGroup as ae } from "./lyra127.js";
-import { useHover as N } from "./lyra275.js";
-import { useTableCell as De } from "./lyra357.js";
-import { useFocusRing as A } from "./lyra262.js";
-import { FocusScope as we } from "./lyra236.js";
-import { useTable as Ce } from "./lyra344.js";
-import { ListKeyboardDelegate as xe } from "./lyra339.js";
-import { useTableHeaderRow as Pe } from "./lyra356.js";
-import { useTableSelectAllCheckbox as Te, useTableSelectionCheckbox as He } from "./lyra358.js";
-import { useTableColumnHeader as Se } from "./lyra352.js";
-import { useVisuallyHidden as X } from "./lyra320.js";
-import { useTableRow as Re } from "./lyra354.js";
-class Ee extends he {
-  addNode(e) {
-    super.addNode(e), this.columnsDirty || (this.columnsDirty = e.type === "column"), e.type === "tableheader" && (this.head = e), e.type === "tablebody" && (this.body = e);
-  }
-  commit(e, o, l = !1) {
-    this.updateColumns(l), super.commit(e, o, l), this.rows = [
-      ...this.getChildren(this.body.key)
-    ];
-  }
-  updateColumns(e) {
-    if (!this.columnsDirty) return;
-    this.rowHeaderColumnKeys = /* @__PURE__ */ new Set(), this.columns = [];
-    let o = /* @__PURE__ */ new Map(), l = (t) => {
-      switch (t.type) {
-        case "column":
-          o.set(t.key, t), t.hasChildNodes || (t.index = this.columns.length, this.columns.push(t), t.props.isRowHeader && this.rowHeaderColumnKeys.add(t.key));
-          break;
-      }
-      for (let i of this.getChildren(t.key)) l(i);
-    };
-    for (let t of this.getChildren(this.head.key)) l(t);
-    if (this.headerRows = ge(o, this.columns), this.columnsDirty = !1, this.rowHeaderColumnKeys.size === 0 && this.columns.length > 0 && !e) throw new Error("A table must have at least one Column with the isRowHeader prop set to true");
-  }
-  get columnCount() {
-    return this.columns.length;
-  }
-  *[Symbol.iterator]() {
-    this.head.key !== -1 && (yield this.head, yield this.body);
-  }
-  get size() {
-    return this.rows.length;
-  }
-  getFirstKey() {
-    return this.body.firstChildKey;
-  }
-  getLastKey() {
-    return this.body.lastChildKey;
-  }
-  getKeyAfter(e) {
-    let o = this.getItem(e);
-    var l;
-    return (o == null ? void 0 : o.type) === "column" ? (l = o.nextKey) !== null && l !== void 0 ? l : null : super.getKeyAfter(e);
-  }
-  getKeyBefore(e) {
-    var o;
-    let l = this.getItem(e);
-    var t;
-    if ((l == null ? void 0 : l.type) === "column") return (t = l.prevKey) !== null && t !== void 0 ? t : null;
-    let i = super.getKeyBefore(e);
-    return i != null && ((o = this.getItem(i)) === null || o === void 0 ? void 0 : o.type) === "tablebody" ? null : i;
-  }
-  getChildren(e) {
-    if (!this.getItem(e)) {
-      for (let o of this.headerRows)
-        if (o.key === e) return o.childNodes;
-    }
-    return super.getChildren(e);
-  }
-  clone() {
-    let e = super.clone();
-    return e.headerRows = this.headerRows, e.columns = this.columns, e.rowHeaderColumnKeys = this.rowHeaderColumnKeys, e.head = this.head, e.body = this.body, e;
-  }
-  getTextValue(e) {
-    let o = this.getItem(e);
-    if (!o) return "";
-    if (o.textValue) return o.textValue;
-    let l = this.rowHeaderColumnKeys, t = [];
-    for (let i of this.getChildren(e)) {
-      let s = this.columns[i.index];
-      if (l.has(s.key) && i.textValue && t.push(i.textValue), t.length === l.size) break;
-    }
-    return t.join(" ");
-  }
-  constructor(...e) {
-    super(...e), this.headerRows = [], this.columns = [], this.rows = [], this.rowHeaderColumnKeys = /* @__PURE__ */ new Set(), this.head = new Z("tableheader", -1), this.body = new Z("tablebody", -2), this.columnsDirty = !0;
-  }
-}
-const ke = /* @__PURE__ */ V(null), Ve = /* @__PURE__ */ V(null), T = /* @__PURE__ */ V(null), ie = /* @__PURE__ */ V(null), mt = /* @__PURE__ */ oe(function(e, o) {
-  var l;
-  [e, o] = de(e, o, Ve);
-  let t = ye(e), { selectionBehavior: i, selectionMode: s, disallowEmptySelection: d } = t, u = !!(!((l = e.dragAndDropHooks) === null || l === void 0) && l.useDraggableCollectionState), f = re(() => ({
-    selectionBehavior: s === "none" ? null : i,
-    selectionMode: s,
-    disallowEmptySelection: d,
-    allowsDragging: u
-  }), [
-    i,
-    s,
-    d,
-    u
-  ]), n = /* @__PURE__ */ a.createElement(Fe.Provider, {
-    value: f
-  }, /* @__PURE__ */ a.createElement(Q, e));
-  return /* @__PURE__ */ a.createElement(pe, {
-    content: n,
-    createCollection: () => new Ee()
-  }, (p) => /* @__PURE__ */ a.createElement(ze, {
-    props: e,
-    forwardedRef: o,
-    selectionState: t,
-    collection: p
+import { CollectionRendererContext as T, DefaultCollectionRenderer as S, usePersistedKeys as V } from "./lyra378.js";
+import { useContextProps as M, useRenderProps as m, Provider as h, useSlottedContext as g } from "./lyra121.js";
+import { createLeafComponent as k, CollectionBuilder as w, Collection as K } from "./lyra379.js";
+import { createHideableComponent as N } from "./lyra380.js";
+import { mergeProps as E } from "./lyra144.js";
+import { filterDOMProps as v } from "./lyra202.js";
+import { useObjectRef as x } from "./lyra123.js";
+import d, { forwardRef as R, createContext as y, useMemo as H, useContext as b } from "react";
+import { useTabPanel as O } from "./lyra362.js";
+import { useTab as z } from "./lyra360.js";
+import { useTabList as A } from "./lyra363.js";
+import { useFocusRing as C } from "./lyra262.js";
+import { useHover as I } from "./lyra275.js";
+import { useTabListState as j } from "./lyra407.js";
+const p = /* @__PURE__ */ y(null), u = /* @__PURE__ */ y(null), re = /* @__PURE__ */ R(function(t, o) {
+  [t, o] = M(t, o, p);
+  let { children: a, orientation: s = "horizontal" } = t;
+  return a = H(() => typeof a == "function" ? a({
+    orientation: s,
+    defaultChildren: null
+  }) : a, [
+    a,
+    s
+  ]), /* @__PURE__ */ d.createElement(w, {
+    content: a
+  }, (l) => /* @__PURE__ */ d.createElement(_, {
+    props: t,
+    collection: l,
+    tabsRef: o
   }));
 });
-function ze({ props: r, forwardedRef: e, selectionState: o, collection: l }) {
-  let t = c(ke);
-  e = _(re(() => $e(e, t == null ? void 0 : t.tableRef), [
-    e,
-    t == null ? void 0 : t.tableRef
-  ]));
-  let i = me({
-    ...r,
-    collection: l,
-    children: void 0,
-    UNSAFE_selectionState: o
-  }), { isVirtualized: s, layoutDelegate: d, dropTargetDelegate: u, CollectionRoot: f } = c(x), { dragAndDropHooks: n } = r, { gridProps: p } = Ce({
+function _({ props: e, tabsRef: t, collection: o }) {
+  let { orientation: a = "horizontal" } = e, s = j({
+    ...e,
+    collection: o,
+    children: void 0
+  }), { focusProps: l, isFocused: n, isFocusVisible: i } = C({
+    within: !0
+  }), c = H(() => ({
+    orientation: a,
+    isFocusWithin: n,
+    isFocusVisible: i
+  }), [
+    a,
+    n,
+    i
+  ]), r = m({
+    ...e,
+    defaultClassName: "react-aria-Tabs",
+    values: c
+  });
+  return /* @__PURE__ */ d.createElement("div", {
+    ...v(e),
+    ...l,
     ...r,
-    layoutDelegate: d,
-    isVirtualized: s
-  }, i, e), b = i.selectionManager, h = !!(n != null && n.useDraggableCollectionState), D = !!(n != null && n.useDroppableCollectionState), C = H(h), P = H(D);
-  le(() => {
-    C.current !== h && console.warn("Drag hooks were provided during one render, but not another. This should be avoided as it may produce unexpected behavior."), P.current !== D && console.warn("Drop hooks were provided during one render, but not another. This should be avoided as it may produce unexpected behavior.");
-  }, [
-    h,
-    D
-  ]);
-  let v, w, y, $ = !1, m = null, z = H(null);
-  if (h && n) {
-    v = n.useDraggableCollectionState({
-      collection: l,
-      selectionManager: b,
-      preview: n.renderDragPreview ? z : void 0
-    }), n.useDraggableCollection({}, v, e);
-    let j = n.DragPreview;
-    m = n.renderDragPreview ? /* @__PURE__ */ a.createElement(j, {
-      ref: z
-    }, n.renderDragPreview) : null;
-  }
-  if (D && n) {
-    w = n.useDroppableCollectionState({
-      collection: l,
-      selectionManager: b
-    });
-    let j = new xe({
-      collection: l,
-      disabledKeys: b.disabledKeys,
-      disabledBehavior: b.disabledBehavior,
-      ref: e,
-      layoutDelegate: d
-    }), se = n.dropTargetDelegate || u || new n.ListDropTargetDelegate(l.rows, e);
-    y = n.useDroppableCollection({
-      keyboardDelegate: j,
-      dropTargetDelegate: se
-    }, w, e), $ = w.isDropTarget({
-      type: "root"
-    });
-  }
-  let { focusProps: W, isFocused: F, isFocusVisible: I } = A(), L = S({
-    className: r.className,
-    style: r.style,
-    defaultClassName: "react-aria-Table",
-    values: {
-      isDropTarget: $,
-      isFocused: F,
-      isFocusVisible: I,
-      state: i
-    }
-  }), O = !!(h && !(v != null && v.isDisabled)), K = L.style, B = null;
-  t && (B = t.useTableColumnResizeState({
-    tableWidth: t.tableWidth
-  }, i), s || (K = {
-    ...K,
-    tableLayout: "fixed",
-    width: "fit-content"
-  }));
-  let G = g("table");
-  var U;
-  return /* @__PURE__ */ a.createElement(M, {
+    ref: t,
+    slot: e.slot || void 0,
+    "data-focused": n || void 0,
+    "data-orientation": a,
+    "data-focus-visible": i || void 0,
+    "data-disabled": s.isDisabled || void 0
+  }, /* @__PURE__ */ d.createElement(h, {
     values: [
       [
-        T,
-        i
-      ],
-      [
-        ie,
-        B
-      ],
-      [
-        k,
-        {
-          dragAndDropHooks: n,
-          dragState: v,
-          dropState: w
-        }
+        p,
+        e
       ],
       [
-        ue,
-        {
-          render: Be
-        }
+        u,
+        s
       ]
     ]
-  }, /* @__PURE__ */ a.createElement(we, null, /* @__PURE__ */ a.createElement(G, {
-    ...R(r),
-    ...L,
-    ...E(p, W, y == null ? void 0 : y.collectionProps),
-    style: K,
-    ref: e,
-    slot: r.slot || void 0,
-    onScroll: r.onScroll,
-    "data-allows-dragging": O || void 0,
-    "data-drop-target": $ || void 0,
-    "data-focused": F || void 0,
-    "data-focus-visible": I || void 0
-  }, /* @__PURE__ */ a.createElement(f, {
-    collection: l,
-    scrollRef: (U = t == null ? void 0 : t.scrollRef) !== null && U !== void 0 ? U : e,
-    persistedKeys: fe(b, n, w)
-  }))), m);
-}
-function g(r) {
-  let { isVirtualized: e } = c(x);
-  return e ? "div" : r;
+  }, r.children));
 }
-const Fe = /* @__PURE__ */ V(null), gt = /* @__PURE__ */ q("tableheader", (r, e) => {
-  let o = c(T).collection, l = be({
-    items: o.headerRows,
-    children: ve((f) => {
-      switch (f.type) {
-        case "headerrow":
-          return /* @__PURE__ */ a.createElement(Ie, {
-            item: f
-          });
-        default:
-          throw new Error("Unsupported node type in TableHeader: " + f.type);
-      }
-    }, [])
-  }), t = g("thead"), { rowGroupProps: i } = ae(), { hoverProps: s, isHovered: d } = N({
-    onHoverStart: r.onHoverStart,
-    onHoverChange: r.onHoverChange,
-    onHoverEnd: r.onHoverEnd
-  }), u = S({
-    className: r.className,
-    style: r.style,
-    defaultClassName: "react-aria-TableHeader",
+const ie = /* @__PURE__ */ R(function(t, o) {
+  return b(u) ? /* @__PURE__ */ d.createElement(B, {
+    props: t,
+    forwardedRef: o
+  }) : /* @__PURE__ */ d.createElement(K, t);
+});
+function B({ props: e, forwardedRef: t }) {
+  let o = b(u), { CollectionRoot: a } = b(T), { orientation: s = "horizontal", keyboardActivation: l = "automatic" } = g(p), n = x(t), { tabListProps: i } = A({
+    ...e,
+    orientation: s,
+    keyboardActivation: l
+  }, o, n), c = m({
+    ...e,
+    children: null,
+    defaultClassName: "react-aria-TabList",
     values: {
-      isHovered: d
+      orientation: s,
+      state: o
     }
-  });
-  return /* @__PURE__ */ a.createElement(t, {
-    ...E(R(r), i, s),
-    ...u,
-    ref: e,
-    "data-hovered": d || void 0
-  }, l);
-}, (r) => /* @__PURE__ */ a.createElement(Q, {
-  dependencies: r.dependencies,
-  items: r.columns
-}, r.children));
-function Ie({ item: r }) {
-  let e = H(null), o = c(T), { isVirtualized: l, CollectionBranch: t } = c(x), { rowProps: i } = Pe({
-    node: r,
-    isVirtualized: l
-  }, o, e), { checkboxProps: s } = Te(o), d = g("tr");
-  return /* @__PURE__ */ a.createElement(d, {
+  }), r = v(e);
+  return delete r.id, /* @__PURE__ */ d.createElement("div", {
+    ...r,
     ...i,
-    ref: e
-  }, /* @__PURE__ */ a.createElement(M, {
-    values: [
-      [
-        ee,
-        {
-          slots: {
-            selection: s
-          }
-        }
-      ]
-    ]
-  }, /* @__PURE__ */ a.createElement(t, {
+    ref: n,
+    ...c,
+    "data-orientation": s || void 0
+  }, /* @__PURE__ */ d.createElement(a, {
     collection: o.collection,
-    parent: r
-  })));
+    persistedKeys: V(o.selectionManager.focusedKey)
+  }));
 }
-const $t = /* @__PURE__ */ J("column", (r, e, o) => {
-  var l, t;
-  let i = _(e), s = c(T), { isVirtualized: d } = c(x), { columnHeaderProps: u } = Se({
-    node: o,
-    isVirtualized: d
-  }, s, i), { isFocused: f, isFocusVisible: n, focusProps: p } = A(), b = c(ie), h = !1;
-  if (b) h = b.resizingColumn === o.key;
-  else
-    for (let y in [
-      "width",
-      "defaultWidth",
-      "minWidth",
-      "maxWidth"
-    ]) y in o.props && console.warn(`The ${y} prop on a <Column> only applies when a <Table> is wrapped in a <ResizableTableContainer>. If you aren't using column resizing, you can set the width of a column with CSS.`);
-  let { hoverProps: D, isHovered: C } = N({
-    isDisabled: !r.allowsSorting
-  }), P = S({
-    ...r,
+const de = /* @__PURE__ */ k("item", (e, t, o) => {
+  let a = b(u), s = x(t), { tabProps: l, isSelected: n, isDisabled: i, isPressed: c } = z({
+    key: o.key,
+    ...e
+  }, a, s), { focusProps: r, isFocused: f, isFocusVisible: $ } = C(), { hoverProps: P, isHovered: F } = I({
+    isDisabled: i,
+    onHoverStart: e.onHoverStart,
+    onHoverEnd: e.onHoverEnd,
+    onHoverChange: e.onHoverChange
+  }), L = m({
+    ...e,
     id: void 0,
-    children: o.rendered,
-    defaultClassName: "react-aria-Column",
+    defaultClassName: "react-aria-Tab",
     values: {
-      isHovered: C,
+      isSelected: n,
+      isDisabled: i,
       isFocused: f,
-      isFocusVisible: n,
-      allowsSorting: o.props.allowsSorting,
-      sortDirection: ((l = s.sortDescriptor) === null || l === void 0 ? void 0 : l.column) === o.key ? s.sortDescriptor.direction : void 0,
-      isResizing: h,
-      startResize: () => {
-        if (b)
-          b.startResize(o.key), s.setKeyboardNavigationDisabled(!0);
-        else throw new Error("Wrap your <Table> in a <ResizableTableContainer> to enable column resizing");
-      },
-      sort: (y) => {
-        s.sort(o.key, y);
-      }
+      isFocusVisible: $,
+      isPressed: c,
+      isHovered: F
     }
-  }), v = P.style;
-  b && (v = {
-    ...v,
-    width: b.getColumnWidth(o.key)
-  });
-  let w = g("th");
-  return /* @__PURE__ */ a.createElement(w, {
-    ...E(R(r), u, p, D),
-    ...P,
-    style: v,
-    colSpan: o.colspan,
-    ref: i,
-    "data-hovered": C || void 0,
+  }), D = o.props.href ? "a" : "div";
+  return /* @__PURE__ */ d.createElement(D, {
+    ...E(l, r, P, L),
+    ref: s,
+    "data-selected": n || void 0,
+    "data-disabled": i || void 0,
     "data-focused": f || void 0,
-    "data-focus-visible": n || void 0,
-    "data-resizing": h || void 0,
-    "data-allows-sorting": o.props.allowsSorting || void 0,
-    "data-sort-direction": ((t = s.sortDescriptor) === null || t === void 0 ? void 0 : t.column) === o.key ? s.sortDescriptor.direction : void 0
-  }, /* @__PURE__ */ a.createElement(M, {
-    values: [
-      [
-        Ke,
-        {
-          column: o,
-          triggerRef: i
-        }
-      ],
-      [
-        x,
-        te
-      ]
-    ]
-  }, P.children));
-}), Ke = /* @__PURE__ */ V(null), vt = /* @__PURE__ */ q("tablebody", (r, e) => {
-  let o = c(T), { isVirtualized: l } = c(x), t = o.collection, { CollectionBranch: i } = c(x), { dragAndDropHooks: s, dropState: d } = c(k), u = !!(s != null && s.useDroppableCollectionState) && !(d != null && d.isDisabled);
-  var f;
-  let p = {
-    isDropTarget: u && !!d && ((f = d.isDropTarget({
-      type: "root"
-    })) !== null && f !== void 0 ? f : !1),
-    isEmpty: t.size === 0
-  }, b = S({
-    ...r,
-    id: void 0,
-    children: void 0,
-    defaultClassName: "react-aria-TableBody",
-    values: p
-  }), h, D = g("tr"), C = g("td"), P = t.columnCount;
-  if (t.size === 0 && r.renderEmptyState && o) {
-    let y = {}, $ = {}, m = {};
-    l ? (y["aria-rowindex"] = t.headerRows.length + 1, $["aria-colspan"] = P, m = {
-      display: "contents"
-    }) : $.colSpan = P, h = /* @__PURE__ */ a.createElement(D, {
-      role: "row",
-      ...y,
-      style: m
-    }, /* @__PURE__ */ a.createElement(C, {
-      role: "rowheader",
-      ...$,
-      style: m
-    }, r.renderEmptyState(p)));
-  }
-  let { rowGroupProps: v } = ae(), w = g("tbody");
-  return /* @__PURE__ */ a.createElement(w, {
-    ...E(R(r), v),
-    ...b,
-    ref: e,
-    "data-empty": t.size === 0 || void 0
-  }, u && /* @__PURE__ */ a.createElement(Me, null), /* @__PURE__ */ a.createElement(i, {
-    collection: t,
-    parent: t.body,
-    renderDropIndicator: ce(s, d)
-  }), h);
-}), yt = /* @__PURE__ */ q("item", (r, e, o) => {
-  let l = _(e), t = c(T), { dragAndDropHooks: i, dragState: s, dropState: d } = c(k), { isVirtualized: u, CollectionBranch: f } = c(x), { rowProps: n, ...p } = Re({
-    node: o,
-    shouldSelectOnPressUp: !!s,
-    isVirtualized: u
-  }, t, l), { isFocused: b, isFocusVisible: h, focusProps: D } = A(), { isFocusVisible: C, focusProps: P } = A({
-    within: !0
-  }), { hoverProps: v, isHovered: w } = N({
-    isDisabled: !p.allowsSelection && !p.hasAction,
-    onHoverStart: r.onHoverStart,
-    onHoverChange: r.onHoverChange,
-    onHoverEnd: r.onHoverEnd
-  }), { checkboxProps: y } = He({
-    key: o.key
-  }, t), $;
-  s && i && ($ = i.useDraggableItem({
-    key: o.key,
-    hasDragButton: !0
-  }, s));
-  let m, z = H(null), { visuallyHiddenProps: W } = X();
-  d && i && (m = i.useDropIndicator({
-    target: {
-      type: "item",
-      key: o.key,
-      dropPosition: "on"
-    }
-  }, d, z));
-  let F = H(null);
-  le(() => {
-    s && !F.current && console.warn('Draggable items in a Table must contain a <Button slot="drag"> element so that keyboard and screen reader users can drag them.');
-  }, []);
-  let I = s && s.isDragging(o.key), { children: L, ...O } = r, K = S({
-    ...O,
-    id: void 0,
-    defaultClassName: "react-aria-Row",
+    "data-focus-visible": $ || void 0,
+    "data-pressed": c || void 0,
+    "data-hovered": F || void 0
+  });
+}), ne = /* @__PURE__ */ N(function(t, o) {
+  const a = b(u);
+  let s = x(o), { tabPanelProps: l } = O(t, a, s), { focusProps: n, isFocused: i, isFocusVisible: c } = C(), r = a.selectedKey === t.id, f = m({
+    ...t,
+    defaultClassName: "react-aria-TabPanel",
     values: {
-      ...p,
-      isHovered: w,
-      isFocused: b,
-      isFocusVisible: h,
-      selectionMode: t.selectionManager.selectionMode,
-      selectionBehavior: t.selectionManager.selectionBehavior,
-      isDragging: I,
-      isDropTarget: m == null ? void 0 : m.isDropTarget,
-      isFocusVisibleWithin: C
-    }
-  }), B = g("tr"), G = g("td");
-  return /* @__PURE__ */ a.createElement(a.Fragment, null, m && !m.isHidden && /* @__PURE__ */ a.createElement(B, {
-    role: "row",
-    style: {
-      height: 0
+      isFocused: i,
+      isFocusVisible: c,
+      isInert: !r,
+      state: a
     }
-  }, /* @__PURE__ */ a.createElement(G, {
-    role: "gridcell",
-    colSpan: t.collection.columnCount,
-    style: {
-      padding: 0
-    }
-  }, /* @__PURE__ */ a.createElement("div", {
-    role: "button",
-    ...W,
-    ...m.dropIndicatorProps,
-    ref: z
-  }))), /* @__PURE__ */ a.createElement(B, {
-    ...E(R(r), n, D, v, $ == null ? void 0 : $.dragProps, P),
-    ...K,
-    ref: l,
-    "data-disabled": p.isDisabled || void 0,
-    "data-selected": p.isSelected || void 0,
-    "data-hovered": w || void 0,
-    "data-focused": p.isFocused || void 0,
-    "data-focus-visible": h || void 0,
-    "data-pressed": p.isPressed || void 0,
-    "data-dragging": I || void 0,
-    "data-drop-target": (m == null ? void 0 : m.isDropTarget) || void 0,
-    "data-selection-mode": t.selectionManager.selectionMode === "none" ? void 0 : t.selectionManager.selectionMode,
-    "data-focus-visible-within": C || void 0
-  }, /* @__PURE__ */ a.createElement(M, {
+  });
+  if (!r && !t.shouldForceMount) return null;
+  let $ = v(t);
+  delete $.id;
+  let P = r ? E($, l, n, f) : f;
+  return /* @__PURE__ */ d.createElement("div", {
+    ...P,
+    ref: s,
+    "data-focused": i || void 0,
+    "data-focus-visible": c || void 0,
+    // @ts-ignore
+    inert: r ? void 0 : "true",
+    "data-inert": r ? void 0 : "true"
+  }, /* @__PURE__ */ d.createElement(h, {
     values: [
       [
-        ee,
-        {
-          slots: {
-            [Y]: {},
-            selection: y
-          }
-        }
+        p,
+        null
       ],
       [
-        ne,
-        {
-          slots: {
-            [Y]: {},
-            drag: {
-              ...$ == null ? void 0 : $.dragButtonProps,
-              ref: F,
-              style: {
-                pointerEvents: "none"
-              }
-            }
-          }
-        }
+        u,
+        null
       ]
     ]
-  }, /* @__PURE__ */ a.createElement(f, {
-    collection: t.collection,
-    parent: o
-  }))));
-}, (r) => {
-  if (r.id == null && typeof r.children == "function") throw new Error("No id detected for the Row element. The Row element requires a id to be provided to it when the cells are rendered dynamically.");
-  let e = [
-    r.value
-  ].concat(r.dependencies);
-  return /* @__PURE__ */ a.createElement(Q, {
-    dependencies: e,
-    items: r.columns,
-    idScope: r.id
-  }, r.children);
-}), Dt = /* @__PURE__ */ J("cell", (r, e, o) => {
-  let l = _(e), t = c(T), { dragState: i } = c(k), { isVirtualized: s } = c(x);
-  o.column = t.collection.columns[o.index];
-  let { gridCellProps: d, isPressed: u } = De({
-    node: o,
-    shouldSelectOnPressUp: !!i,
-    isVirtualized: s
-  }, t, l), { isFocused: f, isFocusVisible: n, focusProps: p } = A(), { hoverProps: b, isHovered: h } = N({}), D = S({
-    ...r,
-    id: void 0,
-    defaultClassName: "react-aria-Cell",
-    values: {
-      isFocused: f,
-      isFocusVisible: n,
-      isPressed: u,
-      isHovered: h
-    }
-  }), C = g("td");
-  return /* @__PURE__ */ a.createElement(C, {
-    ...E(R(r), d, p, b),
-    ...D,
-    ref: l,
-    "data-focused": f || void 0,
-    "data-focus-visible": n || void 0,
-    "data-pressed": u || void 0
-  }, /* @__PURE__ */ a.createElement(x.Provider, {
-    value: te
-  }, D.children));
-});
-function Be(r, e) {
-  e = _(e);
-  let { dragAndDropHooks: o, dropState: l } = c(k), t = H(null), { dropIndicatorProps: i, isHidden: s, isDropTarget: d } = o.useDropIndicator(r, l, t);
-  return s ? null : /* @__PURE__ */ a.createElement(_e, {
-    ...r,
-    dropIndicatorProps: i,
-    isDropTarget: d,
-    buttonRef: t,
-    ref: e
-  });
-}
-function Ae(r, e) {
-  let { dropIndicatorProps: o, isDropTarget: l, buttonRef: t, ...i } = r, s = c(T), { visuallyHiddenProps: d } = X(), u = S({
-    ...i,
-    defaultClassName: "react-aria-DropIndicator",
-    values: {
-      isDropTarget: l
-    }
-  }), f = g("tr"), n = g("td");
-  return /* @__PURE__ */ a.createElement(f, {
-    ...R(r),
-    ...u,
-    role: "row",
-    ref: e,
-    "data-drop-target": l || void 0
-  }, /* @__PURE__ */ a.createElement(n, {
-    role: "gridcell",
-    colSpan: s.collection.columnCount,
-    style: {
-      padding: 0
-    }
-  }, /* @__PURE__ */ a.createElement("div", {
-    ...d,
-    role: "button",
-    ...o,
-    ref: t
-  }), u.children));
-}
-const _e = /* @__PURE__ */ oe(Ae);
-function Me() {
-  let r = c(T), { dragAndDropHooks: e, dropState: o } = c(k), l = H(null), { dropIndicatorProps: t } = e.useDropIndicator({
-    target: {
-      type: "root"
-    }
-  }, o, l), i = o.isDropTarget({
-    type: "root"
-  }), { visuallyHiddenProps: s } = X(), d = g("tr"), u = g("td");
-  return !i && t["aria-hidden"] ? null : /* @__PURE__ */ a.createElement(d, {
-    role: "row",
-    "aria-hidden": t["aria-hidden"],
-    style: {
-      height: 0
-    }
-  }, /* @__PURE__ */ a.createElement(u, {
-    role: "gridcell",
-    colSpan: r.collection.columnCount,
-    style: {
-      padding: 0
-    }
-  }, /* @__PURE__ */ a.createElement("div", {
-    role: "button",
-    ...s,
-    ...t,
-    ref: l
-  })));
-}
-J("loader", function(e, o, l) {
-  let t = c(T), { isVirtualized: i } = c(x), s = t.collection.columns.length, d = S({
-    ...e,
-    id: void 0,
-    children: l.rendered,
-    defaultClassName: "react-aria-TableLoadingIndicator",
-    values: null
-  }), u = g("tr"), f = g("td"), n = {}, p = {}, b = {};
-  return i ? (n["aria-rowindex"] = t.collection.headerRows.length + t.collection.size, p["aria-colspan"] = s, b = {
-    display: "contents"
-  }) : p.colSpan = s, /* @__PURE__ */ a.createElement(a.Fragment, null, /* @__PURE__ */ a.createElement(u, {
-    role: "row",
-    ref: o,
-    ...E(R(e), n),
-    ...d
-  }, /* @__PURE__ */ a.createElement(f, {
-    role: "rowheader",
-    ...p,
-    style: b
-  }, d.children)));
+  }, /* @__PURE__ */ d.createElement(T.Provider, {
+    value: S
+  }, f.children)));
 });
 export {
-  Dt as Cell,
-  $t as Column,
-  yt as Row,
-  mt as Table,
-  vt as TableBody,
-  ie as TableColumnResizeStateContext,
-  Ve as TableContext,
-  gt as TableHeader,
-  T as TableStateContext
+  de as Tab,
+  ie as TabList,
+  u as TabListStateContext,
+  ne as TabPanel,
+  re as Tabs,
+  p as TabsContext
 };