@lucasbernardosn/react-table 0.0.0-stage → 0.1.0

package/dist/features/index.js

@@ -0,0 +1,5 @@
+import { activeRowFeature } from "./active-row/active-row-feature.js";
+import { columnAlignmentFeature } from "./column-alignment/column-alignment-feature.js";
+import { loadingFeature } from "./loading/loading-feature.js";
+import { rowDensityFeature } from "./row-density/row-density-feature.js";
+export { activeRowFeature, columnAlignmentFeature, loadingFeature, rowDensityFeature };

package/dist/features/loading/loading-feature.d.ts

@@ -0,0 +1,30 @@
+import { TableFeature } from "@tanstack/react-table";
+//#region src/features/loading/loading-feature.d.ts
+/**
+ * Feature do TanStack Table para o carregamento dos dados. Registre com essa chave:
+ * `tableFeatures({ loadingFeature })`.
+ *
+ * Só guarda o estado: o `DataTable.Root` marca o grid enquanto carrega, o `DataTable.Body`
+ * bloqueia as linhas e, sem linhas, desenha linhas-fantasma.
+ *
+ * Carregar é ter na tela linhas que não são as da consulta atual: as de outra página ou ordem,
+ * à espera das novas, ou nenhuma na primeira carga. Uma busca em segundo plano que só confirma
+ * o que já está na tela não conta: marcá-la cobriria com o skeleton as linhas certas. No
+ * TanStack Query, com `placeholderData: keepPreviousData`, isso é `isPending || isPlaceholderData`,
+ * e não `isFetching`.
+ *
+ * @example
+ * ```ts
+ * const features = tableFeatures({ columnSizingFeature, loadingFeature });
+ *
+ * const table = useTable({
+ *   features,
+ *   columns,
+ *   data: query.data ?? [],
+ *   state: { isLoading: query.isPending || query.isPlaceholderData },
+ * });
+ * ```
+ */
+export declare const loadingFeature: TableFeature;
+//#endregion
+//# sourceMappingURL=loading-feature.d.ts.map

package/dist/features/loading/loading-feature.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loading-feature.d.ts","names":[],"sources":["../../../src/features/loading/loading-feature.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;qBAyCa,gBAAgB"}

package/dist/features/loading/loading-feature.js

@@ -0,0 +1,48 @@
+import { assignTableAPIs, makeStateUpdater, setStateSlice } from "@tanstack/react-table";
+//#region src/features/loading/loading-feature.ts
+/** O carregamento sem `initialState`. */
+const DEFAULT_IS_LOADING = false;
+/** O carregamento de um estado inicial, ou o padrão quando ele não traz. */
+const getInitialIsLoading = (initialState) => initialState.isLoading ?? DEFAULT_IS_LOADING;
+/**
+* Feature do TanStack Table para o carregamento dos dados. Registre com essa chave:
+* `tableFeatures({ loadingFeature })`.
+*
+* Só guarda o estado: o `DataTable.Root` marca o grid enquanto carrega, o `DataTable.Body`
+* bloqueia as linhas e, sem linhas, desenha linhas-fantasma.
+*
+* Carregar é ter na tela linhas que não são as da consulta atual: as de outra página ou ordem,
+* à espera das novas, ou nenhuma na primeira carga. Uma busca em segundo plano que só confirma
+* o que já está na tela não conta: marcá-la cobriria com o skeleton as linhas certas. No
+* TanStack Query, com `placeholderData: keepPreviousData`, isso é `isPending || isPlaceholderData`,
+* e não `isFetching`.
+*
+* @example
+* ```ts
+* const features = tableFeatures({ columnSizingFeature, loadingFeature });
+*
+* const table = useTable({
+*   features,
+*   columns,
+*   data: query.data ?? [],
+*   state: { isLoading: query.isPending || query.isPlaceholderData },
+* });
+* ```
+*/
+const loadingFeature = {
+	getInitialState: (initialState) => ({
+		isLoading: DEFAULT_IS_LOADING,
+		...initialState
+	}),
+	getDefaultTableOptions: (table) => ({ onIsLoadingChange: makeStateUpdater("isLoading", table) }),
+	constructTableAPIs: (table) => {
+		assignTableAPIs("loadingFeature", table, {
+			table_setIsLoading: { fn: (updater) => setStateSlice(table, "isLoading", updater) },
+			table_resetIsLoading: { fn: (defaultState) => setStateSlice(table, "isLoading", defaultState ? DEFAULT_IS_LOADING : getInitialIsLoading(table.initialState)) }
+		});
+	}
+};
+//#endregion
+export { loadingFeature };
+
+//# sourceMappingURL=loading-feature.js.map

