@propellerads/table 5.1.1 → 6.0.0

package/dist/index.d.ts

@@ -1,22 +1,114 @@
-import React, { FunctionComponent } from 'react';
-import { TableState } from 'react-table';
-import { DefaultObject, FOOTER_PLACEMENT, TableProps } from './types';
-export declare const defaultProps: {
-    hasDefaultPagination: boolean;
-    isLoading: boolean;
-    footerPlacement: FOOTER_PLACEMENT[];
-    loadingMessage: string;
-    labelPerPage: string;
-    parentElementId: string;
-    tableContentId: string;
-    showLoadingState: boolean;
-    initialState: Partial<TableState<Record<string, unknown>>>;
-    LoadingCellComponent: React.FunctionComponent<Record<string, unknown>>;
-    getRowPreProps: () => DefaultObject;
-    isEnableRowSelect: (_original?: Record<string, unknown> | undefined) => boolean;
-    selectColumnProps: {};
-    noDataMessage: string;
-};
-declare type DefaultProps = Readonly<typeof defaultProps>;
-declare const Table: FunctionComponent<TableProps & DefaultProps>;
-export { Table };
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as styled_components from 'styled-components';
+import { RowData, Cell, HeaderGroup, Header, ColumnDef, Row, TableState, VisibilityState, SortingState } from '@tanstack/react-table';
+export { SortingState, VisibilityState } from '@tanstack/react-table';
+import { CSSProperties, ComponentPropsWithoutRef, ReactNode, ComponentType, ReactElement } from 'react';
+
+declare module '@tanstack/react-table' {
+    interface ColumnMeta<TData extends RowData, TValue> {
+        align?: CSSProperties['textAlign'];
+    }
+}
+type DefaultObject = Record<string, unknown>;
+type LoadingState<TData extends DefaultObject = DefaultObject> = {
+    loadingColumns?: ColumnDef<TData>[];
+    loadingData: TData[];
+};
+type RowPreProps = ComponentPropsWithoutRef<'div'> & {
+    isDelimiterTd?: boolean;
+};
+declare const FooterPlacement: {
+    readonly Top: "top";
+    readonly Bottom: "bottom";
+};
+type FooterPlacement = (typeof FooterPlacement)[keyof typeof FooterPlacement];
+type PaginationProps = {
+    paginationAmount?: ReactNode;
+    parentElementId: string;
+    labelPerPage?: string;
+    pageSizes?: Array<string | number>;
+    pageIndex: number;
+    perPage: number;
+    totalPages: number;
+    totalItems: number;
+    canNextPage: boolean;
+    canPreviousPage: boolean;
+    nextPageHandler: () => void;
+    previousPageHandler: () => void;
+    setPageSize: (size: number) => void;
+    gotoPage: (page: number) => void;
+};
+type ControlledPagination = {
+    paginationAmount?: ReactNode;
+    pageSize: number;
+    pageIndex: number;
+    pageCount: number;
+};
+type HeaderGroupPropsGetter<TData extends DefaultObject = DefaultObject> = (headerGroup: HeaderGroup<TData>) => ComponentPropsWithoutRef<'div'>;
+type HeaderPropsGetter<TData extends DefaultObject = DefaultObject> = (header: Header<TData, unknown>) => ComponentPropsWithoutRef<'div'>;
+type RowPropsGetter<TData extends DefaultObject = DefaultObject> = (row: Row<TData>) => ComponentPropsWithoutRef<'div'>;
+type CellPropsGetter<TData extends DefaultObject = DefaultObject> = (cell: Cell<TData, unknown>) => ComponentPropsWithoutRef<'div'>;
+type SelectColumnProps<TData extends DefaultObject = DefaultObject> = Pick<ColumnDef<TData>, 'size' | 'minSize' | 'maxSize' | 'meta' | 'enableHiding'>;
+type TableProps<TData extends DefaultObject = DefaultObject> = {
+    columns: ColumnDef<TData>[];
+    data: TData[];
+    totalItems?: number;
+    PaginationComponent?: ComponentType<PaginationProps>;
+    initialState?: Partial<TableState> & {
+        columnVisibility?: VisibilityState;
+    };
+    fetchData?: (params: {
+        pageIndex: number;
+        pageSize: number;
+    }) => void;
+    onSortedChange?: (sorting: SortingState) => void;
+    isLoading?: boolean;
+    footerPlacement?: FooterPlacement[];
+    hasDefaultPagination?: boolean;
+    onSelectRowsChange?: (rows: TData[]) => void;
+    controlledPagination?: ControlledPagination;
+    loadingMessage?: string;
+    labelPerPage?: string;
+    parentElementId?: string;
+    tableContentId?: string;
+    getRowPreProps?: (row: Row<TData>) => RowPreProps;
+    getRowId?: (originalRow: TData, index: number, parent?: Row<TData>) => string;
+    getSubRows?: (originalRow: TData, index: number) => TData[] | undefined;
+    getTableProps?: () => ComponentPropsWithoutRef<'div'>;
+    getHeaderGroupProps?: HeaderGroupPropsGetter<TData>;
+    getHeaderProps?: HeaderPropsGetter<TData>;
+    getRowProps?: RowPropsGetter<TData>;
+    getCellProps?: CellPropsGetter<TData>;
+    getFooterProps?: HeaderPropsGetter<TData>;
+    getFooterGroupProps?: HeaderGroupPropsGetter<TData>;
+    showLoadingState?: boolean;
+    LoadingCellComponent?: ComponentType;
+    noDataMessage?: ReactNode;
+    rowSubComponent?: (row: Row<TData>) => ReactElement;
+    isEnableRowSelect?: (original: TData) => boolean;
+    selectColumnProps?: Partial<SelectColumnProps<TData>>;
+};
+type StandardColumn<TData extends DefaultObject = DefaultObject> = ColumnDef<TData>;
+type StandardRow<TData extends DefaultObject = DefaultObject> = Row<TData>;
+type StandardCell<TData extends DefaultObject = DefaultObject> = Cell<TData, unknown>;
+
+type TableRowData = DefaultObject & RowData;
+declare const defaultProps: {
+    hasDefaultPagination: boolean;
+    isLoading: boolean;
+    footerPlacement: never[];
+    loadingMessage: string;
+    labelPerPage: string;
+    parentElementId: string;
+    tableContentId: string;
+    showLoadingState: boolean;
+    LoadingCellComponent: styled_components.StyledComponent<"div", any, {}, never>;
+    getRowPreProps: () => RowPreProps;
+    isEnableRowSelect: () => boolean;
+    selectColumnProps: {};
+    noDataMessage: string;
+};
+declare const Table: <TData extends TableRowData = DefaultObject>({ columns, data, totalItems, fetchData, controlledPagination, initialState, isLoading, loadingMessage, labelPerPage, footerPlacement, onSortedChange, hasDefaultPagination, onSelectRowsChange, parentElementId, tableContentId, LoadingCellComponent, PaginationComponent, getRowPreProps, getRowId, getSubRows, getTableProps, getHeaderGroupProps, getHeaderProps, getRowProps, getCellProps, getFooterProps, getFooterGroupProps, showLoadingState, noDataMessage, rowSubComponent, isEnableRowSelect, selectColumnProps, }: TableProps<TData>) => react_jsx_runtime.JSX.Element;
+
+export { Table as default, defaultProps };
+export type { CellPropsGetter, ControlledPagination, DefaultObject, HeaderGroupPropsGetter, HeaderPropsGetter, LoadingState, PaginationProps, RowPreProps, RowPropsGetter, SelectColumnProps, StandardCell, StandardColumn, StandardRow, TableProps };

