@new-black/lyra 1.8.0 → 1.9.0

package/dist/lyra130.js

@@ -1,15 +1,666 @@
-import { useContextProps as r } from "./lyra106.js";
-import c, { forwardRef as n, createContext as f } from "react";
-const x = /* @__PURE__ */ f({}), b = /* @__PURE__ */ n(function(e, t) {
-  [e, t] = r(e, t, x);
-  let { elementType: a = "span", ...o } = e;
-  return /* @__PURE__ */ c.createElement(a, {
-    className: "react-aria-Text",
+import { ButtonContext as ne } from "./lyra117.js";
+import { CheckboxContext as ee } from "./lyra170.js";
+import { CollectionRendererContext as x, DefaultCollectionRenderer as te } from "./lyra378.js";
+import { useContextProps as de, useRenderProps as S, Provider as M, DEFAULT_SLOT as Y } from "./lyra121.js";
+import { DragAndDropContext as k, useRenderDropIndicator as ce, DropIndicatorContext as ue, useDndPersistedKeys as fe } from "./lyra395.js";
+import { createBranchComponent as q, createLeafComponent as J, Collection as Q, CollectionBuilder as pe } from "./lyra379.js";
+import { useCachedChildren as be } from "./lyra393.js";
+import { BaseCollection as he, CollectionNode as Z } from "./lyra404.js";
+import { useTableState as me } from "./lyra405.js";
+import { buildHeaderRows as ge } from "./lyra406.js";
+import { mergeProps as E } from "./lyra144.js";
+import { mergeRefs as $e } from "./lyra122.js";
+import { filterDOMProps as R } from "./lyra202.js";
+import { useObjectRef as _ } from "./lyra123.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 "./lyra397.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
+  }));
+});
+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({
+    ...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, {
+    values: [
+      [
+        T,
+        i
+      ],
+      [
+        ie,
+        B
+      ],
+      [
+        k,
+        {
+          dragAndDropHooks: n,
+          dragState: v,
+          dropState: w
+        }
+      ],
+      [
+        ue,
+        {
+          render: Be
+        }
+      ]
+    ]
+  }, /* @__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;
+}
+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",
+    values: {
+      isHovered: d
+    }
+  });
+  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, {
+    ...i,
+    ref: e
+  }, /* @__PURE__ */ a.createElement(M, {
+    values: [
+      [
+        ee,
+        {
+          slots: {
+            selection: s
+          }
+        }
+      ]
+    ]
+  }, /* @__PURE__ */ a.createElement(t, {
+    collection: o.collection,
+    parent: r
+  })));
+}
+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,
+    id: void 0,
+    children: o.rendered,
+    defaultClassName: "react-aria-Column",
+    values: {
+      isHovered: C,
+      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);
+      }
+    }
+  }), 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,
+    "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",
+    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
+    }
+  }, /* @__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, {
+    values: [
+      [
+        ee,
+        {
+          slots: {
+            [Y]: {},
+            selection: y
+          }
+        }
+      ],
+      [
+        ne,
+        {
+          slots: {
+            [Y]: {},
+            drag: {
+              ...$ == null ? void 0 : $.dragButtonProps,
+              ref: F,
+              style: {
+                pointerEvents: "none"
+              }
+            }
+          }
+        }
+      ]
+    ]
+  }, /* @__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)));
 });
 export {
-  b as Text,
-  x as TextContext
+  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
 };