package/dist/features/loading/loading-feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"loading-feature.js","names":[],"sources":["../../../src/features/loading/loading-feature.ts"],"sourcesContent":["import {\n  assignTableAPIs,\n  makeStateUpdater,\n  setStateSlice,\n  type TableFeature,\n  type TableState_All,\n  type Updater,\n} from '@tanstack/react-table';\n\n/** O carregamento sem `initialState`. */\nconst DEFAULT_IS_LOADING = false;\n\n/** O carregamento de um estado inicial, ou o padrão quando ele não traz. */\nconst getInitialIsLoading = (initialState: Partial<TableState_All>) =>\n  initialState.isLoading ?? DEFAULT_IS_LOADING;\n\n/**\n * Feature do TanStack Table para o carregamento dos dados. Registre com essa chave:\n * `tableFeatures({ loadingFeature })`.\n *\n * Só guarda o estado: o `DataTable.Root` marca o grid enquanto carrega, o `DataTable.Body`\n * bloqueia as linhas e, sem linhas, desenha linhas-fantasma.\n *\n * Carregar é ter na tela linhas que não são as da consulta atual: as de outra página ou ordem,\n * à espera das novas, ou nenhuma na primeira carga. Uma busca em segundo plano que só confirma\n * o que já está na tela não conta: marcá-la cobriria com o skeleton as linhas certas. No\n * TanStack Query, com `placeholderData: keepPreviousData`, isso é `isPending || isPlaceholderData`,\n * e não `isFetching`.\n *\n * @example\n * ```ts\n * const features = tableFeatures({ columnSizingFeature, loadingFeature });\n *\n * const table = useTable({\n *   features,\n *   columns,\n *   data: query.data ?? [],\n *   state: { isLoading: query.isPending || query.isPlaceholderData },\n * });\n * ```\n */\nexport const loadingFeature: TableFeature = {\n  getInitialState: (initialState) => ({\n    isLoading: DEFAULT_IS_LOADING,\n    ...initialState,\n  }),\n\n  getDefaultTableOptions: (table) => ({\n    onIsLoadingChange: makeStateUpdater('isLoading', table),\n  }),\n\n  constructTableAPIs: (table) => {\n    assignTableAPIs('loadingFeature', table, {\n      table_setIsLoading: {\n        fn: (updater: Updater<boolean>) =>\n          setStateSlice(table, 'isLoading', updater),\n      },\n      table_resetIsLoading: {\n        fn: (defaultState?: boolean) =>\n          setStateSlice(\n            table,\n            'isLoading',\n            defaultState\n              ? DEFAULT_IS_LOADING\n              : getInitialIsLoading(table.initialState),\n          ),\n      },\n    });\n  },\n};\n"],"mappings":";;;AAUA,MAAM,qBAAqB;;AAG3B,MAAM,uBAAuB,iBAC3B,aAAa,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;AA2B5B,MAAa,iBAA+B;CAC1C,kBAAkB,kBAAkB;EAClC,WAAW;EACX,GAAG;CACL;CAEA,yBAAyB,WAAW,EAClC,mBAAmB,iBAAiB,aAAa,KAAK,EACxD;CAEA,qBAAqB,UAAU;EAC7B,gBAAgB,kBAAkB,OAAO;GACvC,oBAAoB,EAClB,KAAK,YACH,cAAc,OAAO,aAAa,OAAO,EAC7C;GACA,sBAAsB,EACpB,KAAK,iBACH,cACE,OACA,aACA,eACI,qBACA,oBAAoB,MAAM,YAAY,CAC5C,EACJ;EACF,CAAC;CACH;AACF"}

package/dist/features/loading/loading-feature.types.d.ts

@@ -0,0 +1,50 @@
+import { OnChangeFn, RowData, TableFeature, TableFeatures, Updater } from "@tanstack/react-table";
+//#region src/features/loading/loading-feature.types.d.ts
+/** O estado da feature. */
+export type TableState_Loading = {
+  /**
+   * Se os dados da tabela estão carregando.
+   * @default false
+   */
+  isLoading: boolean;
+};
+/** As opções da feature. */
+export type TableOptions_Loading = {
+  /**
+   * Chamada a cada troca do carregamento, com o updater. Para ligar o carregamento ao da consulta
+   * do app, passe `state.isLoading` (ver a `loadingFeature`).
+   */
+  onIsLoadingChange?: OnChangeFn<boolean>;
+};
+/** As APIs da feature na tabela. */
+export type Table_Loading = {
+  /** Liga ou desliga o carregamento, com um valor ou um updater. */
+  setIsLoading: (updater: Updater<boolean>) => void;
+  /**
+   * Volta o carregamento ao do `initialState`. Com `defaultState`, volta ao padrão da feature,
+   * `false`.
+   */
+  resetIsLoading: (defaultState?: boolean) => void;
+};
+declare module '@tanstack/react-table' {
+  interface Plugins {
+    loadingFeature: TableFeature;
+  }
+  interface TableState_FeatureMap {
+    loadingFeature: TableState_Loading;
+  }
+  /**
+   * O `TableState_All` não junta os plugins sozinho. Sem a chave aqui, o `setStateSlice` e a
+   * leitura do `initialState` dentro da feature não a conhecem. Opcional, como as chaves do
+   * TanStack.
+   */
+  interface TableState_All extends Partial<TableState_Loading> {}
+  interface TableOptions_FeatureMap<TFeatures extends TableFeatures, TData extends RowData> {
+    loadingFeature: TableOptions_Loading;
+  }
+  interface Table_FeatureMap<TFeatures extends TableFeatures, TData extends RowData> {
+    loadingFeature: Table_Loading;
+  }
+}
+//#endregion
+//# sourceMappingURL=loading-feature.types.d.ts.map

package/dist/features/loading/loading-feature.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loading-feature.types.d.ts","names":[],"sources":["../../../src/features/loading/loading-feature.types.ts"],"mappings":";;;YAUY;;;;;EAKV;;;YAIU;;;;;EAKV,oBAAoB;;;YAIV;;EAEV,eAAe,SAAS;;;;;EAKxB,iBAAiB;;;YASP;IACR,gBAAgB;;YAGR;IACR,gBAAgB;;;;;;;YAQR,uBAAuB,QAAQ;YAE/B,wBACR,kBAAkB,eAClB,cAAc;IAEd,gBAAgB;;YAGR,iBACR,kBAAkB,eAClB,cAAc;IAEd,gBAAgB"}