package/dist/index.js

@@ -1,8 +1,497 @@
+import { jsx as a, jsxs as w } from "react/jsx-runtime";
+import { ArrowUp as He, Color as ne, Size as oe, ArrowDown as _e } from "@propellerads/icon";
+import ie from "@propellerads/input-checkbox";
+import { useMemo as I, useEffect as A, useState as $, useRef as ae, Fragment as le } from "react";
+import { useReactTable as Ve, getPaginationRowModel as Be, getExpandedRowModel as Fe, getSortedRowModel as je, getCoreRowModel as Ue, flexRender as z } from "@tanstack/react-table";
+import d, { keyframes as Ye, css as L } from "styled-components";
+import { fontNormal as Ge, gray95 as D, white as Oe, spacing as me, black as qe, gray80 as We } from "@propellerads/stylevariables";
+const se = (e) => e.column.columnDef.meta?.align, Xe = (e) => e.column.columnDef.meta?.align, Ze = Ye`
+  from {
+    background-position-x: 0;
+  }
+  50% {
+    background-position-x: 100%;
+  }
+  100% {
+    background-position-x: 0;
+  }
+`, Je = d.div`
+  display: block;
+  position: absolute;
+  left: 0;
+  right: 0;
+  top: 0;
+  bottom: 0;
+  background: rgba(255, 255, 255, 0.8);
+  transition: all 0.3s ease;
+  z-index: -1;
+  opacity: 0;
+  pointer-events: none;
 
-'use strict'
+  ${({ $isLoading: e }) => e && L`
+      opacity: 1;
+      z-index: 2;
+      pointer-events: all;
+    `}
+`, Ke = d.div`
+  position: absolute;
+  display: block;
+  text-align: center;
+  width: 100%;
+  top: 50%;
+  left: 0;
+  color: rgba(0, 0, 0, 0.6);
+  transform: translateY(-52%);
+  transition: all 0.3s cubic-bezier(0.25, 0.46, 0.45, 0.94);
+`, Qe = d.div`
+  position: relative;
+  overflow: hidden;
 
-if (process.env.NODE_ENV === 'production') {
-  module.exports = require('./table.cjs.production.min.js')
-} else {
-  module.exports = require('./table.cjs.development.js')
-}
+  &::before {
+    bottom: 10px;
+    content: '';
+    opacity: 0;
+    pointer-events: none;
+    position: absolute;
+    width: 10px;
+    height: 100%;
+    top: 0;
+    left: -10px;
+    box-shadow: 0 3px 6px 0 rgba(0, 0, 0, 0.2);
+    transition: 0.3s opacity;
+  }
+
+  &::after {
+    bottom: 10px;
+    content: '';
+    opacity: 0;
+    pointer-events: none;
+    width: 10px;
+    height: 100%;
+    position: absolute;
+    top: 0;
+    right: -10px;
+    box-shadow: 0 3px 6px 0 rgba(0, 0, 0, 0.2);
+    transition: 0.3s opacity;
+  }
+
+  &.shadow_left {
+    &::before {
+      opacity: 1 !important;
+    }
+  }
+
+  &.shadow_right {
+    &::after {
+      opacity: 1 !important;
+    }
+  }
+`, et = d.div`
+  font-size: ${Ge}px;
+  position: relative;
+  display: flex;
+  flex-direction: column;
+  border: 0;
+`, tt = d.div`
+  display: block;
+  max-width: 100%;
+  overflow-x: scroll;
+  overflow-y: hidden;
+`, nt = d.div`
+  flex: auto 1;
+  display: flex;
+  flex-direction: column;
+  align-items: stretch;
+  border-collapse: collapse;
+`, re = d.div`
+  display: inline-flex;
+`, P = d.div`
+  flex: 0 0 ${({ $size: e }) => e ?? 50}px;
+  width: ${({ $size: e }) => e ?? 50}px;
+  white-space: nowrap;
+  text-overflow: ellipsis;
+  line-height: 1.3rem;
+  padding: 7px 4px;
+  overflow: hidden;
+  transition: width 0.3s ease 0s, min-width, padding, opacity;
+
+  ${({ $align: e }) => e && L`
+      text-align: ${e};
+    `}
+`, ot = d.div`
+  width: 100%;
+  height: ${me * 4}px;
+  background: linear-gradient(to left, ${D}, ${Oe}, ${D});
+  background-size: 200% 200%;
+  animation: ${Ze} 1.6s linear infinite;
+`, fe = d.div`
+  flex: 0 0 ${({ $size: e }) => e ?? 50}px;
+  width: ${({ $size: e }) => e ?? 50}px;
+  padding: 0 4px;
+  line-height: normal;
+  position: relative;
+  transition: box-shadow 0.3s cubic-bezier(0.175, 0.885, 0.32, 1.275) 0s;
+  color: rgb(0, 0, 0);
+  font-weight: 500;
+  outline: none;
+
+  ${({ $align: e }) => e && L`
+      text-align: ${e};
+    `}
+`, it = d.div`
+  flex: 1 0 auto;
+  display: flex;
+  flex-direction: column;
+  user-select: none;
+
+  ${fe}, ${P} {
+    padding: 0 4px;
+    line-height: normal;
+    position: relative;
+    transition: box-shadow 0.3s cubic-bezier(0.175, 0.885, 0.32, 1.275);
+    color: ${qe};
+    font-weight: 500;
+    outline: none;
+  }
+`, ce = d.div`
+  display: flex;
+  flex: 1 0 auto;
+  box-shadow: inset 0 -1px 0 0 ${D};
+  min-width: 100%;
+  width: max-content;
+`, S = d.div`
+  display: flex;
+  flex: 1 0 auto;
+  padding: 0;
+  align-items: center;
+`, at = d.div`
+  border-top: 1px solid ${We};
+  margin-top: ${me * 2}px;
+  min-width: 100%;
+  width: max-content;
+`, de = d.div`
+  background: ${D};
+  flex: 1 0 auto;
+  display: flex;
+  flex-direction: column;
+`, lt = d.div`
+  display: inline-block;
+  position: absolute;
+  right: 5px;
+  top: 0;
+  z-index: 1;
+  touch-action: none;
+
+  &:after {
+    content: '↔';
+    position: absolute;
+    right: 0;
+    top: 0;
+  }
+`, ge = {
+  Top: "top",
+  Bottom: "bottom"
+}, st = (e, o, s, l, i) => {
+  const x = I(
+    () => e && o ? l.map((b) => ({
+      ...b,
+      cell: () => /* @__PURE__ */ a(i, {})
+    })) : [],
+    [l, o, e]
+  ), h = I(() => {
+    if (e && o && l && l.length > 0) {
+      const b = {}, C = [];
+      for (let f = 0; f < l.length; f += 1)
+        b[`empty_${f}`] = "";
+      for (let f = 0; f < s; f += 1)
+        C.push(b);
+      return C;
+    }
+    return [];
+  }, [l, o, s, e]);
+  return {
+    loadingColumns: x,
+    loadingData: h
+  };
+}, M = {
+  Left: "shadow_left",
+  Right: "shadow_right"
+}, rt = (e, o) => {
+  const { classList: s } = e;
+  s.remove(M.Left, M.Right), s.add(...o);
+}, pe = (e, o) => {
+  if (!e || !o)
+    return;
+  const s = e.getBoundingClientRect(), l = o.getBoundingClientRect(), i = [], x = Math.floor(s.left), h = Math.floor(s.right), b = Math.floor(l.left), C = Math.floor(l.right);
+  x < b && i.push(M.Left), h > C && i.push(M.Right), rt(o, i);
+}, ct = (e, o) => {
+  A(() => {
+    let s = !1;
+    const l = () => {
+      s || (window.requestAnimationFrame(() => {
+        pe(e.current, o.current), s = !1;
+      }), s = !0);
+    };
+    return pe(e.current, o.current), e?.current?.addEventListener("mousewheel", l), window.addEventListener("resize", l), () => {
+      e?.current?.removeEventListener("mousewheel", l), window.removeEventListener("resize", l);
+    };
+  }, [e.current, o.current]);
+}, dt = () => !0, gt = {}, N = () => ({}), pt = (e) => {
+  const { subRows: o } = e;
+  if (Array.isArray(o))
+    return o;
+}, u = {
+  hasDefaultPagination: !1,
+  isLoading: !1,
+  footerPlacement: [],
+  loadingMessage: "loading...",
+  labelPerPage: "Show rows",
+  parentElementId: "parent-element",
+  tableContentId: "",
+  showLoadingState: !1,
+  LoadingCellComponent: ot,
+  getRowPreProps: N,
+  isEnableRowSelect: dt,
+  selectColumnProps: gt,
+  noDataMessage: ""
+}, ut = 0, ue = 10, mt = (e) => {
+  const o = e.column.getIsSorted(), s = z(e.column.columnDef.header, e.getContext());
+  return o === "desc" ? /* @__PURE__ */ w(re, { children: [
+    s,
+    /* @__PURE__ */ a(He, { size: oe.Small, color: ne.GrayDark })
+  ] }) : o === "asc" ? /* @__PURE__ */ w(re, { children: [
+    s,
+    /* @__PURE__ */ a(_e, { size: oe.Small, color: ne.GrayDark })
+  ] }) : s;
+}, ft = (e) => e.column.getCanResize() ? /* @__PURE__ */ a(
+  lt,
+  {
+    onMouseDown: e.getResizeHandler(),
+    onTouchStart: e.getResizeHandler(),
+    onClick: (o) => {
+      o.preventDefault(), o.stopPropagation();
+    }
+  }
+) : null, Rt = ({
+  columns: e,
+  data: o,
+  totalItems: s,
+  fetchData: l,
+  controlledPagination: i,
+  initialState: x,
+  isLoading: h = u.isLoading,
+  loadingMessage: b = u.loadingMessage,
+  labelPerPage: C = u.labelPerPage,
+  footerPlacement: f = u.footerPlacement,
+  onSortedChange: H,
+  hasDefaultPagination: k = u.hasDefaultPagination,
+  onSelectRowsChange: _,
+  parentElementId: xe = u.parentElementId,
+  tableContentId: he = u.tableContentId,
+  LoadingCellComponent: be = u.LoadingCellComponent,
+  PaginationComponent: V,
+  getRowPreProps: we = N,
+  getRowId: Ce,
+  getSubRows: ve = pt,
+  getTableProps: ye,
+  getHeaderGroupProps: Re,
+  getHeaderProps: Se,
+  getRowProps: B,
+  getCellProps: F,
+  getFooterProps: j,
+  getFooterGroupProps: U,
+  showLoadingState: T = u.showLoadingState,
+  noDataMessage: ze = u.noDataMessage,
+  rowSubComponent: v,
+  isEnableRowSelect: y = u.isEnableRowSelect,
+  selectColumnProps: Y = u.selectColumnProps
+}) => {
+  const E = I(() => e, [e]), g = T && h, R = !g && typeof _ == "function", G = typeof H == "function", m = !!(l && i && Object.keys(i).length > 0);
+  if (k && m)
+    throw new Error(
+      "You have to pass either hasDefaultPagination true boolean prop or pass fetchData callback and controlledPagination data"
+    );
+  if (m && typeof i?.pageCount > "u")
+    throw new Error("You have to pass pageCount in controlledPagination data");
+  const [Pe, O] = $([]), [q, Ie] = $({}), [W, $e] = $({
+    pageIndex: ut,
+    pageSize: ue
+  }), [De, X] = $(x?.columnVisibility ?? {});
+  A(() => {
+    x?.columnVisibility && X(x.columnVisibility);
+  }, [x?.columnVisibility]);
+  const Z = I(
+    () => ({
+      id: "selection",
+      enableSorting: !1,
+      header: ({ table: t }) => {
+        const r = t.getRowModel().rows.map((c) => c.original).filter(y).length === 0;
+        return /* @__PURE__ */ a(
+          ie,
+          {
+            elementId: "all",
+            onChange: t.toggleAllPageRowsSelected,
+            isChecked: t.getIsAllPageRowsSelected(),
+            isDisabled: r
+          }
+        );
+      },
+      cell: ({ row: t }) => {
+        const n = y(t.original);
+        return /* @__PURE__ */ a(
+          ie,
+          {
+            elementId: t.id,
+            onChange: t.toggleSelected,
+            isDisabled: !n,
+            isChecked: n && t.getIsSelected()
+          }
+        );
+      },
+      ...Y
+    }),
+    [y, Y]
+  ), { loadingColumns: J, loadingData: Me } = st(
+    T,
+    h,
+    m ? i?.pageSize ?? ue : W.pageSize,
+    E,
+    be
+  ), ke = I(() => {
+    const t = g ? J ?? [] : E;
+    return R ? [Z, ...t] : t;
+  }, [g, J, E, R, Z]), Te = g ? Me : o, Ee = m && i ? { pageIndex: i.pageIndex, pageSize: i.pageSize } : W, p = Ve({
+    columns: ke,
+    data: Te,
+    getCoreRowModel: Ue(),
+    getSortedRowModel: je(),
+    getExpandedRowModel: Fe(),
+    ...k || m ? { getPaginationRowModel: Be() } : {},
+    enableRowSelection: R ? (t) => y(t.original) : !1,
+    getRowCanExpand: (t) => !g && (!!v || t.subRows.length > 0),
+    getRowId: Ce,
+    getSubRows: ve,
+    state: {
+      sorting: Pe,
+      rowSelection: q,
+      pagination: Ee,
+      columnVisibility: De
+    },
+    onSortingChange: O,
+    onRowSelectionChange: Ie,
+    onPaginationChange: m ? void 0 : $e,
+    onColumnVisibilityChange: X,
+    manualSorting: G,
+    manualPagination: m ? !0 : void 0,
+    pageCount: m ? i?.pageCount : void 0,
+    enableSortingRemoval: !1,
+    enableMultiSort: !1,
+    enableColumnResizing: !1,
+    columnResizeMode: "onChange"
+  }), K = ae(null), Q = ae(null);
+  ct(K, Q), A(() => {
+    if (R) {
+      const t = p.getSelectedRowModel().flatRows.map((n) => n.original).filter(y);
+      _?.(t);
+    }
+  }, [q, R]);
+  let ee = null;
+  if (m || k) {
+    const { pageIndex: t, pageSize: n } = p.getState().pagination, r = {
+      setPageSize: p.setPageSize,
+      gotoPage: p.setPageIndex,
+      canNextPage: p.getCanNextPage(),
+      canPreviousPage: p.getCanPreviousPage(),
+      parentElementId: xe,
+      labelPerPage: C,
+      pageIndex: t,
+      previousPageHandler: p.previousPage,
+      nextPageHandler: p.nextPage,
+      totalPages: p.getPageCount(),
+      perPage: n,
+      totalItems: s ?? o.length
+    };
+    m && i && (r.canNextPage = i.pageIndex + 1 !== r.totalPages, r.canPreviousPage = i.pageIndex !== 0, r.pageIndex = i.pageIndex, r.perPage = i.pageSize, r.setPageSize = (c) => {
+      l?.({ pageIndex: i.pageIndex, pageSize: c });
+    }, r.gotoPage = (c) => {
+      l?.({ pageIndex: c, pageSize: i.pageSize });
+    }, r.nextPageHandler = () => {
+      l?.({ pageIndex: i.pageIndex + 1, pageSize: i.pageSize });
+    }, r.previousPageHandler = () => {
+      l?.({ pageIndex: i.pageIndex - 1, pageSize: i.pageSize });
+    }, i.paginationAmount && (r.paginationAmount = i.paginationAmount)), ee = V ? /* @__PURE__ */ a(V, { ...r }) : null;
+  }
+  const Ae = (t) => {
+    if (!t.column.getCanSort()) return;
+    const n = t.column.getIsSorted(), r = [{ id: t.column.id, desc: n !== "desc" }];
+    G && H?.(r), O(r);
+  }, Ne = p.getHeaderGroups(), te = p.getFooterGroups(), Le = p.getRowModel().rows;
+  return /* @__PURE__ */ w(et, { className: "table-root", children: [
+    /* @__PURE__ */ a(Je, { $isLoading: !T && h, className: "table-loading", children: /* @__PURE__ */ a(Ke, { children: b }) }),
+    /* @__PURE__ */ a(Qe, { ref: Q, className: "table-wrapper", children: /* @__PURE__ */ a(tt, { id: he, className: "table-content", children: /* @__PURE__ */ w(nt, { ...ye?.(), ref: K, children: [
+      /* @__PURE__ */ a(it, { className: "table-head", "data-role": "table-head", children: Ne.map((t) => /* @__PURE__ */ a(S, { ...Re?.(t), children: t.headers.map((n) => /* @__PURE__ */ w(
+        fe,
+        {
+          $size: n.getSize(),
+          onClick: () => Ae(n),
+          ...Se?.(n),
+          children: [
+            n.isPlaceholder ? null : mt(n),
+            ft(n)
+          ]
+        },
+        n.id
+      )) }, t.id)) }),
+      f.includes(ge.Top) && /* @__PURE__ */ a(de, { className: "table-footer-top", "data-role": "table-footer-top", children: te.map((t) => /* @__PURE__ */ a(S, { ...U?.(t), children: t.headers.map((n) => /* @__PURE__ */ a(
+        P,
+        {
+          $size: n.getSize(),
+          $align: se(n),
+          ...j?.(n),
+          children: n.isPlaceholder ? null : z(n.column.columnDef.footer, n.getContext())
+        },
+        n.id
+      )) }, t.id)) }),
+      /* @__PURE__ */ a(at, { className: "table-body", "data-role": "table-body", children: Le.map((t) => {
+        const n = g ? N() : we(t), { isDelimiterTd: r } = n;
+        if (r) {
+          const c = t.getVisibleCells()[0];
+          return c ? /* @__PURE__ */ w(le, { children: [
+            /* @__PURE__ */ a(ce, { children: /* @__PURE__ */ a(S, { ...g ? void 0 : B?.(t), children: /* @__PURE__ */ a(P, { style: { flex: "1 0 0%" }, ...g ? void 0 : F?.(c), children: /* @__PURE__ */ a("strong", { children: z(c.column.columnDef.cell, c.getContext()) }) }) }) }),
+            !g && t.getIsExpanded() && v && v(t)
+          ] }, `group_${t.index}`) : null;
+        }
+        return /* @__PURE__ */ w(le, { children: [
+          /* @__PURE__ */ a(ce, { children: /* @__PURE__ */ a(S, { ...g ? void 0 : B?.(t), children: t.getVisibleCells().map((c) => /* @__PURE__ */ a(
+            P,
+            {
+              $size: c.column.getSize(),
+              $align: Xe(c),
+              ...g ? void 0 : F?.(c),
+              children: z(c.column.columnDef.cell, c.getContext())
+            },
+            c.id
+          )) }) }),
+          !g && t.getIsExpanded() && v && v(t)
+        ] }, `group_${t.index}`);
+      }) }),
+      f.includes(ge.Bottom) && /* @__PURE__ */ a(de, { className: "table-footer-bottom", "data-role": "table-footer-bottom", children: te.map((t) => /* @__PURE__ */ a(S, { ...U?.(t), children: t.headers.map((n) => /* @__PURE__ */ a(
+        P,
+        {
+          $size: n.getSize(),
+          $align: se(n),
+          ...j?.(n),
+          children: n.isPlaceholder ? null : z(n.column.columnDef.footer, n.getContext())
+        },
+        n.id
+      )) }, t.id)) })
+    ] }) }) }),
+    !h && !o.length && ze,
+    ee
+  ] });
+};
+export {
+  Rt as default,
+  u as defaultProps
+};
+//# sourceMappingURL=index.js.map