@lucasbernardosn/react-table 0.0.0-stage → 0.1.0

package/dist/components/data-table/header/data-table-header-row.js

@@ -0,0 +1,28 @@
+import { DATA_TABLE_GRID_CLASS_NAMES } from "../root/data-table-grid-classes.js";
+import { mergeProps, useRender } from "@base-ui/react";
+import { mergeTwClassNames } from "@lucasbernardosn/react-ui/utils";
+//#region src/components/data-table/header/data-table-header-row.tsx
+/**
+* Uma linha de headers (`role="row"`), por grupo de headers. É um grid com as colunas do
+* `--data-table-template`, que o `DataTable.Root` escreve.
+*
+* O `DataTable.Header` com render-prop já monta uma por grupo; use direto só no laço feito à mão.
+*/
+const DataTableHeaderRow = (props) => {
+	const { render, className, ...rest } = props;
+	const baseProps = {
+		"data-component": "DataTable.HeaderRow",
+		role: "row",
+		className: mergeTwClassNames([DATA_TABLE_GRID_CLASS_NAMES], className)
+	};
+	return useRender({
+		render,
+		defaultTagName: "div",
+		props: mergeProps(baseProps, rest)
+	});
+};
+DataTableHeaderRow.displayName = "DataTable.HeaderRow";
+//#endregion
+export { DataTableHeaderRow };
+
+//# sourceMappingURL=data-table-header-row.js.map