package/dist/features/row-density/row-density-feature.d.ts

@@ -0,0 +1,26 @@
+import { TableFeature } from "@tanstack/react-table";
+//#region src/features/row-density/row-density-feature.d.ts
+/**
+ * Feature do TanStack Table para a densidade das linhas. Registre com essa chave:
+ * `tableFeatures({ rowDensityFeature })`.
+ *
+ * Só guarda o estado: o `DataTable.Root` o lê e marca o grid com `data-density`, de onde as
+ * células tiram altura e espaçamento.
+ *
+ * @example
+ * ```ts
+ * const features = tableFeatures({ columnSizingFeature, rowDensityFeature });
+ *
+ * const table = useTable({
+ *   features,
+ *   columns,
+ *   data,
+ *   initialState: { rowDensity: 'compact' },
+ * });
+ *
+ * table.setRowDensity('comfortable');
+ * ```
+ */
+export declare const rowDensityFeature: TableFeature;
+//#endregion
+//# sourceMappingURL=row-density-feature.d.ts.map

package/dist/features/row-density/row-density-feature.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"row-density-feature.d.ts","names":[],"sources":["../../../src/features/row-density/row-density-feature.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;qBAsCa,mBAAmB"}

package/dist/features/row-density/row-density-feature.js

@@ -0,0 +1,44 @@
+import { assignTableAPIs, makeStateUpdater, setStateSlice } from "@tanstack/react-table";
+//#region src/features/row-density/row-density-feature.ts
+/** A densidade sem `initialState`. */
+const DEFAULT_ROW_DENSITY = "standard";
+/** A densidade de um estado inicial, ou a padrão quando ele não traz. */
+const getInitialRowDensity = (initialState) => initialState.rowDensity ?? DEFAULT_ROW_DENSITY;
+/**
+* Feature do TanStack Table para a densidade das linhas. Registre com essa chave:
+* `tableFeatures({ rowDensityFeature })`.
+*
+* Só guarda o estado: o `DataTable.Root` o lê e marca o grid com `data-density`, de onde as
+* células tiram altura e espaçamento.
+*
+* @example
+* ```ts
+* const features = tableFeatures({ columnSizingFeature, rowDensityFeature });
+*
+* const table = useTable({
+*   features,
+*   columns,
+*   data,
+*   initialState: { rowDensity: 'compact' },
+* });
+*
+* table.setRowDensity('comfortable');
+* ```
+*/
+const rowDensityFeature = {
+	getInitialState: (initialState) => ({
+		rowDensity: DEFAULT_ROW_DENSITY,
+		...initialState
+	}),
+	getDefaultTableOptions: (table) => ({ onRowDensityChange: makeStateUpdater("rowDensity", table) }),
+	constructTableAPIs: (table) => {
+		assignTableAPIs("rowDensityFeature", table, {
+			table_setRowDensity: { fn: (updater) => setStateSlice(table, "rowDensity", updater) },
+			table_resetRowDensity: { fn: (defaultState) => setStateSlice(table, "rowDensity", defaultState ? DEFAULT_ROW_DENSITY : getInitialRowDensity(table.initialState)) }
+		});
+	}
+};
+//#endregion
+export { rowDensityFeature };
+
+//# sourceMappingURL=row-density-feature.js.map

package/dist/features/row-density/row-density-feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"row-density-feature.js","names":[],"sources":["../../../src/features/row-density/row-density-feature.ts"],"sourcesContent":["import {\n  assignTableAPIs,\n  makeStateUpdater,\n  setStateSlice,\n  type TableFeature,\n  type TableState_All,\n  type Updater,\n} from '@tanstack/react-table';\nimport type { RowDensity } from './row-density-feature.types';\n\n/** A densidade sem `initialState`. */\nconst DEFAULT_ROW_DENSITY: RowDensity = 'standard';\n\n/** A densidade de um estado inicial, ou a padrão quando ele não traz. */\nconst getInitialRowDensity = (initialState: Partial<TableState_All>) =>\n  initialState.rowDensity ?? DEFAULT_ROW_DENSITY;\n\n/**\n * Feature do TanStack Table para a densidade das linhas. Registre com essa chave:\n * `tableFeatures({ rowDensityFeature })`.\n *\n * Só guarda o estado: o `DataTable.Root` o lê e marca o grid com `data-density`, de onde as\n * células tiram altura e espaçamento.\n *\n * @example\n * ```ts\n * const features = tableFeatures({ columnSizingFeature, rowDensityFeature });\n *\n * const table = useTable({\n *   features,\n *   columns,\n *   data,\n *   initialState: { rowDensity: 'compact' },\n * });\n *\n * table.setRowDensity('comfortable');\n * ```\n */\nexport const rowDensityFeature: TableFeature = {\n  getInitialState: (initialState) => ({\n    rowDensity: DEFAULT_ROW_DENSITY,\n    ...initialState,\n  }),\n\n  getDefaultTableOptions: (table) => ({\n    onRowDensityChange: makeStateUpdater('rowDensity', table),\n  }),\n\n  constructTableAPIs: (table) => {\n    assignTableAPIs('rowDensityFeature', table, {\n      table_setRowDensity: {\n        fn: (updater: Updater<RowDensity>) =>\n          setStateSlice(table, 'rowDensity', updater),\n      },\n      table_resetRowDensity: {\n        fn: (defaultState?: boolean) =>\n          setStateSlice(\n            table,\n            'rowDensity',\n            defaultState\n              ? DEFAULT_ROW_DENSITY\n              : getInitialRowDensity(table.initialState),\n          ),\n      },\n    });\n  },\n};\n"],"mappings":";;;AAWA,MAAM,sBAAkC;;AAGxC,MAAM,wBAAwB,iBAC5B,aAAa,cAAc;;;;;;;;;;;;;;;;;;;;;;AAuB7B,MAAa,oBAAkC;CAC7C,kBAAkB,kBAAkB;EAClC,YAAY;EACZ,GAAG;CACL;CAEA,yBAAyB,WAAW,EAClC,oBAAoB,iBAAiB,cAAc,KAAK,EAC1D;CAEA,qBAAqB,UAAU;EAC7B,gBAAgB,qBAAqB,OAAO;GAC1C,qBAAqB,EACnB,KAAK,YACH,cAAc,OAAO,cAAc,OAAO,EAC9C;GACA,uBAAuB,EACrB,KAAK,iBACH,cACE,OACA,cACA,eACI,sBACA,qBAAqB,MAAM,YAAY,CAC7C,EACJ;EACF,CAAC;CACH;AACF"}

