better-table 1.1.0 → 1.3.0

package/dist/components/BetterTable/hooks/useTablePagination.d.ts

@@ -3,6 +3,8 @@ interface UseTablePaginationOptions<T extends TableData> {
     data: T[];
     config?: PaginationConfig | false;
     onPageChange?: (page: number, pageSize: number) => void;
+    /** When true, skip client-side pagination — data represents the current page from the server */
+    manual?: boolean;
 }
 interface UseTablePaginationReturn<T extends TableData> {
     paginatedData: T[];
@@ -19,5 +21,5 @@ interface UseTablePaginationReturn<T extends TableData> {
     startIndex: number;
     endIndex: number;
 }
-export declare function useTablePagination<T extends TableData>({ data, config, onPageChange, }: UseTablePaginationOptions<T>): UseTablePaginationReturn<T>;
+export declare function useTablePagination<T extends TableData>({ data, config, onPageChange, manual, }: UseTablePaginationOptions<T>): UseTablePaginationReturn<T>;
 export {};

package/dist/components/BetterTable/hooks/useTableSearch.d.ts

@@ -7,6 +7,8 @@ interface UseTableSearchOptions<T extends TableData> {
     controlledValue?: string;
     onSearchChange?: (value: string) => void;
     debounceMs?: number;
+    /** When true, skip client-side search — data is returned as-is */
+    manual?: boolean;
 }
 interface UseTableSearchReturn<T extends TableData> {
     searchedData: T[];
@@ -14,5 +16,5 @@ interface UseTableSearchReturn<T extends TableData> {
     handleSearch: (value: string) => void;
     clearSearch: () => void;
 }
-export declare function useTableSearch<T extends TableData>({ data, columns, searchColumns, initialValue, controlledValue, onSearchChange, }: UseTableSearchOptions<T>): UseTableSearchReturn<T>;
+export declare function useTableSearch<T extends TableData>({ data, columns, searchColumns, initialValue, controlledValue, onSearchChange, debounceMs, manual, }: UseTableSearchOptions<T>): UseTableSearchReturn<T>;
 export {};

package/dist/components/BetterTable/hooks/useTableSort.d.ts

@@ -1,15 +1,27 @@
-import { SortState, TableData } from '../types';
+import { SortState, MultiSortState, TableData } from '../types';
 interface UseTableSortOptions<T extends TableData> {
     data: T[];
     initialSort?: SortState;
     controlledSort?: SortState;
     onSortChange?: (sort: SortState) => void;
+    /** Enable multi-sort (Shift+Click) */
+    multiSort?: boolean;
+    /** Controlled multi-sort state */
+    controlledMultiSort?: MultiSortState;
+    /** Callback when multi-sort changes */
+    onMultiSortChange?: (sorts: MultiSortState) => void;
+    /** When true, skip client-side sorting — data is returned as-is */
+    manual?: boolean;
 }
 interface UseTableSortReturn<T extends TableData> {
     sortedData: T[];
     sortState: SortState;
     handleSort: (columnId: string) => void;
     clearSort: () => void;
+    /** Multi-sort state (array of sort states in priority order) */
+    multiSortState: MultiSortState;
+    /** Whether multi-sort is enabled */
+    isMultiSort: boolean;
 }
-export declare function useTableSort<T extends TableData>({ data, initialSort, controlledSort, onSortChange, }: UseTableSortOptions<T>): UseTableSortReturn<T>;
+export declare function useTableSort<T extends TableData>({ data, initialSort, controlledSort, onSortChange, multiSort, controlledMultiSort, onMultiSortChange, manual, }: UseTableSortOptions<T>): UseTableSortReturn<T>;
 export {};

package/dist/components/BetterTable/hooks/useVirtualization.d.ts

@@ -0,0 +1,25 @@
+import { RefObject } from 'react';
+interface UseVirtualizationOptions {
+    /** Ref to the scrollable container */
+    containerRef: RefObject<HTMLElement | null>;
+    /** Total number of items */
+    itemCount: number;
+    /** Fixed height per row in pixels */
+    rowHeight: number;
+    /** Extra rows to render above/below the viewport */
+    buffer: number;
+    /** Whether virtualization is active */
+    enabled: boolean;
+}
+interface UseVirtualizationResult {
+    /** Total height of the virtualized content (px) */
+    totalHeight: number;
+    /** Index of the first row to render */
+    startIndex: number;
+    /** Index of the last row to render (exclusive) */
+    endIndex: number;
+    /** Top offset for the first rendered row (px) */
+    offsetTop: number;
+}
+export declare function useVirtualization({ containerRef, itemCount, rowHeight, buffer, enabled, }: UseVirtualizationOptions): UseVirtualizationResult;
+export {};

package/dist/components/BetterTable/index.d.ts

@@ -1,13 +1,14 @@
 export { BetterTable, default } from './components';
-export { defaultLocale } from './types';
-export type { BetterTableProps, Column, RowAction, GlobalAction, PaginationConfig, SortState, FilterState, TableClassNames, TableLocale, TableData, } from './types';
+export { defaultLocale, locales } from './types';
+export type { BetterTableProps, Column, RowAction, GlobalAction, PaginationConfig, SortState, MultiSortState, FilterState, TableClassNames, TableLocale, TableData, LocaleKey, } from './types';
 export { useTableSort } from './hooks/useTableSort';
 export { useTableFilter } from './hooks/useTableFilter';
 export { useTablePagination } from './hooks/useTablePagination';
 export { useTableSelection } from './hooks/useTableSelection';
 export { useTableSearch } from './hooks/useTableSearch';
-export { useTableContext, TableProvider } from './context';
-export type { TableContextValue } from './context';
+export { useColumnVisibility } from './hooks/useColumnVisibility';
+export { TableProvider, useTableData, useTableSortContext, useTableFilterContext, useTableSelectionContext, useTablePaginationContext, useTableUI, } from './context';
+export type { TableProviderProps, TableDataContextValue, TableSortContextValue, TableFilterContextValue, TableSelectionContextValue, TablePaginationContextValue, TableUIContextValue, } from './context';
 export { getValueFromPath } from './utils/getValueFromPath';
 export { sortData } from './utils/sortData';
 export { filterData, searchData } from './utils/filterData';

package/dist/components/BetterTable/types.d.ts

@@ -26,6 +26,12 @@ export interface Column<T extends TableData = TableData> {
     filterable?: boolean;
     /** Ancho de columna */
     width?: string | number;
+    /** Ancho mínimo de columna en px (default: 50) */
+    minWidth?: number;
+    /** Ancho máximo de columna en px */
+    maxWidth?: number;
+    /** Whether this column can be resized (default: inherits from table-level resizable) */
+    resizable?: boolean;
     /** Alineación del contenido */
     align?: "left" | "center" | "right";
     /** Columna oculta */
@@ -93,6 +99,15 @@ export interface PaginationConfig {
     /** Mostrar salto a página */
     showQuickJumper?: boolean;
 }
+/**
+ * Configuration for expandable rows
+ */
+export interface ExpandableConfig<T extends TableData = TableData> {
+    /** Render function for the expanded row content */
+    render: (row: T, rowIndex: number) => ReactNode;
+    /** Whether only one row can be expanded at a time (default: false) */
+    accordion?: boolean;
+}
 /**
  * Estado de ordenamiento
  */
@@ -100,11 +115,22 @@ export interface SortState {
     columnId: string | null;
     direction: "asc" | "desc";
 }
+/**
+ * Estado de multi-sort (array de sort states en orden de prioridad)
+ */
+export type MultiSortState = SortState[];
+/**
+ * Rango de fechas para filtros tipo date
+ */
+export interface DateFilterRange {
+    from?: string;
+    to?: string;
+}
 /**
  * Estado de filtros
  */
 export interface FilterState {
-    [columnId: string]: string | number | boolean | null;
+    [columnId: string]: string | number | boolean | DateFilterRange | null;
 }
 /**
  * Personalización de estilos
@@ -145,13 +171,116 @@ export interface TableLocale {
     sortDesc?: string;
     filterBy?: string;
     clearFilters?: string;
+    dateFrom?: string;
+    dateTo?: string;
     selectAll?: string;
     deselectAll?: string;
+    moreActions?: string;
+    clearSearch?: string;
+    closeModal?: string;
+    previousPage?: string;
+    nextPage?: string;
+    jumpToPage?: string;
+    details?: string;
+    columns?: string;
+    showAllColumns?: string;
+    hideColumn?: string;
+    sortPriority?: string;
+    clearSort?: string;
+    /** aria-live announcements */
+    resultsFound?: string;
+    noResultsFound?: string;
+    rowsSelected?: string;
+    /** Expandable rows */
+    expandRow?: string;
+    collapseRow?: string;
 }
 /**
- * Locale por defecto
+ * Locale por defecto (Inglés)
+ */
+export declare const defaultLocale: Required<TableLocale>;
+/**
+ * Locales predefinidos
  */
-export declare const defaultLocale: TableLocale;
+export declare const locales: {
+    readonly en: Required<TableLocale>;
+    readonly es: {
+        search: string;
+        searchPlaceholder: string;
+        noData: string;
+        loading: string;
+        page: string;
+        of: string;
+        items: string;
+        selected: string;
+        rowsPerPage: string;
+        actions: string;
+        sortAsc: string;
+        sortDesc: string;
+        filterBy: string;
+        clearFilters: string;
+        dateFrom: string;
+        dateTo: string;
+        selectAll: string;
+        deselectAll: string;
+        moreActions: string;
+        clearSearch: string;
+        closeModal: string;
+        previousPage: string;
+        nextPage: string;
+        jumpToPage: string;
+        details: string;
+        columns: string;
+        showAllColumns: string;
+        hideColumn: string;
+        sortPriority: string;
+        clearSort: string;
+        resultsFound: string;
+        noResultsFound: string;
+        rowsSelected: string;
+        expandRow: string;
+        collapseRow: string;
+    };
+    readonly pt: {
+        search: string;
+        searchPlaceholder: string;
+        noData: string;
+        loading: string;
+        page: string;
+        of: string;
+        items: string;
+        selected: string;
+        rowsPerPage: string;
+        actions: string;
+        sortAsc: string;
+        sortDesc: string;
+        filterBy: string;
+        clearFilters: string;
+        dateFrom: string;
+        dateTo: string;
+        selectAll: string;
+        deselectAll: string;
+        moreActions: string;
+        clearSearch: string;
+        closeModal: string;
+        previousPage: string;
+        nextPage: string;
+        jumpToPage: string;
+        details: string;
+        columns: string;
+        showAllColumns: string;
+        hideColumn: string;
+        sortPriority: string;
+        clearSort: string;
+        resultsFound: string;
+        noResultsFound: string;
+        rowsSelected: string;
+        expandRow: string;
+        collapseRow: string;
+    };
+};
+/** Claves de locales predefinidos */
+export type LocaleKey = keyof typeof locales;
 /**
  * Props principales del componente BetterTable
  */
@@ -166,6 +295,8 @@ export interface BetterTableProps<T extends TableData = TableData> {
     rowActions?: RowAction<T>[];
     /** Acciones globales (toolbar) */
     globalActions?: GlobalAction<T>[];
+    /** Máximo de acciones visibles inline antes de agrupar en menú overflow (default: 3) */
+    maxVisibleActions?: number;
     /** Configuración de paginación (false para desactivar) */
     pagination?: PaginationConfig | false;
     /** Callback de cambio de página */
@@ -174,6 +305,14 @@ export interface BetterTableProps<T extends TableData = TableData> {
     sort?: SortState;
     /** Callback de cambio de ordenamiento */
     onSortChange?: (sort: SortState) => void;
+    /** Habilitar multi-sort (cada columna cicla: sin orden → asc → desc → sin orden, default: false) */
+    multiSort?: boolean;
+    /** Estado de multi-sort (controlado) */
+    multiSortState?: MultiSortState;
+    /** Callback de cambio de multi-sort */
+    onMultiSortChange?: (sorts: MultiSortState) => void;
+    /** Modo de visualización de filtros: 'floating' (en header), 'panel' (colapsable), o 'both' (default: 'floating') */
+    filterMode?: "floating" | "panel" | "both";
     /** Estado de filtros (controlado) */
     filters?: FilterState;
     /** Callback de cambio de filtros */
@@ -186,6 +325,14 @@ export interface BetterTableProps<T extends TableData = TableData> {
     onSearchChange?: (value: string) => void;
     /** Columnas en las que buscar (default: todas) */
     searchColumns?: string[];
+    /** Milisegundos de debounce en la búsqueda (default: 300) */
+    searchDebounceMs?: number;
+    /** Skip client-side sorting — data is assumed pre-sorted by the server (default: false) */
+    manualSorting?: boolean;
+    /** Skip client-side filtering and search — data is assumed pre-filtered by the server (default: false) */
+    manualFiltering?: boolean;
+    /** Skip client-side pagination — data represents the current page from the server (default: false) */
+    manualPagination?: boolean;
     /** Habilitar selección de filas */
     selectable?: boolean;
     /** Filas seleccionadas (controlado) */
@@ -194,6 +341,12 @@ export interface BetterTableProps<T extends TableData = TableData> {
     onSelectionChange?: (selectedRows: T[]) => void;
     /** Modo de selección */
     selectionMode?: "single" | "multiple";
+    /** Mostrar toggle de visibilidad de columnas en el toolbar */
+    columnVisibility?: boolean;
+    /** Estado controlado de columnas ocultas (array de column IDs) */
+    hiddenColumns?: string[];
+    /** Callback cuando cambia la visibilidad de columnas */
+    onColumnVisibilityChange?: (hiddenColumns: string[]) => void;
     /** Estado de carga */
     loading?: boolean;
     /** Componente de loading personalizado */
@@ -211,8 +364,8 @@ export interface BetterTableProps<T extends TableData = TableData> {
         row?: CSSProperties;
         cell?: CSSProperties;
     };
-    /** Textos personalizados */
-    locale?: TableLocale;
+    /** Textos personalizados (preset: 'en' | 'es' | 'pt', o parcial para override) */
+    locale?: LocaleKey | TableLocale;
     /** Header fijo al hacer scroll */
     stickyHeader?: boolean;
     /** Altura máxima (activa scroll interno) */
@@ -225,6 +378,14 @@ export interface BetterTableProps<T extends TableData = TableData> {
     hoverable?: boolean;
     /** Tamaño de la tabla */
     size?: "small" | "medium" | "large";
+    /** Enable column resizing via drag (default: false) */
+    resizable?: boolean;
+    /** Callback when a column is resized */
+    onColumnResize?: (columnId: string, width: number) => void;
+    /** Minimum column width in px when resizing (default: 50) */
+    minColumnWidth?: number;
+    /** Maximum column width in px when resizing */
+    maxColumnWidth?: number;
     /** Callback al hacer click en una fila */
     onRowClick?: (row: T, rowIndex: number) => void;
     /** Callback al hacer doble click en una fila */
@@ -233,4 +394,16 @@ export interface BetterTableProps<T extends TableData = TableData> {
     ariaLabel?: string;
     /** ID del elemento que describe la tabla */
     ariaDescribedBy?: string;
+    /** Configuration for expandable rows (render function for expanded content) */
+    expandable?: ExpandableConfig<T>;
+    /** Array of expanded row keys (controlled mode) */
+    expandedRows?: string[];
+    /** Callback when expanded rows change */
+    onExpandChange?: (expandedRows: string[]) => void;
+    /** Force-enable virtualization (auto-enabled when pagination is off and dataset > VIRTUALIZATION_THRESHOLD) */
+    virtualize?: boolean;
+    /** Fixed row height in px for virtualized rendering (default: 48) */
+    rowHeight?: number;
+    /** Extra rows rendered above/below the viewport as scroll buffer (default: 5) */
+    virtualBuffer?: number;
 }

package/dist/components/BetterTable/utils/sortData.d.ts

@@ -1,4 +1,4 @@
-import { TableData } from '../types';
+import { TableData, MultiSortState } from '../types';
 /**
  * Ordena un array de datos por una columna específica
  * @param data - Array de datos a ordenar
@@ -7,3 +7,10 @@ import { TableData } from '../types';
  * @returns Array ordenado (nueva referencia)
  */
 export declare function sortData<T extends TableData>(data: T[], columnId: string, direction: "asc" | "desc"): T[];
+/**
+ * Ordena un array de datos por múltiples columnas (multi-sort)
+ * @param data - Array de datos a ordenar
+ * @param sorts - Array de estados de sort en orden de prioridad
+ * @returns Array ordenado (nueva referencia)
+ */
+export declare function multiSortData<T extends TableData>(data: T[], sorts: MultiSortState): T[];

package/dist/index.d.ts

@@ -1,19 +1,20 @@
 /**
- * @juanb/better-table
+ * better-table
  * A modern, flexible, and fully typed React data table component
  *
  * @packageDocumentation
  */
 export { BetterTable } from './components/BetterTable';
-export { defaultLocale } from './components/BetterTable/types';
-export type { BetterTableProps, Column, RowAction, GlobalAction, PaginationConfig, SortState, FilterState, TableClassNames, TableLocale, TableData, } from './components/BetterTable/types';
+export { defaultLocale, locales } from './components/BetterTable/types';
+export type { BetterTableProps, Column, RowAction, GlobalAction, ExpandableConfig, PaginationConfig, SortState, MultiSortState, FilterState, DateFilterRange, TableClassNames, TableLocale, TableData, LocaleKey, } from './components/BetterTable/types';
 export { useTableSort } from './components/BetterTable/hooks/useTableSort';
 export { useTableFilter } from './components/BetterTable/hooks/useTableFilter';
 export { useTablePagination } from './components/BetterTable/hooks/useTablePagination';
 export { useTableSelection } from './components/BetterTable/hooks/useTableSelection';
 export { useTableSearch } from './components/BetterTable/hooks/useTableSearch';
-export { useTableContext, TableProvider, } from './components/BetterTable/context';
-export type { TableContextValue } from './components/BetterTable/context';
+export { useColumnVisibility } from './components/BetterTable/hooks/useColumnVisibility';
+export { TableProvider, useTableData, useTableSortContext, useTableFilterContext, useTableSelectionContext, useTablePaginationContext, useTableUI, } from './components/BetterTable/context';
+export type { TableProviderProps, TableDataContextValue, TableSortContextValue, TableFilterContextValue, TableSelectionContextValue, TablePaginationContextValue, TableUIContextValue, } from './components/BetterTable/context';
 export { getValueFromPath } from './components/BetterTable/utils/getValueFromPath';
 export { sortData } from './components/BetterTable/utils/sortData';
 export { filterData, searchData, } from './components/BetterTable/utils/filterData';

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "better-table",
-  "version": "1.1.0",
+  "version": "1.3.0",
   "description": "A modern, flexible, and fully typed React data table component",
-  "author": "Juan Puca",
+  "author": "jrodrigopuca",
   "license": "Apache-2.0",
   "type": "module",
   "main": "./dist/better-table.cjs.js",
@@ -36,9 +36,19 @@
     "datagrid",
     "typescript",
     "sorting",
+    "multi-sort",
     "filtering",
     "pagination",
-    "selection"
+    "selection",
+    "column-visibility",
+    "column-resize",
+    "expandable-rows",
+    "virtualization",
+    "sticky-header",
+    "server-side",
+    "accessible",
+    "responsive",
+    "i18n"
   ],
   "repository": {
     "type": "git",
@@ -73,17 +83,6 @@
     "vite-plugin-dts": "^4.5.0",
     "vitest": "^4.0.18"
   },
-  "scripts": {
-    "dev": "vite --config demo/vite.config.ts",
-    "build": "vite build",
-    "build:types": "tsc -p tsconfig.build.json",
-    "preview": "vite preview",
-    "test": "vitest --config vitest.config.ts",
-    "test:run": "vitest run --config vitest.config.ts",
-    "test:coverage": "vitest run --coverage --config vitest.config.ts",
-    "lint": "tsc --noEmit",
-    "prepublishOnly": "npm run build"
-  },
   "browserslist": {
     "production": [
       ">0.2%",
@@ -95,5 +94,15 @@
       "last 1 firefox version",
       "last 1 safari version"
     ]
+  },
+  "scripts": {
+    "dev": "vite --config demo/vite.config.ts",
+    "build": "vite build",
+    "build:types": "tsc -p tsconfig.build.json",
+    "preview": "vite preview",
+    "test": "vitest --config vitest.config.ts",
+    "test:run": "vitest run --config vitest.config.ts",
+    "test:coverage": "vitest run --coverage --config vitest.config.ts",
+    "lint": "tsc --noEmit"
   }
-}
+}