package/dist/components/data-table/header/data-table-header-row.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-table-header-row.js","names":[],"sources":["../../../../src/components/data-table/header/data-table-header-row.tsx"],"sourcesContent":["import { mergeProps, useRender } from '@base-ui/react';\nimport { mergeTwClassNames } from '@lucasbernardosn/react-ui/utils';\nimport { DATA_TABLE_GRID_CLASS_NAMES } from '../root/data-table-grid-classes';\n\nexport type DataTableHeaderRowProps = useRender.ComponentProps<'div'>;\n\n/**\n * Uma linha de headers (`role=\"row\"`), por grupo de headers. É um grid com as colunas do\n * `--data-table-template`, que o `DataTable.Root` escreve.\n *\n * O `DataTable.Header` com render-prop já monta uma por grupo; use direto só no laço feito à mão.\n */\nexport const DataTableHeaderRow = (props: DataTableHeaderRowProps) => {\n  const { render, className, ...rest } = props;\n\n  const baseProps = {\n    'data-component': 'DataTable.HeaderRow',\n    role: 'row',\n    className: mergeTwClassNames(\n      [\n        // A linha horizontal fica também na última: entre os níveis de um cabeçalho agrupado e,\n        // na última, entre o cabeçalho e o corpo.\n        DATA_TABLE_GRID_CLASS_NAMES,\n      ],\n      className,\n    ),\n  };\n\n  return useRender({\n    render,\n    defaultTagName: 'div',\n    props: mergeProps(baseProps, rest),\n  });\n};\n\nDataTableHeaderRow.displayName = 'DataTable.HeaderRow';\n"],"mappings":";;;;;;;;;;AAYA,MAAa,sBAAsB,UAAmC;CACpE,MAAM,EAAE,QAAQ,WAAW,GAAG,SAAS;CAEvC,MAAM,YAAY;EAChB,kBAAkB;EAClB,MAAM;EACN,WAAW,kBACT,CAGE,2BACF,GACA,SACF;CACF;CAEA,OAAO,UAAU;EACf;EACA,gBAAgB;EAChB,OAAO,WAAW,WAAW,IAAI;CACnC,CAAC;AACH;AAEA,mBAAmB,cAAc"}

package/dist/components/data-table/header/data-table-header.d.ts

@@ -0,0 +1,46 @@
+import { Header, RowData, Table, TableFeatures } from "@tanstack/react-table";
+import { useRender } from "@base-ui/react";
+import React from "react";
+import { MergeOverride } from "@lucasbernardosn/utils";
+//#region src/components/data-table/header/data-table-header.d.ts
+export type DataTableHeaderProps<TFeatures extends TableFeatures, TData extends RowData> = MergeOverride<useRender.ComponentProps<'div'>, {
+  /** A tabela do `useTable`. */
+  table: Table<TFeatures, TData>;
+  /**
+   * Uma função que recebe cada header e devolve a célula dele: o `Header` monta uma
+   * `DataTable.HeaderRow` por grupo de headers e chama a função para cada header. Com nós
+   * comuns, quem usa faz o laço.
+   * @default (header) => <DataTable.HeaderCell header={header} />
+   */
+  children?: React.ReactNode | ((header: Header<TFeatures, TData>) => React.ReactNode);
+}>;
+/**
+ * O cabeçalho da tabela (`role="rowgroup"`), grudado no topo da área de rolagem.
+ *
+ * Com render-prop ou sem `children`, faz o laço sozinho: assina os grupos de headers e só
+ * re-renderiza quando a estrutura das colunas muda (`columns`, ordem, visibilidade, pinning),
+ * sem o dono da tabela precisar re-renderizar. Com nós comuns, o laço é de quem usa, e o dono
+ * precisa re-renderizar quando a estrutura muda.
+ *
+ * Com `columnPinningFeature`, monta as linhas com os grupos de cada região (as fixadas no início,
+ * o centro e as fixadas no fim): um grupo cujas colunas atravessam a fronteira da fixação vira um
+ * header em cada região, e a parte fixada gruda.
+ *
+ * @example
+ * ```tsx
+ * <DataTable.Header table={table}>
+ *   {(header) => (
+ *     <DataTable.HeaderCell header={header}>
+ *       <DataTable.HeaderContent header={header} />
+ *       <DataTable.ResizeHandle header={header} />
+ *     </DataTable.HeaderCell>
+ *   )}
+ * </DataTable.Header>
+ * ```
+ */
+export declare const DataTableHeader: {
+  <TFeatures extends TableFeatures, TData extends RowData>(props: DataTableHeaderProps<TFeatures, TData>): React.ReactElement<unknown, string | React.JSXElementConstructor<any>>;
+  displayName: string;
+};
+//#endregion
+//# sourceMappingURL=data-table-header.d.ts.map

package/dist/components/data-table/header/data-table-header.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-table-header.d.ts","names":[],"sources":["../../../../src/components/data-table/header/data-table-header.tsx"],"mappings":";;;;;YAgBY,qBACV,kBAAkB,eAClB,cAAc,WACZ,cACF,UAAU;;EAGR,OAAO,MAAM,WAAW;;;;;;;EAOxB,WACI,MAAM,cACJ,QAAQ,OAAO,WAAW,WAAW,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;qBA4BxC;GACX,kBAAkB,eAClB,cAAc,SAAO,OAEd,qBAAqB,WAAW,SAAM,MAAA,+BAAA,MAAA"}

package/dist/components/data-table/header/data-table-header.js

@@ -0,0 +1,80 @@
+import { hasTableFeature } from "../../../utils/has-feature.js";
+import { DataTableHeaderCell } from "./data-table-header-cell.js";
+import { DataTableHeaderRow } from "./data-table-header-row.js";
+import { jsx } from "react/jsx-runtime";
+import { mergeProps, useRender } from "@base-ui/react";
+import { shallow, useSelector } from "@tanstack/react-store";
+import { mergeTwClassNames } from "@lucasbernardosn/react-ui/utils";
+import { Fragment as Fragment$1 } from "react";
+//#region src/components/data-table/header/data-table-header.tsx
+/**
+* O cabeçalho da tabela (`role="rowgroup"`), grudado no topo da área de rolagem.
+*
+* Com render-prop ou sem `children`, faz o laço sozinho: assina os grupos de headers e só
+* re-renderiza quando a estrutura das colunas muda (`columns`, ordem, visibilidade, pinning),
+* sem o dono da tabela precisar re-renderizar. Com nós comuns, o laço é de quem usa, e o dono
+* precisa re-renderizar quando a estrutura muda.
+*
+* Com `columnPinningFeature`, monta as linhas com os grupos de cada região (as fixadas no início,
+* o centro e as fixadas no fim): um grupo cujas colunas atravessam a fronteira da fixação vira um
+* header em cada região, e a parte fixada gruda.
+*
+* @example
+* ```tsx
+* <DataTable.Header table={table}>
+*   {(header) => (
+*     <DataTable.HeaderCell header={header}>
+*       <DataTable.HeaderContent header={header} />
+*       <DataTable.ResizeHandle header={header} />
+*     </DataTable.HeaderCell>
+*   )}
+* </DataTable.Header>
+* ```
+*/
+const DataTableHeader = (props) => {
+	const { table, render, className, children, ...rest } = props;
+	/**
+	* Os grupos que o TanStack memoiza, numa tupla: o `shallow` compara item a item, e só
+	* re-renderiza quando a estrutura das colunas muda. Tamanho, ordenação e seleção mudam o store,
+	* mas não os grupos. Com pinning, os grupos de cada região: o de uma região só tem as colunas
+	* dela.
+	*/
+	const regionHeaderGroups = useSelector(table.store, () => hasTableFeature(table, "columnPinningFeature") ? [
+		table.getStartHeaderGroups(),
+		table.getCenterHeaderGroups(),
+		table.getEndHeaderGroups()
+	] : [table.getHeaderGroups()], { compare: shallow });
+	/**
+	* As linhas do cabeçalho, uma por profundidade, com os headers das regiões na ordem do
+	* template. Toda região tem o mesmo número de grupos, o da coluna mais funda.
+	*/
+	const headerRows = (regionHeaderGroups[0] ?? []).map((headerGroup) => ({
+		depth: headerGroup.depth,
+		headers: regionHeaderGroups.flatMap((headerGroups) => headerGroups[headerGroup.depth]?.headers ?? [])
+	}));
+	/**
+	* Com render-prop ou sem `children`, o laço é daqui, com uma `HeaderRow` por grupo; com nós
+	* comuns, de quem usa.
+	*/
+	const content = typeof children === "function" || children === void 0 ? headerRows.map((headerRow) => /* @__PURE__ */ jsx(DataTableHeaderRow, { children: headerRow.headers.map((header) => /* @__PURE__ */ jsx(Fragment$1, { children: children === void 0 ? /* @__PURE__ */ jsx(DataTableHeaderCell, { header }) : children(header) }, header.id)) }, headerRow.depth)) : children;
+	const baseProps = {
+		"data-component": "DataTable.Header",
+		role: "rowgroup",
+		className: mergeTwClassNames([
+			"sticky",
+			"top-0",
+			"z-10"
+		], className),
+		children: content
+	};
+	return useRender({
+		render,
+		defaultTagName: "div",
+		props: mergeProps(baseProps, rest)
+	});
+};
+DataTableHeader.displayName = "DataTable.Header";
+//#endregion
+export { DataTableHeader };
+
+//# sourceMappingURL=data-table-header.js.map

package/dist/components/data-table/header/data-table-header.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-table-header.js","names":["Fragment"],"sources":["../../../../src/components/data-table/header/data-table-header.tsx"],"sourcesContent":["import { mergeProps, useRender } from '@base-ui/react';\nimport { mergeTwClassNames } from '@lucasbernardosn/react-ui/utils';\nimport type { MergeOverride } from '@lucasbernardosn/utils';\nimport { shallow, useSelector } from '@tanstack/react-store';\nimport type {\n  Header,\n  RowData,\n  Table,\n  TableFeatures,\n} from '@tanstack/react-table';\nimport type React from 'react';\nimport { Fragment } from 'react';\nimport { hasTableFeature } from '../../../utils';\nimport { DataTableHeaderCell } from './data-table-header-cell';\nimport { DataTableHeaderRow } from './data-table-header-row';\n\nexport type DataTableHeaderProps<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n> = MergeOverride<\n  useRender.ComponentProps<'div'>,\n  {\n    /** A tabela do `useTable`. */\n    table: Table<TFeatures, TData>;\n    /**\n     * Uma função que recebe cada header e devolve a célula dele: o `Header` monta uma\n     * `DataTable.HeaderRow` por grupo de headers e chama a função para cada header. Com nós\n     * comuns, quem usa faz o laço.\n     * @default (header) => <DataTable.HeaderCell header={header} />\n     */\n    children?:\n      | React.ReactNode\n      | ((header: Header<TFeatures, TData>) => React.ReactNode);\n  }\n>;\n\n/**\n * O cabeçalho da tabela (`role=\"rowgroup\"`), grudado no topo da área de rolagem.\n *\n * Com render-prop ou sem `children`, faz o laço sozinho: assina os grupos de headers e só\n * re-renderiza quando a estrutura das colunas muda (`columns`, ordem, visibilidade, pinning),\n * sem o dono da tabela precisar re-renderizar. Com nós comuns, o laço é de quem usa, e o dono\n * precisa re-renderizar quando a estrutura muda.\n *\n * Com `columnPinningFeature`, monta as linhas com os grupos de cada região (as fixadas no início,\n * o centro e as fixadas no fim): um grupo cujas colunas atravessam a fronteira da fixação vira um\n * header em cada região, e a parte fixada gruda.\n *\n * @example\n * ```tsx\n * <DataTable.Header table={table}>\n *   {(header) => (\n *     <DataTable.HeaderCell header={header}>\n *       <DataTable.HeaderContent header={header} />\n *       <DataTable.ResizeHandle header={header} />\n *     </DataTable.HeaderCell>\n *   )}\n * </DataTable.Header>\n * ```\n */\nexport const DataTableHeader = <\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(\n  props: DataTableHeaderProps<TFeatures, TData>,\n) => {\n  const { table, render, className, children, ...rest } = props;\n\n  /**\n   * Os grupos que o TanStack memoiza, numa tupla: o `shallow` compara item a item, e só\n   * re-renderiza quando a estrutura das colunas muda. Tamanho, ordenação e seleção mudam o store,\n   * mas não os grupos. Com pinning, os grupos de cada região: o de uma região só tem as colunas\n   * dela.\n   */\n  const regionHeaderGroups = useSelector(\n    table.store,\n    () =>\n      hasTableFeature(table, 'columnPinningFeature')\n        ? [\n            table.getStartHeaderGroups(),\n            table.getCenterHeaderGroups(),\n            table.getEndHeaderGroups(),\n          ]\n        : [table.getHeaderGroups()],\n    { compare: shallow },\n  );\n\n  /**\n   * As linhas do cabeçalho, uma por profundidade, com os headers das regiões na ordem do\n   * template. Toda região tem o mesmo número de grupos, o da coluna mais funda.\n   */\n  const headerRows = (regionHeaderGroups[0] ?? []).map((headerGroup) => ({\n    depth: headerGroup.depth,\n    headers: regionHeaderGroups.flatMap(\n      (headerGroups) => headerGroups[headerGroup.depth]?.headers ?? [],\n    ),\n  }));\n\n  /**\n   * Com render-prop ou sem `children`, o laço é daqui, com uma `HeaderRow` por grupo; com nós\n   * comuns, de quem usa.\n   */\n  const content =\n    typeof children === 'function' || children === undefined\n      ? headerRows.map((headerRow) => (\n          <DataTableHeaderRow key={headerRow.depth}>\n            {headerRow.headers.map((header) => (\n              <Fragment key={header.id}>\n                {children === undefined ? (\n                  <DataTableHeaderCell header={header} />\n                ) : (\n                  children(header)\n                )}\n              </Fragment>\n            ))}\n          </DataTableHeaderRow>\n        ))\n      : children;\n\n  const baseProps = {\n    'data-component': 'DataTable.Header',\n    role: 'rowgroup',\n    className: mergeTwClassNames(\n      [\n        // Gruda no ancestral que rola, como o viewport do `DataTable.ScrollArea`.\n        'sticky',\n        'top-0',\n        'z-10',\n      ],\n      className,\n    ),\n    children: content,\n  };\n\n  return useRender({\n    render,\n    defaultTagName: 'div',\n    props: mergeProps(baseProps, rest),\n  });\n};\n\nDataTableHeader.displayName = 'DataTable.Header';\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4DA,MAAa,mBAIX,UACG;CACH,MAAM,EAAE,OAAO,QAAQ,WAAW,UAAU,GAAG,SAAS;;;;;;;CAQxD,MAAM,qBAAqB,YACzB,MAAM,aAEJ,gBAAgB,OAAO,sBAAsB,IACzC;EACE,MAAM,qBAAqB;EAC3B,MAAM,sBAAsB;EAC5B,MAAM,mBAAmB;CAC3B,IACA,CAAC,MAAM,gBAAgB,CAAC,GAC9B,EAAE,SAAS,QAAQ,CACrB;;;;;CAMA,MAAM,cAAc,mBAAmB,MAAM,CAAC,EAAA,CAAG,KAAK,iBAAiB;EACrE,OAAO,YAAY;EACnB,SAAS,mBAAmB,SACzB,iBAAiB,aAAa,YAAY,MAAM,EAAE,WAAW,CAAC,CACjE;CACF,EAAE;;;;;CAMF,MAAM,UACJ,OAAO,aAAa,cAAc,aAAa,KAAA,IAC3C,WAAW,KAAK,cACd,oBAAC,oBAAD,EAAA,UACG,UAAU,QAAQ,KAAK,WACtB,oBAACA,YAAD,EAAA,UACG,aAAa,KAAA,IACZ,oBAAC,qBAAD,EAA6B,OAAS,CAAA,IAEtC,SAAS,MAAM,EAET,GANK,OAAO,EAMZ,CACX,EACiB,GAVK,UAAU,KAUf,CACrB,IACD;CAEN,MAAM,YAAY;EAChB,kBAAkB;EAClB,MAAM;EACN,WAAW,kBACT;GAEE;GACA;GACA;EACF,GACA,SACF;EACA,UAAU;CACZ;CAEA,OAAO,UAAU;EACf;EACA,gBAAgB;EAChB,OAAO,WAAW,WAAW,IAAI;CACnC,CAAC;AACH;AAEA,gBAAgB,cAAc"}

package/dist/components/data-table/index.d.ts

@@ -0,0 +1,2 @@
+import { index_parts_d_exports } from "./index.parts.js";
+export { index_parts_d_exports as DataTable };

package/dist/components/data-table/index.js

@@ -0,0 +1,2 @@
+import { index_parts_exports } from "./index.parts.js";
+export { index_parts_exports as DataTable };

package/dist/components/data-table/index.parts.d.ts

@@ -0,0 +1,32 @@
+import { DataTableBody, DataTableBodyProps } from "./body/data-table-body.js";
+import { DataTableCell, DataTableCellProps } from "./body/data-table-cell.js";
+import { DataTableEmpty, DataTableEmptyProps } from "./body/data-table-empty.js";
+import { DataTableRow, DataTableRowProps } from "./body/data-table-row.js";
+import { DataTableHeaderButton, DataTableHeaderButtonProps } from "./header/data-table-header-button.js";
+import { DataTableHeaderCell, DataTableHeaderCellProps } from "./header/data-table-header-cell.js";
+import { DataTableHeaderContent, DataTableHeaderContentProps } from "./header/data-table-header-content.js";
+import { DataTableHeaderRow, DataTableHeaderRowProps } from "./header/data-table-header-row.js";
+import { DataTableHeader, DataTableHeaderProps } from "./header/data-table-header.js";
+import { DataTablePageButton, DataTablePageButtonPage, DataTablePageButtonProps } from "./pagination/data-table-page-button.js";
+import { DataTablePageSizeSelect, DataTablePageSizeSelectProps } from "./pagination/data-table-page-size-select.js";
+import { DataTablePageStatus, DataTablePageStatusProps, DataTablePageStatusValues } from "./pagination/data-table-page-status.js";
+import { DataTablePagination, DataTablePaginationProps } from "./pagination/data-table-pagination.js";
+import { DataTableRowRange, DataTableRowRangeProps, DataTableRowRangeValues } from "./pagination/data-table-row-range.js";
+import { DataTableSelectedCount, DataTableSelectedCountProps } from "./pagination/data-table-selected-count.js";
+import { DataTableResizeHandle, DataTableResizeHandleProps } from "./resize/data-table-resize-handle.js";
+import { DataTableRoot, DataTableRootProps } from "./root/data-table-root.js";
+import { DataTableScrollArea, DataTableScrollAreaProps } from "./root/data-table-scroll-area.js";
+import { DataTableRowCheckbox, DataTableRowCheckboxProps } from "./selection/data-table-row-checkbox.js";
+import { DataTableSelectAllCheckbox, DataTableSelectAllCheckboxProps } from "./selection/data-table-select-all-checkbox.js";
+import { SelectionColumnDefOptions, selectionColumnDef } from "./selection/selection-column-def.js";
+import { DataTableSortIndicator, DataTableSortIndicatorProps } from "./sorting/data-table-sort-indicator.js";
+import { DataTableSortTrigger, DataTableSortTriggerProps } from "./sorting/data-table-sort-trigger.js";
+import { DataTableDensitySelect, DataTableDensitySelectProps } from "./toolbar/data-table-density-select.js";
+import { DataTableSortColumnSelect, DataTableSortColumnSelectProps } from "./toolbar/data-table-sort-column-select.js";
+import { DataTableSortDirectionSelect, DataTableSortDirectionSelectProps } from "./toolbar/data-table-sort-direction-select.js";
+declare namespace index_parts_d_exports {
+  export { DataTableBody as Body, DataTableBodyProps as BodyProps, DataTableCell as Cell, DataTableCellProps as CellProps, DataTableDensitySelect as DensitySelect, DataTableDensitySelectProps as DensitySelectProps, DataTableEmpty as Empty, DataTableEmptyProps as EmptyProps, DataTableHeader as Header, DataTableHeaderButton as HeaderButton, DataTableHeaderButtonProps as HeaderButtonProps, DataTableHeaderCell as HeaderCell, DataTableHeaderCellProps as HeaderCellProps, DataTableHeaderContent as HeaderContent, DataTableHeaderContentProps as HeaderContentProps, DataTableHeaderProps as HeaderProps, DataTableHeaderRow as HeaderRow, DataTableHeaderRowProps as HeaderRowProps, DataTablePageButton as PageButton, DataTablePageButtonPage as PageButtonPage, DataTablePageButtonProps as PageButtonProps, DataTablePageSizeSelect as PageSizeSelect, DataTablePageSizeSelectProps as PageSizeSelectProps, DataTablePageStatus as PageStatus, DataTablePageStatusProps as PageStatusProps, DataTablePageStatusValues as PageStatusValues, DataTablePagination as Pagination, DataTablePaginationProps as PaginationProps, DataTableResizeHandle as ResizeHandle, DataTableResizeHandleProps as ResizeHandleProps, DataTableRoot as Root, DataTableRootProps as RootProps, DataTableRow as Row, DataTableRowCheckbox as RowCheckbox, DataTableRowCheckboxProps as RowCheckboxProps, DataTableRowProps as RowProps, DataTableRowRange as RowRange, DataTableRowRangeProps as RowRangeProps, DataTableRowRangeValues as RowRangeValues, DataTableScrollArea as ScrollArea, DataTableScrollAreaProps as ScrollAreaProps, DataTableSelectAllCheckbox as SelectAllCheckbox, DataTableSelectAllCheckboxProps as SelectAllCheckboxProps, DataTableSelectedCount as SelectedCount, DataTableSelectedCountProps as SelectedCountProps, SelectionColumnDefOptions, DataTableSortColumnSelect as SortColumnSelect, DataTableSortColumnSelectProps as SortColumnSelectProps, DataTableSortDirectionSelect as SortDirectionSelect, DataTableSortDirectionSelectProps as SortDirectionSelectProps, DataTableSortIndicator as SortIndicator, DataTableSortIndicatorProps as SortIndicatorProps, DataTableSortTrigger as SortTrigger, DataTableSortTriggerProps as SortTriggerProps, selectionColumnDef };
+}
+//#endregion
+export { DataTableBody as Body, type DataTableBodyProps as BodyProps, DataTableCell as Cell, type DataTableCellProps as CellProps, DataTableDensitySelect as DensitySelect, type DataTableDensitySelectProps as DensitySelectProps, DataTableEmpty as Empty, type DataTableEmptyProps as EmptyProps, DataTableHeader as Header, DataTableHeaderButton as HeaderButton, type DataTableHeaderButtonProps as HeaderButtonProps, DataTableHeaderCell as HeaderCell, type DataTableHeaderCellProps as HeaderCellProps, DataTableHeaderContent as HeaderContent, type DataTableHeaderContentProps as HeaderContentProps, type DataTableHeaderProps as HeaderProps, DataTableHeaderRow as HeaderRow, type DataTableHeaderRowProps as HeaderRowProps, DataTablePageButton as PageButton, type DataTablePageButtonPage as PageButtonPage, type DataTablePageButtonProps as PageButtonProps, DataTablePageSizeSelect as PageSizeSelect, type DataTablePageSizeSelectProps as PageSizeSelectProps, DataTablePageStatus as PageStatus, type DataTablePageStatusProps as PageStatusProps, type DataTablePageStatusValues as PageStatusValues, DataTablePagination as Pagination, type DataTablePaginationProps as PaginationProps, DataTableResizeHandle as ResizeHandle, type DataTableResizeHandleProps as ResizeHandleProps, DataTableRoot as Root, type DataTableRootProps as RootProps, DataTableRow as Row, DataTableRowCheckbox as RowCheckbox, type DataTableRowCheckboxProps as RowCheckboxProps, type DataTableRowProps as RowProps, DataTableRowRange as RowRange, type DataTableRowRangeProps as RowRangeProps, type DataTableRowRangeValues as RowRangeValues, DataTableScrollArea as ScrollArea, type DataTableScrollAreaProps as ScrollAreaProps, DataTableSelectAllCheckbox as SelectAllCheckbox, type DataTableSelectAllCheckboxProps as SelectAllCheckboxProps, DataTableSelectedCount as SelectedCount, type DataTableSelectedCountProps as SelectedCountProps, type SelectionColumnDefOptions, DataTableSortColumnSelect as SortColumnSelect, type DataTableSortColumnSelectProps as SortColumnSelectProps, DataTableSortDirectionSelect as SortDirectionSelect, type DataTableSortDirectionSelectProps as SortDirectionSelectProps, DataTableSortIndicator as SortIndicator, type DataTableSortIndicatorProps as SortIndicatorProps, DataTableSortTrigger as SortTrigger, type DataTableSortTriggerProps as SortTriggerProps, index_parts_d_exports, selectionColumnDef };
+//# sourceMappingURL=index.parts.d.ts.map

package/dist/components/data-table/index.parts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.parts.d.ts","names":[],"sources":["../../../src/components/data-table/index.parts.ts"],"mappings":""}

package/dist/components/data-table/index.parts.js

@@ -0,0 +1,60 @@
+import { __exportAll } from "../../_virtual/_rolldown/runtime.js";
+import { DataTableHeaderButton } from "./header/data-table-header-button.js";
+import { DataTableCell } from "./body/data-table-cell.js";
+import { DataTableRow } from "./body/data-table-row.js";
+import { DataTableBody } from "./body/data-table-body.js";
+import { DataTableEmpty } from "./body/data-table-empty.js";
+import { DataTableHeaderContent } from "./header/data-table-header-content.js";
+import { DataTableHeaderCell } from "./header/data-table-header-cell.js";
+import { DataTableHeaderRow } from "./header/data-table-header-row.js";
+import { DataTableHeader } from "./header/data-table-header.js";
+import { DataTablePageButton } from "./pagination/data-table-page-button.js";
+import { DataTablePageSizeSelect } from "./pagination/data-table-page-size-select.js";
+import { DataTablePageStatus } from "./pagination/data-table-page-status.js";
+import { DataTableRowRange } from "./pagination/data-table-row-range.js";
+import { DataTableSelectedCount } from "./pagination/data-table-selected-count.js";
+import { DataTablePagination } from "./pagination/data-table-pagination.js";
+import { DataTableResizeHandle } from "./resize/data-table-resize-handle.js";
+import { DataTableRoot } from "./root/data-table-root.js";
+import { DataTableScrollArea } from "./root/data-table-scroll-area.js";
+import { DataTableRowCheckbox } from "./selection/data-table-row-checkbox.js";
+import { DataTableSelectAllCheckbox } from "./selection/data-table-select-all-checkbox.js";
+import { selectionColumnDef } from "./selection/selection-column-def.js";
+import { DataTableSortIndicator } from "./sorting/data-table-sort-indicator.js";
+import { DataTableSortTrigger } from "./sorting/data-table-sort-trigger.js";
+import { DataTableDensitySelect } from "./toolbar/data-table-density-select.js";
+import { DataTableSortColumnSelect } from "./toolbar/data-table-sort-column-select.js";
+import { DataTableSortDirectionSelect } from "./toolbar/data-table-sort-direction-select.js";
+//#region src/components/data-table/index.parts.ts
+var index_parts_exports = /* @__PURE__ */ __exportAll({
+	Body: () => DataTableBody,
+	Cell: () => DataTableCell,
+	DensitySelect: () => DataTableDensitySelect,
+	Empty: () => DataTableEmpty,
+	Header: () => DataTableHeader,
+	HeaderButton: () => DataTableHeaderButton,
+	HeaderCell: () => DataTableHeaderCell,
+	HeaderContent: () => DataTableHeaderContent,
+	HeaderRow: () => DataTableHeaderRow,
+	PageButton: () => DataTablePageButton,
+	PageSizeSelect: () => DataTablePageSizeSelect,
+	PageStatus: () => DataTablePageStatus,
+	Pagination: () => DataTablePagination,
+	ResizeHandle: () => DataTableResizeHandle,
+	Root: () => DataTableRoot,
+	Row: () => DataTableRow,
+	RowCheckbox: () => DataTableRowCheckbox,
+	RowRange: () => DataTableRowRange,
+	ScrollArea: () => DataTableScrollArea,
+	SelectAllCheckbox: () => DataTableSelectAllCheckbox,
+	SelectedCount: () => DataTableSelectedCount,
+	SortColumnSelect: () => DataTableSortColumnSelect,
+	SortDirectionSelect: () => DataTableSortDirectionSelect,
+	SortIndicator: () => DataTableSortIndicator,
+	SortTrigger: () => DataTableSortTrigger,
+	selectionColumnDef: () => selectionColumnDef
+});
+//#endregion
+export { DataTableBody as Body, DataTableCell as Cell, DataTableDensitySelect as DensitySelect, DataTableEmpty as Empty, DataTableHeader as Header, DataTableHeaderButton as HeaderButton, DataTableHeaderCell as HeaderCell, DataTableHeaderContent as HeaderContent, DataTableHeaderRow as HeaderRow, DataTablePageButton as PageButton, DataTablePageSizeSelect as PageSizeSelect, DataTablePageStatus as PageStatus, DataTablePagination as Pagination, DataTableResizeHandle as ResizeHandle, DataTableRoot as Root, DataTableRow as Row, DataTableRowCheckbox as RowCheckbox, DataTableRowRange as RowRange, DataTableScrollArea as ScrollArea, DataTableSelectAllCheckbox as SelectAllCheckbox, DataTableSelectedCount as SelectedCount, DataTableSortColumnSelect as SortColumnSelect, DataTableSortDirectionSelect as SortDirectionSelect, DataTableSortIndicator as SortIndicator, DataTableSortTrigger as SortTrigger, index_parts_exports, selectionColumnDef };
+
+//# sourceMappingURL=index.parts.js.map

package/dist/components/data-table/index.parts.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.parts.js","names":[],"sources":["../../../src/components/data-table/index.parts.ts"],"sourcesContent":["export { DataTableBody as Body } from './body/data-table-body';\nexport { DataTableCell as Cell } from './body/data-table-cell';\nexport { DataTableEmpty as Empty } from './body/data-table-empty';\nexport { DataTableRow as Row } from './body/data-table-row';\nexport { DataTableHeader as Header } from './header/data-table-header';\nexport { DataTableHeaderButton as HeaderButton } from './header/data-table-header-button';\nexport { DataTableHeaderCell as HeaderCell } from './header/data-table-header-cell';\nexport { DataTableHeaderContent as HeaderContent } from './header/data-table-header-content';\nexport { DataTableHeaderRow as HeaderRow } from './header/data-table-header-row';\nexport { DataTablePageButton as PageButton } from './pagination/data-table-page-button';\nexport { DataTablePageSizeSelect as PageSizeSelect } from './pagination/data-table-page-size-select';\nexport { DataTablePageStatus as PageStatus } from './pagination/data-table-page-status';\nexport { DataTablePagination as Pagination } from './pagination/data-table-pagination';\nexport { DataTableRowRange as RowRange } from './pagination/data-table-row-range';\nexport { DataTableSelectedCount as SelectedCount } from './pagination/data-table-selected-count';\nexport { DataTableResizeHandle as ResizeHandle } from './resize/data-table-resize-handle';\nexport { DataTableRoot as Root } from './root/data-table-root';\nexport { DataTableScrollArea as ScrollArea } from './root/data-table-scroll-area';\nexport { DataTableRowCheckbox as RowCheckbox } from './selection/data-table-row-checkbox';\nexport { DataTableSelectAllCheckbox as SelectAllCheckbox } from './selection/data-table-select-all-checkbox';\nexport { selectionColumnDef } from './selection/selection-column-def';\nexport { DataTableSortIndicator as SortIndicator } from './sorting/data-table-sort-indicator';\nexport { DataTableSortTrigger as SortTrigger } from './sorting/data-table-sort-trigger';\nexport { DataTableDensitySelect as DensitySelect } from './toolbar/data-table-density-select';\nexport { DataTableSortColumnSelect as SortColumnSelect } from './toolbar/data-table-sort-column-select';\nexport { DataTableSortDirectionSelect as SortDirectionSelect } from './toolbar/data-table-sort-direction-select';\n\n/* types */\n\nexport type { DataTableBodyProps as BodyProps } from './body/data-table-body';\nexport type { DataTableCellProps as CellProps } from './body/data-table-cell';\nexport type { DataTableEmptyProps as EmptyProps } from './body/data-table-empty';\nexport type { DataTableRowProps as RowProps } from './body/data-table-row';\nexport type { DataTableHeaderProps as HeaderProps } from './header/data-table-header';\nexport type { DataTableHeaderButtonProps as HeaderButtonProps } from './header/data-table-header-button';\nexport type { DataTableHeaderCellProps as HeaderCellProps } from './header/data-table-header-cell';\nexport type { DataTableHeaderContentProps as HeaderContentProps } from './header/data-table-header-content';\nexport type { DataTableHeaderRowProps as HeaderRowProps } from './header/data-table-header-row';\nexport type {\n  DataTablePageButtonPage as PageButtonPage,\n  DataTablePageButtonProps as PageButtonProps,\n} from './pagination/data-table-page-button';\nexport type { DataTablePageSizeSelectProps as PageSizeSelectProps } from './pagination/data-table-page-size-select';\nexport type {\n  DataTablePageStatusProps as PageStatusProps,\n  DataTablePageStatusValues as PageStatusValues,\n} from './pagination/data-table-page-status';\nexport type { DataTablePaginationProps as PaginationProps } from './pagination/data-table-pagination';\nexport type {\n  DataTableRowRangeProps as RowRangeProps,\n  DataTableRowRangeValues as RowRangeValues,\n} from './pagination/data-table-row-range';\nexport type { DataTableSelectedCountProps as SelectedCountProps } from './pagination/data-table-selected-count';\nexport type { DataTableResizeHandleProps as ResizeHandleProps } from './resize/data-table-resize-handle';\nexport type { DataTableRootProps as RootProps } from './root/data-table-root';\nexport type { DataTableScrollAreaProps as ScrollAreaProps } from './root/data-table-scroll-area';\nexport type { DataTableRowCheckboxProps as RowCheckboxProps } from './selection/data-table-row-checkbox';\nexport type { DataTableSelectAllCheckboxProps as SelectAllCheckboxProps } from './selection/data-table-select-all-checkbox';\nexport type { SelectionColumnDefOptions } from './selection/selection-column-def';\nexport type { DataTableSortIndicatorProps as SortIndicatorProps } from './sorting/data-table-sort-indicator';\nexport type { DataTableSortTriggerProps as SortTriggerProps } from './sorting/data-table-sort-trigger';\nexport type { DataTableDensitySelectProps as DensitySelectProps } from './toolbar/data-table-density-select';\nexport type { DataTableSortColumnSelectProps as SortColumnSelectProps } from './toolbar/data-table-sort-column-select';\nexport type { DataTableSortDirectionSelectProps as SortDirectionSelectProps } from './toolbar/data-table-sort-direction-select';\n"],"mappings":""}

package/dist/components/data-table/loading/get-data-table-loading-without-rows.d.ts

@@ -0,0 +1,16 @@
+import { RowData, Table, TableFeatures } from "@tanstack/react-table";
+//#region src/components/data-table/loading/get-data-table-loading-without-rows.d.ts
+/**
+ * Se a tabela carrega sem nenhuma linha, como na primeira carga: o corpo mostra as
+ * linhas-fantasma, e a barra da paginação, sem o total, que ainda não chegou. Sem
+ * `loadingFeature`, `false`.
+ *
+ * @example
+ * ```ts
+ * // Primeira carga da API: `isLoading: true` e `data: []`.
+ * getDataTableLoadingWithoutRows(table); // → true
+ * ```
+ */
+export declare const getDataTableLoadingWithoutRows: <TFeatures extends TableFeatures, TData extends RowData>(table: Table<TFeatures, TData>) => boolean;
+//#endregion
+//# sourceMappingURL=get-data-table-loading-without-rows.d.ts.map

package/dist/components/data-table/loading/get-data-table-loading-without-rows.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-data-table-loading-without-rows.d.ts","names":[],"sources":["../../../../src/components/data-table/loading/get-data-table-loading-without-rows.ts"],"mappings":";;;;;;;;;;;;;qBAca,iCACX,kBAAkB,eAClB,cAAc,SAEd,OAAO,MAAM,WAAW"}

package/dist/components/data-table/loading/get-data-table-loading-without-rows.js

@@ -0,0 +1,18 @@
+import { hasTableFeature } from "../../../utils/has-feature.js";
+//#region src/components/data-table/loading/get-data-table-loading-without-rows.ts
+/**
+* Se a tabela carrega sem nenhuma linha, como na primeira carga: o corpo mostra as
+* linhas-fantasma, e a barra da paginação, sem o total, que ainda não chegou. Sem
+* `loadingFeature`, `false`.
+*
+* @example
+* ```ts
+* // Primeira carga da API: `isLoading: true` e `data: []`.
+* getDataTableLoadingWithoutRows(table); // → true
+* ```
+*/
+const getDataTableLoadingWithoutRows = (table) => hasTableFeature(table, "loadingFeature") && table.atoms.isLoading.get() && table.getRowModel().rows.length === 0;
+//#endregion
+export { getDataTableLoadingWithoutRows };
+
+//# sourceMappingURL=get-data-table-loading-without-rows.js.map

package/dist/components/data-table/loading/get-data-table-loading-without-rows.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-data-table-loading-without-rows.js","names":[],"sources":["../../../../src/components/data-table/loading/get-data-table-loading-without-rows.ts"],"sourcesContent":["import type { RowData, Table, TableFeatures } from '@tanstack/react-table';\nimport { hasTableFeature } from '../../../utils';\n\n/**\n * Se a tabela carrega sem nenhuma linha, como na primeira carga: o corpo mostra as\n * linhas-fantasma, e a barra da paginação, sem o total, que ainda não chegou. Sem\n * `loadingFeature`, `false`.\n *\n * @example\n * ```ts\n * // Primeira carga da API: `isLoading: true` e `data: []`.\n * getDataTableLoadingWithoutRows(table); // → true\n * ```\n */\nexport const getDataTableLoadingWithoutRows = <\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(\n  table: Table<TFeatures, TData>,\n) =>\n  hasTableFeature(table, 'loadingFeature') &&\n  table.atoms.isLoading.get() &&\n  table.getRowModel().rows.length === 0;\n"],"mappings":";;;;;;;;;;;;;AAcA,MAAa,kCAIX,UAEA,gBAAgB,OAAO,gBAAgB,KACvC,MAAM,MAAM,UAAU,IAAI,KAC1B,MAAM,YAAY,CAAC,CAAC,KAAK,WAAW"}

package/dist/components/data-table/loading/use-data-table-loading-inert.d.ts

@@ -0,0 +1,16 @@
+import { RowData, Table, TableFeatures } from "@tanstack/react-table";
+import React from "react";
+//#region src/components/data-table/loading/use-data-table-loading-inert.d.ts
+/**
+ * Bloqueia o corpo (`inert`) enquanto a tabela carrega, com `loadingFeature`: um clique, o Enter
+ * ou o Delete agiriam sobre o dado antigo. O cabeçalho e a paginação ficam livres.
+ *
+ * O `inert` tira o foco de uma linha. Se o foco estava no corpo quando a carga começou, ele volta
+ * quando ela termina: para a linha ativa, se ela continua na tela, ou para a primeira.
+ *
+ * Assina o store fora do React, como as variáveis das colunas: o atributo muda sem re-renderizar
+ * o corpo, que recriaria todas as linhas.
+ */
+export declare const useDataTableLoadingInert: <TFeatures extends TableFeatures, TData extends RowData>(table: Table<TFeatures, TData>, ref: React.RefObject<HTMLElement | null>) => void;
+//#endregion
+//# sourceMappingURL=use-data-table-loading-inert.d.ts.map

package/dist/components/data-table/loading/use-data-table-loading-inert.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-data-table-loading-inert.d.ts","names":[],"sources":["../../../../src/components/data-table/loading/use-data-table-loading-inert.ts"],"mappings":";;;;;;;;;;;;;qBAmBa,2BACX,kBAAkB,eAClB,cAAc,SAEd,OAAO,MAAM,WAAW,QACxB,KAAK,MAAM,UAAU"}

package/dist/components/data-table/loading/use-data-table-loading-inert.js

@@ -0,0 +1,54 @@
+import { hasTableFeature } from "../../../utils/has-feature.js";
+import { focusDataTableRow, getDataTableRowElements } from "../body/data-table-row-focus.js";
+import { useLayoutEffect, useRef } from "react";
+//#region src/components/data-table/loading/use-data-table-loading-inert.ts
+/**
+* Bloqueia o corpo (`inert`) enquanto a tabela carrega, com `loadingFeature`: um clique, o Enter
+* ou o Delete agiriam sobre o dado antigo. O cabeçalho e a paginação ficam livres.
+*
+* O `inert` tira o foco de uma linha. Se o foco estava no corpo quando a carga começou, ele volta
+* quando ela termina: para a linha ativa, se ela continua na tela, ou para a primeira.
+*
+* Assina o store fora do React, como as variáveis das colunas: o atributo muda sem re-renderizar
+* o corpo, que recriaria todas as linhas.
+*/
+const useDataTableLoadingInert = (table, ref) => {
+	/** A tabela do último render, lida por ref para não refazer a assinatura a cada render. */
+	const tableRef = useRef(table);
+	useLayoutEffect(() => {
+		tableRef.current = table;
+	});
+	useLayoutEffect(() => {
+		/** Se o foco estava no corpo quando a carga começou. */
+		let wasFocusInside = false;
+		const syncInert = () => {
+			const element = ref.current;
+			const currentTable = tableRef.current;
+			if (!element) return;
+			const isLoading = hasTableFeature(currentTable, "loadingFeature") && currentTable.atoms.isLoading.get();
+			if (isLoading === element.hasAttribute("inert")) return;
+			if (isLoading) {
+				wasFocusInside = element.contains(document.activeElement);
+				element.setAttribute("inert", "");
+				return;
+			}
+			element.removeAttribute("inert");
+			if (!wasFocusInside) return;
+			wasFocusInside = false;
+			/** No próximo quadro, com as linhas novas já no DOM. */
+			requestAnimationFrame(() => {
+				const { activeElement } = document;
+				if (activeElement && activeElement !== document.body) return;
+				const targetRow = element.querySelector("[role=\"row\"][data-active]") ?? getDataTableRowElements(element)[0];
+				if (targetRow) focusDataTableRow(targetRow);
+			});
+		};
+		syncInert();
+		const subscription = table.store.subscribe(syncInert);
+		return () => subscription.unsubscribe();
+	}, [table.store, ref]);
+};
+//#endregion
+export { useDataTableLoadingInert };
+
+//# sourceMappingURL=use-data-table-loading-inert.js.map

package/dist/components/data-table/loading/use-data-table-loading-inert.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-data-table-loading-inert.js","names":[],"sources":["../../../../src/components/data-table/loading/use-data-table-loading-inert.ts"],"sourcesContent":["import type { RowData, Table, TableFeatures } from '@tanstack/react-table';\nimport type React from 'react';\nimport { useLayoutEffect, useRef } from 'react';\nimport { hasTableFeature } from '../../../utils';\nimport {\n  focusDataTableRow,\n  getDataTableRowElements,\n} from '../body/data-table-row-focus';\n\n/**\n * Bloqueia o corpo (`inert`) enquanto a tabela carrega, com `loadingFeature`: um clique, o Enter\n * ou o Delete agiriam sobre o dado antigo. O cabeçalho e a paginação ficam livres.\n *\n * O `inert` tira o foco de uma linha. Se o foco estava no corpo quando a carga começou, ele volta\n * quando ela termina: para a linha ativa, se ela continua na tela, ou para a primeira.\n *\n * Assina o store fora do React, como as variáveis das colunas: o atributo muda sem re-renderizar\n * o corpo, que recriaria todas as linhas.\n */\nexport const useDataTableLoadingInert = <\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(\n  table: Table<TFeatures, TData>,\n  ref: React.RefObject<HTMLElement | null>,\n) => {\n  /** A tabela do último render, lida por ref para não refazer a assinatura a cada render. */\n  const tableRef = useRef(table);\n\n  useLayoutEffect(() => {\n    tableRef.current = table;\n  });\n\n  useLayoutEffect(() => {\n    /** Se o foco estava no corpo quando a carga começou. */\n    let wasFocusInside = false;\n\n    const syncInert = () => {\n      const element = ref.current;\n      const currentTable = tableRef.current;\n\n      if (!element) {\n        return;\n      }\n\n      const isLoading =\n        hasTableFeature(currentTable, 'loadingFeature') &&\n        currentTable.atoms.isLoading.get();\n\n      if (isLoading === element.hasAttribute('inert')) {\n        return;\n      }\n\n      if (isLoading) {\n        wasFocusInside = element.contains(document.activeElement);\n        element.setAttribute('inert', '');\n\n        return;\n      }\n\n      element.removeAttribute('inert');\n\n      if (!wasFocusInside) {\n        return;\n      }\n\n      wasFocusInside = false;\n\n      /** No próximo quadro, com as linhas novas já no DOM. */\n      requestAnimationFrame(() => {\n        const { activeElement } = document;\n\n        if (activeElement && activeElement !== document.body) {\n          return;\n        }\n\n        const targetRow =\n          element.querySelector<HTMLElement>('[role=\"row\"][data-active]') ??\n          getDataTableRowElements(element)[0];\n\n        if (targetRow) {\n          focusDataTableRow(targetRow);\n        }\n      });\n    };\n\n    syncInert();\n\n    const subscription = table.store.subscribe(syncInert);\n\n    return () => subscription.unsubscribe();\n  }, [table.store, ref]);\n};\n"],"mappings":";;;;;;;;;;;;;;AAmBA,MAAa,4BAIX,OACA,QACG;;CAEH,MAAM,WAAW,OAAO,KAAK;CAE7B,sBAAsB;EACpB,SAAS,UAAU;CACrB,CAAC;CAED,sBAAsB;;EAEpB,IAAI,iBAAiB;EAErB,MAAM,kBAAkB;GACtB,MAAM,UAAU,IAAI;GACpB,MAAM,eAAe,SAAS;GAE9B,IAAI,CAAC,SACH;GAGF,MAAM,YACJ,gBAAgB,cAAc,gBAAgB,KAC9C,aAAa,MAAM,UAAU,IAAI;GAEnC,IAAI,cAAc,QAAQ,aAAa,OAAO,GAC5C;GAGF,IAAI,WAAW;IACb,iBAAiB,QAAQ,SAAS,SAAS,aAAa;IACxD,QAAQ,aAAa,SAAS,EAAE;IAEhC;GACF;GAEA,QAAQ,gBAAgB,OAAO;GAE/B,IAAI,CAAC,gBACH;GAGF,iBAAiB;;GAGjB,4BAA4B;IAC1B,MAAM,EAAE,kBAAkB;IAE1B,IAAI,iBAAiB,kBAAkB,SAAS,MAC9C;IAGF,MAAM,YACJ,QAAQ,cAA2B,6BAA2B,KAC9D,wBAAwB,OAAO,CAAC,CAAC;IAEnC,IAAI,WACF,kBAAkB,SAAS;GAE/B,CAAC;EACH;EAEA,UAAU;EAEV,MAAM,eAAe,MAAM,MAAM,UAAU,SAAS;EAEpD,aAAa,aAAa,YAAY;CACxC,GAAG,CAAC,MAAM,OAAO,GAAG,CAAC;AACvB"}

package/dist/components/data-table/loading/use-data-table-loading.d.ts

@@ -0,0 +1,13 @@
+import { RowData, Table, TableFeatures } from "@tanstack/react-table";
+//#region src/components/data-table/loading/use-data-table-loading.d.ts
+/**
+ * O carregamento da tabela, de `loadingFeature`: `isLoading` na hora, para o `aria-busy`, e
+ * `isLoadingVisible` depois de 200ms, para o que aparece na tela. Sem a feature, os dois ficam
+ * `false`.
+ */
+export declare const useDataTableLoading: <TFeatures extends TableFeatures, TData extends RowData>(table: Table<TFeatures, TData>) => {
+  isLoading: boolean;
+  isLoadingVisible: boolean;
+};
+//#endregion
+//# sourceMappingURL=use-data-table-loading.d.ts.map

package/dist/components/data-table/loading/use-data-table-loading.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-data-table-loading.d.ts","names":[],"sources":["../../../../src/components/data-table/loading/use-data-table-loading.ts"],"mappings":";;;;;;;qBAgBa,sBACX,kBAAkB,eAClB,cAAc,SAEd,OAAO,MAAM,WAAW"}

package/dist/components/data-table/loading/use-data-table-loading.js

@@ -0,0 +1,40 @@
+import { hasTableFeature } from "../../../utils/has-feature.js";
+import { useSelector } from "@tanstack/react-store";
+import { useEffect, useState } from "react";
+//#region src/components/data-table/loading/use-data-table-loading.ts
+/**
+* Quanto o carregamento espera antes de aparecer. Uma resposta mais rápida que isto não mostra
+* nada: o skeleton ou a barra piscariam e sumiriam, o que incomoda mais do que ajuda.
+*/
+const LOADING_VISIBLE_DELAY = 200;
+/**
+* O carregamento da tabela, de `loadingFeature`: `isLoading` na hora, para o `aria-busy`, e
+* `isLoadingVisible` depois de 200ms, para o que aparece na tela. Sem a feature, os dois ficam
+* `false`.
+*/
+const useDataTableLoading = (table) => {
+	/** Re-renderiza quando o carregamento liga ou desliga. A feature é opcional: assina o store. */
+	const isLoading = useSelector(table.store, () => hasTableFeature(table, "loadingFeature") && table.atoms.isLoading.get());
+	/** Se a carga atual já passou do atraso. Volta a `false` no fim dela, para a próxima esperar. */
+	const [isDelayElapsed, setIsDelayElapsed] = useState(false);
+	useEffect(() => {
+		if (!isLoading) return;
+		const timeout = setTimeout(() => setIsDelayElapsed(true), LOADING_VISIBLE_DELAY);
+		return () => {
+			clearTimeout(timeout);
+			setIsDelayElapsed(false);
+		};
+	}, [isLoading]);
+	/**
+	* Derivado, e não guardado: desliga no mesmo render em que a carga termina, e o conteúdo novo
+	* não espera o efeito.
+	*/
+	return {
+		isLoading,
+		isLoadingVisible: isLoading && isDelayElapsed
+	};
+};
+//#endregion
+export { useDataTableLoading };
+
+//# sourceMappingURL=use-data-table-loading.js.map

package/dist/components/data-table/loading/use-data-table-loading.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-data-table-loading.js","names":[],"sources":["../../../../src/components/data-table/loading/use-data-table-loading.ts"],"sourcesContent":["import { useSelector } from '@tanstack/react-store';\nimport type { RowData, Table, TableFeatures } from '@tanstack/react-table';\nimport { useEffect, useState } from 'react';\nimport { hasTableFeature } from '../../../utils';\n\n/**\n * Quanto o carregamento espera antes de aparecer. Uma resposta mais rápida que isto não mostra\n * nada: o skeleton ou a barra piscariam e sumiriam, o que incomoda mais do que ajuda.\n */\nconst LOADING_VISIBLE_DELAY = 200;\n\n/**\n * O carregamento da tabela, de `loadingFeature`: `isLoading` na hora, para o `aria-busy`, e\n * `isLoadingVisible` depois de 200ms, para o que aparece na tela. Sem a feature, os dois ficam\n * `false`.\n */\nexport const useDataTableLoading = <\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(\n  table: Table<TFeatures, TData>,\n) => {\n  /** Re-renderiza quando o carregamento liga ou desliga. A feature é opcional: assina o store. */\n  const isLoading = useSelector(\n    table.store,\n    () =>\n      hasTableFeature(table, 'loadingFeature') && table.atoms.isLoading.get(),\n  );\n\n  /** Se a carga atual já passou do atraso. Volta a `false` no fim dela, para a próxima esperar. */\n  const [isDelayElapsed, setIsDelayElapsed] = useState(false);\n\n  useEffect(() => {\n    if (!isLoading) {\n      return;\n    }\n\n    const timeout = setTimeout(\n      () => setIsDelayElapsed(true),\n      LOADING_VISIBLE_DELAY,\n    );\n\n    return () => {\n      clearTimeout(timeout);\n      setIsDelayElapsed(false);\n    };\n  }, [isLoading]);\n\n  /**\n   * Derivado, e não guardado: desliga no mesmo render em que a carga termina, e o conteúdo novo\n   * não espera o efeito.\n   */\n  return { isLoading, isLoadingVisible: isLoading && isDelayElapsed };\n};\n"],"mappings":";;;;;;;;AASA,MAAM,wBAAwB;;;;;;AAO9B,MAAa,uBAIX,UACG;;CAEH,MAAM,YAAY,YAChB,MAAM,aAEJ,gBAAgB,OAAO,gBAAgB,KAAK,MAAM,MAAM,UAAU,IAAI,CAC1E;;CAGA,MAAM,CAAC,gBAAgB,qBAAqB,SAAS,KAAK;CAE1D,gBAAgB;EACd,IAAI,CAAC,WACH;EAGF,MAAM,UAAU,iBACR,kBAAkB,IAAI,GAC5B,qBACF;EAEA,aAAa;GACX,aAAa,OAAO;GACpB,kBAAkB,KAAK;EACzB;CACF,GAAG,CAAC,SAAS,CAAC;;;;;CAMd,OAAO;EAAE;EAAW,kBAAkB,aAAa;CAAe;AACpE"}

package/dist/components/data-table/pagination/data-table-page-button.d.ts

@@ -0,0 +1,45 @@
+import { TableWith } from "../../../types/table-with.js";
+import "../../../types/index.js";
+import { RowData, TableFeatures } from "@tanstack/react-table";
+import { IconButtonProps } from "@lucasbernardosn/react-ui/buttons/icon-button";
+import { MergeOverride } from "@lucasbernardosn/utils";
+//#region src/components/data-table/pagination/data-table-page-button.d.ts
+/** Para onde o botão leva. */
+export type DataTablePageButtonPage = 'first' | 'previous' | 'next' | 'last';
+export type DataTablePageButtonProps<TFeatures extends TableFeatures, TData extends RowData> = MergeOverride<Omit<IconButtonProps, 'icon' | 'aria-label'>, {
+  /** A tabela. Exige `rowPaginationFeature`. */
+  table: TableWith<TFeatures, TData, 'rowPaginationFeature'>;
+  /** Para onde o botão leva: a primeira página, a anterior, a próxima ou a última. */
+  page: DataTablePageButtonPage;
+  /**
+   * O ícone.
+   * @default um caret por página: duplo nas pontas, simples na anterior e na próxima
+   */
+  icon?: IconButtonProps['icon'];
+  /**
+   * O que o botão faz.
+   * @default 'Primeira página', 'Página anterior', 'Próxima página' ou 'Última página'
+   */
+  'aria-label'?: string;
+}>;
+/**
+ * O botão que leva a outra página: a primeira, a anterior, a próxima ou a última. Fica
+ * desabilitado quando não há para onde ir. Sem o total de páginas (`pageCount: -1` na paginação
+ * pela API), a próxima continua habilitada, e a última, não.
+ *
+ * As props do `IconButton` passam adiante, como `variant` e `size`.
+ *
+ * @example
+ * ```tsx
+ * <DataTable.PageButton
+ *   table={table}
+ *   page="next"
+ * />
+ * ```
+ */
+export declare const DataTablePageButton: {
+  <TFeatures extends TableFeatures, TData extends RowData>(props: DataTablePageButtonProps<TFeatures, TData>): import("react").JSX.Element;
+  displayName: string;
+};
+//#endregion
+//# sourceMappingURL=data-table-page-button.d.ts.map

package/dist/components/data-table/pagination/data-table-page-button.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-table-page-button.d.ts","names":[],"sources":["../../../../src/components/data-table/pagination/data-table-page-button.tsx"],"mappings":";;;;;;;YAgBY;YAEA,yBACV,kBAAkB,eAClB,cAAc,WACZ,cACF,KAAK;;EAGH,OAAO,UAAU,WAAW;;EAE5B,MAAM;;;;;EAKN,OAAO;;;;;EAKP;;;;;;;;;;;;;;;;;qBAiCS;GACX,kBAAkB,eAClB,cAAc,SAAO,OAEd,yBAAyB,WAAW,yBAAM,IAAA"}