package/dist/features/row-density/row-density-feature.types.d.ts

@@ -0,0 +1,53 @@
+import { OnChangeFn, RowData, TableFeature, TableFeatures, Updater } from "@tanstack/react-table";
+//#region src/features/row-density/row-density-feature.types.d.ts
+/** A densidade das linhas: altura e espaçamento de células e headers. */
+export type RowDensity = 'compact' | 'standard' | 'comfortable';
+/** O estado da feature. */
+export type TableState_RowDensity = {
+  /**
+   * A densidade das linhas.
+   * @default 'standard'
+   */
+  rowDensity: RowDensity;
+};
+/** As opções da feature. */
+export type TableOptions_RowDensity = {
+  /**
+   * Chamada a cada troca da densidade, com o updater. Sem ela, a tabela guarda a densidade
+   * sozinha. Para controlar o estado (ex.: guardar a preferência do usuário), passe esta função e
+   * `state.rowDensity`.
+   */
+  onRowDensityChange?: OnChangeFn<RowDensity>;
+};
+/** As APIs da feature na tabela. */
+export type Table_RowDensity = {
+  /** Troca a densidade, com um valor ou um updater. */
+  setRowDensity: (updater: Updater<RowDensity>) => void;
+  /**
+   * Volta a densidade à do `initialState`. Com `defaultState`, volta ao padrão da feature,
+   * `'standard'`.
+   */
+  resetRowDensity: (defaultState?: boolean) => void;
+};
+declare module '@tanstack/react-table' {
+  interface Plugins {
+    rowDensityFeature: TableFeature;
+  }
+  interface TableState_FeatureMap {
+    rowDensityFeature: TableState_RowDensity;
+  }
+  /**
+   * O `TableState_All` não junta os plugins sozinho. Sem a chave aqui, o `setStateSlice` e a
+   * leitura do `initialState` dentro da feature não a conhecem. Opcional, como as chaves do
+   * TanStack.
+   */
+  interface TableState_All extends Partial<TableState_RowDensity> {}
+  interface TableOptions_FeatureMap<TFeatures extends TableFeatures, TData extends RowData> {
+    rowDensityFeature: TableOptions_RowDensity;
+  }
+  interface Table_FeatureMap<TFeatures extends TableFeatures, TData extends RowData> {
+    rowDensityFeature: Table_RowDensity;
+  }
+}
+//#endregion
+//# sourceMappingURL=row-density-feature.types.d.ts.map

package/dist/features/row-density/row-density-feature.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"row-density-feature.types.d.ts","names":[],"sources":["../../../src/features/row-density/row-density-feature.types.ts"],"mappings":";;;YAUY;;YAGA;;;;;EAKV,YAAY;;;YAIF;;;;;;EAMV,qBAAqB,WAAW;;;YAItB;;EAEV,gBAAgB,SAAS,QAAQ;;;;;EAKjC,kBAAkB;;;YASR;IACR,mBAAmB;;YAGX;IACR,mBAAmB;;;;;;;YAQX,uBAAuB,QAAQ;YAE/B,wBACR,kBAAkB,eAClB,cAAc;IAEd,mBAAmB;;YAGX,iBACR,kBAAkB,eAClB,cAAc;IAEd,mBAAmB"}

package/dist/types/index.d.ts

@@ -0,0 +1,2 @@
+import { ColumnWith, HeaderWith, RowWith, TableFeatureKey, TableWith } from "./table-with.js";
+export type { ColumnWith, HeaderWith, RowWith, TableFeatureKey, TableWith };

package/dist/types/table-with.d.ts

@@ -0,0 +1,96 @@
+import { Atoms, CellData, Column, Column_FeatureMap, Header, Header_FeatureMap, Plugins, Row, RowData, Row_FeatureMap, StockFeatures, Table, TableFeature, TableFeatures, TableOptions_FeatureMap, Table_FeatureMap, UnionToIntersection } from "@tanstack/react-table";
+//#region src/types/table-with.d.ts
+/**
+ * Nome de uma feature da tabela: do TanStack (`rowSortingFeature`, `columnSizingFeature`…) ou
+ * própria, registrada por declaration merging no `Plugins`. Vem do registro, e não de um
+ * FeatureMap: uma feature sem API de tabela, como a de alinhamento, ficaria de fora.
+ */
+export type TableFeatureKey = keyof StockFeatures | keyof Plugins;
+/**
+ * As interfaces de um FeatureMap para as features pedidas, intersectadas. Sem nenhuma entrada no
+ * mapa, `unknown`, que é neutro na interseção.
+ */
+type FeatureMapTypes<TFeatureMap, TKey> = [Extract<TKey, keyof TFeatureMap>] extends [never] ? unknown : UnionToIntersection<TFeatureMap[Extract<TKey, keyof TFeatureMap>]>;
+/**
+ * Os atoms do estado das features pedidas. O `Atoms<TFeatures>` também é derivado do condicional,
+ * então os atoms vêm de um conjunto concreto com só essas features.
+ */
+type FeatureAtoms<TKey extends TableFeatureKey> = Atoms<{ [K in TKey & keyof TableFeatures]: TableFeature; }>;
+/**
+ * Tabela com as features `TKey`: as APIs de tabela delas, os atoms do estado
+ * (`table.atoms.pagination`) e as opções (`table.options.manualPagination`). Aceita a tabela do
+ * `useTable` e a dos contextos de célula e de header.
+ *
+ * @example
+ * ```tsx
+ * const PageStatus = <TFeatures extends TableFeatures, TData extends RowData>(props: {
+ *   table: TableWith<TFeatures, TData, 'rowPaginationFeature'>;
+ * }) => <span>{props.table.getPageCount()} páginas</span>;
+ *
+ * <PageStatus table={table} />
+ * ```
+ */
+export type TableWith<TFeatures extends TableFeatures, TData extends RowData, TKey extends TableFeatureKey> = Table<TFeatures, TData> & FeatureMapTypes<Table_FeatureMap<TFeatures, TData>, TKey> & {
+  atoms: FeatureAtoms<TKey>;
+  options: FeatureMapTypes<TableOptions_FeatureMap<TFeatures, TData>, TKey>;
+};
+/**
+ * Coluna com as APIs de coluna das features `TKey`, e a `table` dela com as de tabela e os atoms
+ * das mesmas features. Aceita `header.column`, `cell.column` e os itens de `getAllLeafColumns()`.
+ *
+ * @example
+ * ```tsx
+ * const SortButton = <TFeatures extends TableFeatures, TData extends RowData>(props: {
+ *   column: ColumnWith<TFeatures, TData, 'rowSortingFeature'>;
+ * }) => <button onClick={props.column.getToggleSortingHandler()}>Ordenar</button>;
+ *
+ * <SortButton column={header.column} />
+ * ```
+ */
+export type ColumnWith<TFeatures extends TableFeatures, TData extends RowData, TKey extends TableFeatureKey, TValue = unknown> = Column<TFeatures, TData, TValue> & FeatureMapTypes<Column_FeatureMap<TFeatures, TData>, TKey> & {
+  table: TableWith<TFeatures, TData, TKey>;
+};
+/**
+ * Header com as APIs de header das features `TKey`, e a `column` dele com as de coluna das
+ * mesmas features. Aceita os headers de `getHeaderGroups()` e o do contexto de header.
+ *
+ * @example
+ * ```tsx
+ * const ResizeHandle = <TFeatures extends TableFeatures, TData extends RowData>(props: {
+ *   header: HeaderWith<TFeatures, TData, 'columnResizingFeature' | 'columnSizingFeature'>;
+ * }) =>
+ *   props.header.column.getCanResize() ? (
+ *     <div onMouseDown={props.header.getResizeHandler()} />
+ *   ) : null;
+ *
+ * <ResizeHandle header={header} />
+ * ```
+ */
+export type HeaderWith<TFeatures extends TableFeatures, TData extends RowData, TKey extends TableFeatureKey, TValue extends CellData = CellData> = Header<TFeatures, TData, TValue> & FeatureMapTypes<Header_FeatureMap, TKey> & {
+  column: ColumnWith<TFeatures, TData, TKey, TValue>;
+};
+/**
+ * Linha com as APIs de linha das features `TKey`, e a `table` dela com as de tabela e os atoms
+ * das mesmas features. Aceita as linhas de `getRowModel().rows`, `cell.row` e a do contexto de
+ * célula.
+ *
+ * @example
+ * ```tsx
+ * const RowCheckbox = <TFeatures extends TableFeatures, TData extends RowData>(props: {
+ *   row: RowWith<TFeatures, TData, 'rowSelectionFeature'>;
+ * }) => (
+ *   <input
+ *     type="checkbox"
+ *     checked={props.row.getIsSelected()}
+ *     onChange={props.row.getToggleSelectedHandler()}
+ *   />
+ * );
+ *
+ * columnHelper.display({ id: 'select', cell: ({ row }) => <RowCheckbox row={row} /> });
+ * ```
+ */
+export type RowWith<TFeatures extends TableFeatures, TData extends RowData, TKey extends TableFeatureKey> = Row<TFeatures, TData> & FeatureMapTypes<Row_FeatureMap<TFeatures, TData>, TKey> & {
+  table: TableWith<TFeatures, TData, TKey>;
+};
+//#endregion
+//# sourceMappingURL=table-with.d.ts.map

package/dist/types/table-with.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"table-with.d.ts","names":[],"sources":["../../src/types/table-with.ts"],"mappings":";;;;;;;YAwCY,wBAAwB,sBAAsB;;;;;KAMrD,gBAAgB,aAAa,SAChC,QAAQ,YAAY,0CAGlB,oBAAoB,YAAY,QAAQ,YAAY;;;;;KAMnD,aAAa,aAAa,mBAAmB,SAC/C,KAAK,aAAa,gBAAgB;;;;;;;;;;;;;;;YAiBzB,UACV,kBAAkB,eAClB,cAAc,SACd,aAAa,mBACX,MAAM,WAAW,SACnB,gBAAgB,iBAAiB,WAAW,QAAQ;EAClD,OAAO,aAAa;EACpB,SAAS,gBAAgB,wBAAwB,WAAW,QAAQ;;;;;;;;;;;;;;;YAgB5D,WACV,kBAAkB,eAClB,cAAc,SACd,aAAa,iBACb,oBACE,OAAO,WAAW,OAAO,UAC3B,gBAAgB,kBAAkB,WAAW,QAAQ;EACnD,OAAO,UAAU,WAAW,OAAO;;;;;;;;;;;;;;;;;;YAmB3B,WACV,kBAAkB,eAClB,cAAc,SACd,aAAa,iBACb,eAAe,WAAW,YACxB,OAAO,WAAW,OAAO,UAC3B,gBAAgB,mBAAmB;EACjC,QAAQ,WAAW,WAAW,OAAO,MAAM;;;;;;;;;;;;;;;;;;;;;;YAuBnC,QACV,kBAAkB,eAClB,cAAc,SACd,aAAa,mBACX,IAAI,WAAW,SACjB,gBAAgB,eAAe,WAAW,QAAQ;EAChD,OAAO,UAAU,WAAW,OAAO"}

package/dist/utils/get-default-column-label.d.ts

@@ -0,0 +1,17 @@
+import { Column, RowData, TableFeatures } from "@tanstack/react-table";
+//#region src/utils/get-default-column-label.d.ts
+/**
+ * O nome de uma coluna fora do cabeçalho: o `header` quando é texto, e o id quando não é (um
+ * `header` em função ou nenhum). É o nome padrão das partes que listam colunas, como o
+ * `ColumnsPanel.Item` e o `DataTable.SortColumnSelect`; o app o usa para mostrar o mesmo nome em
+ * outro lugar, ou como base de um `getLabel` próprio.
+ *
+ * @example
+ * ```ts
+ * const getLabel = (column: Column<typeof features, Person>) =>
+ *   labels[column.id] ?? getDefaultColumnLabel(column);
+ * ```
+ */
+export declare const getDefaultColumnLabel: <TFeatures extends TableFeatures, TData extends RowData, TValue>(column: Column<TFeatures, TData, TValue>) => string;
+//#endregion
+//# sourceMappingURL=get-default-column-label.d.ts.map

package/dist/utils/get-default-column-label.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-default-column-label.d.ts","names":[],"sources":["../../src/utils/get-default-column-label.ts"],"mappings":";;;;;;;;;;;;;;qBAca,wBACX,kBAAkB,eAClB,cAAc,SACd,QAEA,QAAQ,OAAO,WAAW,OAAO"}

package/dist/utils/get-default-column-label.js

@@ -0,0 +1,18 @@
+//#region src/utils/get-default-column-label.ts
+/**
+* O nome de uma coluna fora do cabeçalho: o `header` quando é texto, e o id quando não é (um
+* `header` em função ou nenhum). É o nome padrão das partes que listam colunas, como o
+* `ColumnsPanel.Item` e o `DataTable.SortColumnSelect`; o app o usa para mostrar o mesmo nome em
+* outro lugar, ou como base de um `getLabel` próprio.
+*
+* @example
+* ```ts
+* const getLabel = (column: Column<typeof features, Person>) =>
+*   labels[column.id] ?? getDefaultColumnLabel(column);
+* ```
+*/
+const getDefaultColumnLabel = (column) => typeof column.columnDef.header === "string" ? column.columnDef.header : column.id;
+//#endregion
+export { getDefaultColumnLabel };
+
+//# sourceMappingURL=get-default-column-label.js.map

package/dist/utils/get-default-column-label.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-default-column-label.js","names":[],"sources":["../../src/utils/get-default-column-label.ts"],"sourcesContent":["import type { Column, RowData, TableFeatures } from '@tanstack/react-table';\n\n/**\n * O nome de uma coluna fora do cabeçalho: o `header` quando é texto, e o id quando não é (um\n * `header` em função ou nenhum). É o nome padrão das partes que listam colunas, como o\n * `ColumnsPanel.Item` e o `DataTable.SortColumnSelect`; o app o usa para mostrar o mesmo nome em\n * outro lugar, ou como base de um `getLabel` próprio.\n *\n * @example\n * ```ts\n * const getLabel = (column: Column<typeof features, Person>) =>\n *   labels[column.id] ?? getDefaultColumnLabel(column);\n * ```\n */\nexport const getDefaultColumnLabel = <\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n  TValue,\n>(\n  column: Column<TFeatures, TData, TValue>,\n) =>\n  typeof column.columnDef.header === 'string'\n    ? column.columnDef.header\n    : column.id;\n"],"mappings":";;;;;;;;;;;;;AAcA,MAAa,yBAKX,WAEA,OAAO,OAAO,UAAU,WAAW,WAC/B,OAAO,UAAU,SACjB,OAAO"}

package/dist/utils/has-feature.d.ts

@@ -0,0 +1,54 @@
+import { ColumnWith, HeaderWith, RowWith, TableFeatureKey, TableWith } from "../types/table-with.js";
+import "../types/index.js";
+import { CellData, Column, Header, Row, RowData, Table, TableFeatures } from "@tanstack/react-table";
+//#region src/utils/has-feature.d.ts
+/**
+ * Se a tabela registrou as features pedidas. Estreita a tabela para as APIs e os atoms só dessas
+ * features: para uma parte que se adapta a uma feature que não exige.
+ *
+ * @example
+ * ```ts
+ * if (hasTableFeature(table, 'rowPaginationFeature')) {
+ *   table.getPageCount();
+ * }
+ * ```
+ */
+export declare const hasTableFeature: <TFeatures extends TableFeatures, TData extends RowData, TKey extends TableFeatureKey>(table: Table<TFeatures, TData>, ...keys: TKey[]) => table is TableWith<TFeatures, TData, TKey>;
+/**
+ * Se a tabela do header registrou as features pedidas. Estreita o header, e a `column` dele, para
+ * as APIs só dessas features.
+ *
+ * @example
+ * ```ts
+ * if (hasHeaderFeature(header, 'columnSizingFeature')) {
+ *   header.getSize();
+ * }
+ * ```
+ */
+export declare const hasHeaderFeature: <TFeatures extends TableFeatures, TData extends RowData, TValue extends CellData, TKey extends TableFeatureKey>(header: Header<TFeatures, TData, TValue>, ...keys: TKey[]) => header is HeaderWith<TFeatures, TData, TKey, TValue>;
+/**
+ * Se a tabela da coluna registrou as features pedidas. Estreita a coluna para as APIs só dessas
+ * features.
+ *
+ * @example
+ * ```ts
+ * if (hasColumnFeature(cell.column, 'columnPinningFeature')) {
+ *   cell.column.getIsPinned();
+ * }
+ * ```
+ */
+export declare const hasColumnFeature: <TFeatures extends TableFeatures, TData extends RowData, TValue, TKey extends TableFeatureKey>(column: Column<TFeatures, TData, TValue>, ...keys: TKey[]) => column is ColumnWith<TFeatures, TData, TKey, TValue>;
+/**
+ * Se a tabela da linha registrou as features pedidas. Estreita a linha para as APIs só dessas
+ * features.
+ *
+ * @example
+ * ```ts
+ * if (hasRowFeature(row, 'columnVisibilityFeature')) {
+ *   row.getVisibleCells();
+ * }
+ * ```
+ */
+export declare const hasRowFeature: <TFeatures extends TableFeatures, TData extends RowData, TKey extends TableFeatureKey>(row: Row<TFeatures, TData>, ...keys: TKey[]) => row is RowWith<TFeatures, TData, TKey>;
+//#endregion
+//# sourceMappingURL=has-feature.d.ts.map

package/dist/utils/has-feature.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"has-feature.d.ts","names":[],"sources":["../../src/utils/has-feature.ts"],"mappings":";;;;;;;;;;;;;;;qBA4Ca,kBACX,kBAAkB,eAClB,cAAc,SACd,aAAa,iBAEb,OAAO,MAAM,WAAW,WACrB,MAAM,WACR,SAAS,UAAU,WAAW,OAAO;;;;;;;;;;;;qBAc3B,mBACX,kBAAkB,eAClB,cAAc,SACd,eAAe,UACf,aAAa,iBAEb,QAAQ,OAAO,WAAW,OAAO,YAC9B,MAAM,WACR,UAAU,WAAW,WAAW,OAAO,MAAM;;;;;;;;;;;;qBAcnC,mBACX,kBAAkB,eAClB,cAAc,SACd,QACA,aAAa,iBAEb,QAAQ,OAAO,WAAW,OAAO,YAC9B,MAAM,WACR,UAAU,WAAW,WAAW,OAAO,MAAM;;;;;;;;;;;;qBAcnC,gBACX,kBAAkB,eAClB,cAAc,SACd,aAAa,iBAEb,KAAK,IAAI,WAAW,WACjB,MAAM,WACR,OAAO,QAAQ,WAAW,OAAO"}

package/dist/utils/has-feature.js

@@ -0,0 +1,55 @@
+//#region src/utils/has-feature.ts
+/** Se todas as features pedidas estão entre as registradas pelo app. */
+const hasFeatures = (features, keys) => keys.every((key) => key in features);
+/**
+* Se a tabela registrou as features pedidas. Estreita a tabela para as APIs e os atoms só dessas
+* features: para uma parte que se adapta a uma feature que não exige.
+*
+* @example
+* ```ts
+* if (hasTableFeature(table, 'rowPaginationFeature')) {
+*   table.getPageCount();
+* }
+* ```
+*/
+const hasTableFeature = (table, ...keys) => hasFeatures(table.options.features, keys);
+/**
+* Se a tabela do header registrou as features pedidas. Estreita o header, e a `column` dele, para
+* as APIs só dessas features.
+*
+* @example
+* ```ts
+* if (hasHeaderFeature(header, 'columnSizingFeature')) {
+*   header.getSize();
+* }
+* ```
+*/
+const hasHeaderFeature = (header, ...keys) => hasFeatures(header.table.options.features, keys);
+/**
+* Se a tabela da coluna registrou as features pedidas. Estreita a coluna para as APIs só dessas
+* features.
+*
+* @example
+* ```ts
+* if (hasColumnFeature(cell.column, 'columnPinningFeature')) {
+*   cell.column.getIsPinned();
+* }
+* ```
+*/
+const hasColumnFeature = (column, ...keys) => hasFeatures(column.table.options.features, keys);
+/**
+* Se a tabela da linha registrou as features pedidas. Estreita a linha para as APIs só dessas
+* features.
+*
+* @example
+* ```ts
+* if (hasRowFeature(row, 'columnVisibilityFeature')) {
+*   row.getVisibleCells();
+* }
+* ```
+*/
+const hasRowFeature = (row, ...keys) => hasFeatures(row.table.options.features, keys);
+//#endregion
+export { hasColumnFeature, hasHeaderFeature, hasRowFeature, hasTableFeature };
+
+//# sourceMappingURL=has-feature.js.map

package/dist/utils/has-feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"has-feature.js","names":[],"sources":["../../src/utils/has-feature.ts"],"sourcesContent":["import type {\n  CellData,\n  Column,\n  Header,\n  Row,\n  RowData,\n  Table,\n  TableFeatures,\n} from '@tanstack/react-table';\nimport type {\n  ColumnWith,\n  HeaderWith,\n  RowWith,\n  TableFeatureKey,\n  TableWith,\n} from '../types';\n\n/*\n * Guards para os objetos que saem de outro (os headers de `getHeaderGroups()`, as linhas de\n * `getRowModel()`, a `column` de uma célula) e para a feature opcional de uma tabela. Esses vêm\n * com o tipo comum do TanStack, sem as features, e o guard os estreita para o `*With` das\n * features conferidas.\n *\n * A checagem é exata e em runtime: a feature está na lista que o app passou em `features`, e só\n * então o TanStack põe as APIs dela no protótipo. O `in` direto na API (`'getSize' in header`)\n * não serve: ele estreita para o membro do tipo que tem todas as features, e deixaria chamar a\n * API de uma que não foi conferida.\n */\n\n/** Se todas as features pedidas estão entre as registradas pelo app. */\nconst hasFeatures = (features: object, keys: readonly TableFeatureKey[]) =>\n  keys.every((key) => key in features);\n\n/**\n * Se a tabela registrou as features pedidas. Estreita a tabela para as APIs e os atoms só dessas\n * features: para uma parte que se adapta a uma feature que não exige.\n *\n * @example\n * ```ts\n * if (hasTableFeature(table, 'rowPaginationFeature')) {\n *   table.getPageCount();\n * }\n * ```\n */\nexport const hasTableFeature = <\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n  TKey extends TableFeatureKey,\n>(\n  table: Table<TFeatures, TData>,\n  ...keys: TKey[]\n): table is TableWith<TFeatures, TData, TKey> =>\n  hasFeatures(table.options.features, keys);\n\n/**\n * Se a tabela do header registrou as features pedidas. Estreita o header, e a `column` dele, para\n * as APIs só dessas features.\n *\n * @example\n * ```ts\n * if (hasHeaderFeature(header, 'columnSizingFeature')) {\n *   header.getSize();\n * }\n * ```\n */\nexport const hasHeaderFeature = <\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n  TValue extends CellData,\n  TKey extends TableFeatureKey,\n>(\n  header: Header<TFeatures, TData, TValue>,\n  ...keys: TKey[]\n): header is HeaderWith<TFeatures, TData, TKey, TValue> =>\n  hasFeatures(header.table.options.features, keys);\n\n/**\n * Se a tabela da coluna registrou as features pedidas. Estreita a coluna para as APIs só dessas\n * features.\n *\n * @example\n * ```ts\n * if (hasColumnFeature(cell.column, 'columnPinningFeature')) {\n *   cell.column.getIsPinned();\n * }\n * ```\n */\nexport const hasColumnFeature = <\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n  TValue,\n  TKey extends TableFeatureKey,\n>(\n  column: Column<TFeatures, TData, TValue>,\n  ...keys: TKey[]\n): column is ColumnWith<TFeatures, TData, TKey, TValue> =>\n  hasFeatures(column.table.options.features, keys);\n\n/**\n * Se a tabela da linha registrou as features pedidas. Estreita a linha para as APIs só dessas\n * features.\n *\n * @example\n * ```ts\n * if (hasRowFeature(row, 'columnVisibilityFeature')) {\n *   row.getVisibleCells();\n * }\n * ```\n */\nexport const hasRowFeature = <\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n  TKey extends TableFeatureKey,\n>(\n  row: Row<TFeatures, TData>,\n  ...keys: TKey[]\n): row is RowWith<TFeatures, TData, TKey> =>\n  hasFeatures(row.table.options.features, keys);\n"],"mappings":";;AA8BA,MAAM,eAAe,UAAkB,SACrC,KAAK,OAAO,QAAQ,OAAO,QAAQ;;;;;;;;;;;;AAarC,MAAa,mBAKX,OACA,GAAG,SAEH,YAAY,MAAM,QAAQ,UAAU,IAAI;;;;;;;;;;;;AAa1C,MAAa,oBAMX,QACA,GAAG,SAEH,YAAY,OAAO,MAAM,QAAQ,UAAU,IAAI;;;;;;;;;;;;AAajD,MAAa,oBAMX,QACA,GAAG,SAEH,YAAY,OAAO,MAAM,QAAQ,UAAU,IAAI;;;;;;;;;;;;AAajD,MAAa,iBAKX,KACA,GAAG,SAEH,YAAY,IAAI,MAAM,QAAQ,UAAU,IAAI"}

package/dist/utils/index.d.ts

@@ -0,0 +1,3 @@
+import { getDefaultColumnLabel } from "./get-default-column-label.js";
+import { hasColumnFeature, hasHeaderFeature, hasRowFeature, hasTableFeature } from "./has-feature.js";
+export { getDefaultColumnLabel, hasColumnFeature, hasHeaderFeature, hasRowFeature, hasTableFeature };

package/dist/utils/index.js

@@ -0,0 +1,3 @@
+import { getDefaultColumnLabel } from "./get-default-column-label.js";
+import { hasColumnFeature, hasHeaderFeature, hasRowFeature, hasTableFeature } from "./has-feature.js";
+export { getDefaultColumnLabel, hasColumnFeature, hasHeaderFeature, hasRowFeature, hasTableFeature };