@dynatrace/strato-components 3.12.2 → 3.13.0

package/tables/DataTable/features/VirtualScrolling/VirtualScrolling.js

@@ -42,6 +42,7 @@ var import_react_table = require("@tanstack/react-table");
 var import_react_dom = require("react-dom");
 var import_logging = require("../../../../core/utils/logging.js");
 var import_constants = require("../../constants.js");
+var import_table_types = require("../types/table.types.js");
 function table_registerVirtualizers(table, rowVirtualizer, columnVirtualizer) {
   table._rowVirtualizer = rowVirtualizer;
   table._columnVirtualizer = columnVirtualizer;
@@ -253,84 +254,88 @@ function table_getHasVirtualizedRows(table, virtualItemsLength) {
 }
 function constructVirtualScrollingFeature() {
   return {
-    constructTableAPIs: (table) => {
-      (0, import_react_table.assignTableAPIs)("DataTableVirtualScrollingFeature", table, {
-        table_registerVirtualizers: {
-          fn: (rowVirtualizer, columnVirtualizer) => table_registerVirtualizers(
-            table,
-            rowVirtualizer,
-            columnVirtualizer
-          )
-        },
-        table_getRowVirtualizer: { fn: () => table_getRowVirtualizer(table) },
-        table_getColumnVirtualizer: {
-          fn: () => table_getColumnVirtualizer(table)
-        },
-        table_getRowVirtualizationContainer: {
-          fn: () => table_getRowVirtualizationContainer(table)
-        },
-        table_getRowHeight: {
-          fn: (rowId) => table_getRowHeight(table, rowId)
-        },
-        table_getRowScrollOffset: { fn: () => table_getRowScrollOffset(table) },
-        table_scrollToRowOffset: {
-          fn: (offset) => table_scrollToRowOffset(table, offset)
-        },
-        table_scrollToRow: {
-          fn: (rowId, align) => table_scrollToRow(table, rowId, align)
-        },
-        table_remeasureRows: {
-          fn: (containerWidth) => table_remeasureRows(table, containerWidth),
-          memoDeps: (containerWidth) => {
-            const expandingState = table.atoms.expanded?.get();
-            const computedExpandingState = table.options.enableExpanding ? Object.keys(expandingState ?? {}).length !== 0 && expandingState : void 0;
-            const rowDetailsState = table.options.enableRowDetails ? table.atoms.rowDetails?.get() : void 0;
-            const sortingState = table.options.enableSorting ? table.atoms.sorting?.get() : void 0;
-            return [
-              containerWidth,
-              computedExpandingState,
-              rowDetailsState,
-              sortingState,
-              table.atoms.columnLineWrap?.get(),
-              table.atoms.visualVariantConfig?.get().rowDensity,
-              table.atoms.visualVariantConfig?.get().rowSeparation,
-              table.atoms.columnSizing?.get(),
-              table.atoms.pagination?.get().pageIndex,
-              table.atoms.pagination?.get().pageSize,
-              table.atoms.columnVisibility?.get(),
-              table.atoms.rowOrder?.get(),
-              table.options.data,
-              table.options.columns
-            ];
+    constructTableAPIs: (0, import_table_types.createTableConstructor)(
+      (table) => {
+        (0, import_react_table.assignTableAPIs)("DataTableVirtualScrollingFeature", table, {
+          table_registerVirtualizers: {
+            fn: (rowVirtualizer, columnVirtualizer) => table_registerVirtualizers(
+              table,
+              rowVirtualizer,
+              columnVirtualizer
+            )
+          },
+          table_getRowVirtualizer: { fn: () => table_getRowVirtualizer(table) },
+          table_getColumnVirtualizer: {
+            fn: () => table_getColumnVirtualizer(table)
+          },
+          table_getRowVirtualizationContainer: {
+            fn: () => table_getRowVirtualizationContainer(table)
+          },
+          table_getRowHeight: {
+            fn: (rowId) => table_getRowHeight(table, rowId)
+          },
+          table_getRowScrollOffset: {
+            fn: () => table_getRowScrollOffset(table)
+          },
+          table_scrollToRowOffset: {
+            fn: (offset) => table_scrollToRowOffset(table, offset)
+          },
+          table_scrollToRow: {
+            fn: (rowId, align) => table_scrollToRow(table, rowId, align)
+          },
+          table_remeasureRows: {
+            fn: (containerWidth) => table_remeasureRows(table, containerWidth),
+            memoDeps: (containerWidth) => {
+              const expandingState = table.atoms.expanded?.get();
+              const computedExpandingState = table.options.enableExpanding ? Object.keys(expandingState ?? {}).length !== 0 && expandingState : void 0;
+              const rowDetailsState = table.options.enableRowDetails ? table.atoms.rowDetails?.get() : void 0;
+              const sortingState = table.options.enableSorting ? table.atoms.sorting?.get() : void 0;
+              return [
+                containerWidth,
+                computedExpandingState,
+                rowDetailsState,
+                sortingState,
+                table.atoms.columnLineWrap?.get(),
+                table.atoms.visualVariantConfig?.get().rowDensity,
+                table.atoms.visualVariantConfig?.get().rowSeparation,
+                table.atoms.columnSizing?.get(),
+                table.atoms.pagination?.get().pageIndex,
+                table.atoms.pagination?.get().pageSize,
+                table.atoms.columnVisibility?.get(),
+                table.atoms.rowOrder?.get(),
+                table.options.data,
+                table.options.columns
+              ];
+            }
+          },
+          table_remeasureColumn: {
+            fn: (columnId) => table_remeasureColumn(table, columnId)
+          },
+          table_remeasureAllColumns: {
+            fn: () => table_remeasureAllColumns(table)
+          },
+          table_hasColumnCellsRendered: {
+            fn: (columnId) => table_hasColumnCellsRendered(table, columnId)
+          },
+          table_getMeasuredColumnWidths: {
+            fn: () => table_getMeasuredColumnWidths(table)
+          },
+          table_getMeasuredColumnWidth: {
+            fn: (columnId) => table_getMeasuredColumnWidth(table, columnId)
+          },
+          table_resetMeasuredColumnWidths: {
+            fn: (columnIds) => table_resetMeasuredColumnWidths(table, columnIds)
+          },
+          table_setMeasuredColumnWidth: {
+            fn: (id, width) => table_setMeasuredColumnWidth(table, id, width)
+          },
+          table_getHasVirtualizedRows: {
+            fn: (virtualItemsLength) => table_getHasVirtualizedRows(table, virtualItemsLength),
+            memoDeps: () => [table._rowVirtualizer?.getVirtualItems().length]
           }
-        },
-        table_remeasureColumn: {
-          fn: (columnId) => table_remeasureColumn(table, columnId)
-        },
-        table_remeasureAllColumns: {
-          fn: () => table_remeasureAllColumns(table)
-        },
-        table_hasColumnCellsRendered: {
-          fn: (columnId) => table_hasColumnCellsRendered(table, columnId)
-        },
-        table_getMeasuredColumnWidths: {
-          fn: () => table_getMeasuredColumnWidths(table)
-        },
-        table_getMeasuredColumnWidth: {
-          fn: (columnId) => table_getMeasuredColumnWidth(table, columnId)
-        },
-        table_resetMeasuredColumnWidths: {
-          fn: (columnIds) => table_resetMeasuredColumnWidths(table, columnIds)
-        },
-        table_setMeasuredColumnWidth: {
-          fn: (id, width) => table_setMeasuredColumnWidth(table, id, width)
-        },
-        table_getHasVirtualizedRows: {
-          fn: (virtualItemsLength) => table_getHasVirtualizedRows(table, virtualItemsLength),
-          memoDeps: () => [table._rowVirtualizer?.getVirtualItems().length]
-        }
-      });
-    }
+        });
+      }
+    )
   };
 }
 const DataTableVirtualScrollingFeature = constructVirtualScrollingFeature();

package/tables/DataTable/features/VisualVariants/VisualVariants.d.ts

@@ -1,5 +1,4 @@
 import { type TableFeature } from '@tanstack/react-table';
-import type { VisualVariantFeatureConstructors } from './visual-variants-types.js';
 type VerticalAlignment = 'top' | 'center' | 'bottom';
 /**
  * Allow accessing the body vertical alignment from the table instance, so it can be used in other features or for custom logic in the table rendering.
@@ -15,12 +14,12 @@ export declare function table_getHeaderVerticalAlignment(verticalAlignment: Vert
     header: VerticalAlignment;
     body: VerticalAlignment;
 }): VerticalAlignment;
-export declare function constructVisualVariantFeature(): TableFeature<VisualVariantFeatureConstructors>;
+export declare function constructVisualVariantFeature(): TableFeature;
 /**
  * The VisualVariant feature adds visual styling options to the table, such as row separation,
  * vertical dividers, contained layout, row density, font style, header styles, and vertical alignment.
  * These options can be set globally for the entire table or individually for specific columns.
  */
-export declare const DataTableVisualVariantFeature: TableFeature<VisualVariantFeatureConstructors>;
+export declare const DataTableVisualVariantFeature: TableFeature;
 export {};
 //# sourceMappingURL=VisualVariants.d.ts.map

package/tables/DataTable/features/VisualVariants/VisualVariants.js

@@ -25,6 +25,7 @@ __export(VisualVariants_exports, {
 module.exports = __toCommonJS(VisualVariants_exports);
 var import_react_table = require("@tanstack/react-table");
 var import_constants = require("../../constants.js");
+var import_table_types = require("../types/table.types.js");
 function isVerticalAlignmentExtendedConfig(verticalAlignment) {
   if (verticalAlignment !== void 0 && typeof verticalAlignment !== "string") {
     return true;
@@ -53,22 +54,24 @@ function constructVisualVariantFeature() {
         ...initialState
       };
     },
-    constructTableAPIs: (table) => {
-      (0, import_react_table.assignTableAPIs)("DataTableVisualVariantFeature", table, {
-        table_getBodyVerticalAlignment: {
-          fn: (verticalAlignment) => table_getBodyVerticalAlignment(verticalAlignment),
-          memoDeps: () => [
-            table.atoms.visualVariantConfig?.get().verticalAlignment
-          ]
-        },
-        table_getHeaderVerticalAlignment: {
-          fn: (verticalAlignment) => table_getHeaderVerticalAlignment(verticalAlignment),
-          memoDeps: () => [
-            table.atoms.visualVariantConfig?.get().verticalAlignment
-          ]
-        }
-      });
-    }
+    constructTableAPIs: (0, import_table_types.createTableConstructor)(
+      (table) => {
+        (0, import_react_table.assignTableAPIs)("DataTableVisualVariantFeature", table, {
+          table_getBodyVerticalAlignment: {
+            fn: (verticalAlignment) => table_getBodyVerticalAlignment(verticalAlignment),
+            memoDeps: () => [
+              table.atoms.visualVariantConfig?.get().verticalAlignment
+            ]
+          },
+          table_getHeaderVerticalAlignment: {
+            fn: (verticalAlignment) => table_getHeaderVerticalAlignment(verticalAlignment),
+            memoDeps: () => [
+              table.atoms.visualVariantConfig?.get().verticalAlignment
+            ]
+          }
+        });
+      }
+    )
   };
 }
 const DataTableVisualVariantFeature = constructVisualVariantFeature();

package/tables/DataTable/features/VisualVariants/useVisualVariants.d.ts

@@ -1,10 +1,9 @@
-import { type TableOptions } from '@tanstack/react-table';
 import type { DataTableVisualVariantProps } from './visual-variants-types.js';
 import type { DataTableRowData } from '../../row-data-types.js';
-import type { TDataTableFeatures } from '../types/features.types.js';
+import type { DataTableOptions } from '../types/table.types.js';
 /**
  * @internal Configuration hook for the VisualVariant feature.
  *
  */
-export declare function useVisualVariant<TData extends DataTableRowData>(props: DataTableVisualVariantProps, options: TableOptions<TDataTableFeatures, Exclude<TData, unknown>>): void;
+export declare function useVisualVariant<TData extends DataTableRowData>(props: DataTableVisualVariantProps, options: DataTableOptions<Exclude<TData, unknown>>): void;
 //# sourceMappingURL=useVisualVariants.d.ts.map

package/tables/DataTable/features/createCoreRowModel.d.ts

@@ -1,3 +1,4 @@
-import { type RowData, type RowModel, type Table, type TableFeatures } from '@tanstack/react-table';
-export declare function createCoreRowModel<TFeatures extends TableFeatures, TData extends RowData>(): (table: Table<TFeatures, TData>) => () => RowModel<TFeatures, TData>;
+import { type RowData, type RowModel, type Table } from '@tanstack/react-table';
+import type { TDataTableFeatures } from './types/features.types.js';
+export declare function createCoreRowModel<TData extends RowData>(): (table: Table<TDataTableFeatures, TData>) => () => RowModel<TDataTableFeatures, TData>;
 //# sourceMappingURL=createCoreRowModel.d.ts.map

package/tables/DataTable/features/createCoreRowModel.js

@@ -22,8 +22,7 @@ __export(createCoreRowModel_exports, {
 module.exports = __toCommonJS(createCoreRowModel_exports);
 var import_react_table = require("@tanstack/react-table");
 function createCoreRowModel() {
-  return (_table) => {
-    const table = _table;
+  return (table) => {
     return (0, import_react_table.tableMemo)({
       feature: "coreRowModelsFeature",
       table,

package/tables/DataTable/features/features.d.ts

@@ -2,9 +2,9 @@ import { type Cell, type CellData, type ColumnHelper, type Header, type RowData,
 import type { DataTableAlignmentColumnDef } from './ColumnAlignment.js';
 import type { DataTableColumnFontStyleColumn, DataTableColumnFontStyleInstance, DataTableColumnFontStyleOptions, DataTableColumnFontStyleTableState } from './ColumnFontStyle/column-font-style-types.js';
 import { DataTableColumnFontStyleFeature } from './ColumnFontStyle/ColumnFontStyle.js';
-import type { DataTableColumnOrderHeader, DataTableColumnOrderInstance, DataTableColumnOrderOptions, DataTableColumnOrderState } from './ColumnOrder/column-order-types.js';
+import type { DataTableColumnOrderColumn, DataTableColumnOrderHeader, DataTableColumnOrderInstance, DataTableColumnOrderOptions, DataTableColumnOrderState } from './ColumnOrder/column-order-types.js';
 import { DataTableColumnOrderFeature } from './ColumnOrder/ColumnOrder.js';
-import type { DataTableColumnPinningColumn, DataTableColumnPinningHeader, DataTableColumnPinningInstance, DataTableColumnPinningOptions, DataTablePinnedColumnState } from './ColumnPinning/column-pinning-types.js';
+import type { DataTableColumnPinningColumn, DataTableColumnPinningHeader, DataTableColumnPinningInstance, DataTableColumnPinningOptions } from './ColumnPinning/column-pinning-types.js';
 import { DataTableColumnPinningFeature } from './ColumnPinning/ColumnPinning.js';
 import type { DataTableColumnSizingHeader, DataTableColumnSizingTableState } from './ColumnSizing/column-sizing-types.js';
 import { DataTableColumnSizingFeature } from './ColumnSizing/ColumnSizing.js';
@@ -49,14 +49,20 @@ import { DataTableVirtualScrollingFeature } from './VirtualScrolling/VirtualScro
 import type { DataTableVisualVariantTableInstance, DataTableVisualVariantTableState } from './VisualVariants/visual-variants-types.js';
 import { DataTableVisualVariantFeature } from './VisualVariants/VisualVariants.js';
 declare module '@tanstack/react-table' {
-    interface ColumnDef_Plugins<TFeatures extends TableFeatures, TData extends RowData, TValue extends CellData = CellData> extends DataTableLayoutColumnDef, DataTableThresholdColumnDef<TData>, DataTableAlignmentColumnDef, DataTableSortingColumnDef<TData, TValue>, DataTableUserActionColumnDef, DataTableCustomHeaderColumnDef, DataTableUserActionColumnDef {
-        /**
-         * Defines the columnType for the column, which is used to determine the default cell renderer and other default features of the column.
-         */
-        columnType?: DataTableColumnType;
-        customSortingFn?: DataTableCustomSortingFn<TValue>;
+    interface ColumnDef_FeatureMap<in out TFeatures extends TableFeatures, in out TData extends RowData, TValue extends CellData> {
+        DataTableTableLayoutFeature: DataTableLayoutColumnDef & DataTableAlignmentColumnDef & DataTableCustomHeaderColumnDef & {
+            /**
+             * Defines the columnType for the column, which is used to determine the default cell renderer and other default features of the column.
+             */
+            columnType?: DataTableColumnType;
+        };
+        DataTableRowThresholdsFeature: DataTableThresholdColumnDef<TData>;
+        DataTableRowSortingFeature: DataTableSortingColumnDef<TData, TValue> & {
+            customSortingFn?: DataTableCustomSortingFn<TValue>;
+        };
+        DataTableUserActionsFeature: DataTableUserActionColumnDef;
     }
-    interface ColumnMeta<TFeatures extends TableFeatures, TData extends RowData, TValue extends CellData = CellData> {
+    interface ColumnMeta<in out TFeatures extends TableFeatures, in out TData extends RowData, TValue extends CellData = CellData> {
         config?: DataTableSparklineColumnConfig | DataTableMeterbarColumnConfig | DataTableGanttColumnConfig | DataTableMarkdownColumnConfig | DataTableLogContentColumnConfig | DataTableTextColumnConfig;
         hasFormatter?: boolean;
         hasCustomCellRenderer?: boolean;
@@ -88,27 +94,103 @@ declare module '@tanstack/react-table' {
          */
         cellDeps?: (cell: Cell<TFeatures, TData, TValue>) => Array<boolean | string | number>;
     }
-    interface CreateRowModel_Plugins {
-        rowOrderRowModel?: (table: Table<TableFeatures, RowData>) => () => RowModel<TableFeatures, RowData>;
-        detailsRowModel?: (table: Table<TableFeatures, RowData>) => () => RowModel<TableFeatures, RowData>;
-    }
-    interface CachedRowModel_Plugins {
-        rowOrderRowModel: () => RowModel<TableFeatures, RowData>;
-        detailsRowModel: () => RowModel<TableFeatures, RowData>;
+    interface CachedRowModels_FeatureMap<in out TFeatures extends TableFeatures, in out TData extends RowData> {
+        DataTableRowOrderFeature: {
+            rowOrderRowModel?: () => RowModel<TFeatures, TData>;
+        };
+        DataTableRowDetailsFeature: {
+            detailsRowModel?: () => RowModel<TFeatures, TData>;
+        };
     }
-    interface TableState_Plugins<TFeatures extends TableFeatures> extends DataTableVisualVariantTableState, DataTableColumnSizingTableState, DataTablePaginationTableState, DataTableLineWrapTableState, DataTableColumnFontStyleTableState, DataTableLayoutTableState, DataTableVisualVariantTableState, DataTableLoadingState, DataTableRowInteractivityState, DataTableGanttChartState, DataTableMeterbarChartState, DataTableRowDetailsState, DataTableRowOrderState<TFeatures>, DataTableUserActionsState, DataTablePinnedColumnState, DataTableColumnOrderState<TFeatures>, DataTableGanttChartState {
+    interface TableState_FeatureMap {
+        DataTableVisualVariantFeature: DataTableVisualVariantTableState;
+        DataTableColumnSizingFeature: DataTableColumnSizingTableState;
+        DataTableRowPaginationFeature: DataTablePaginationTableState;
+        DataTableColumnLineWrapFeature: DataTableLineWrapTableState;
+        DataTableColumnFontStyleFeature: DataTableColumnFontStyleTableState;
+        DataTableTableLayoutFeature: DataTableLayoutTableState;
+        DataTableLoadingStateFeature: DataTableLoadingState;
+        DataTableRowInteractivityFeature: DataTableRowInteractivityState;
+        DataTableGanttChartFeature: DataTableGanttChartState;
+        DataTableMeterBarChartColumnTypeFeature: DataTableMeterbarChartState;
+        DataTableRowDetailsFeature: DataTableRowDetailsState;
+        DataTableRowOrderFeature: DataTableRowOrderState<TDataTableFeatures>;
+        DataTableUserActionsFeature: DataTableUserActionsState;
+        DataTableColumnOrderFeature: DataTableColumnOrderState<TDataTableFeatures>;
     }
-    interface Table_Plugins<TFeatures extends TableFeatures, TData extends RowData> extends DataTableVisualVariantTableInstance, DataTableColumnFontStyleInstance, DataTableColumnOrderInstance<TFeatures, TData>, DataTableColumnPinningInstance<TFeatures, TData>, DataTableColumnVisibilityInstance<TFeatures, TData>, DataTableLayoutInstance, DataTableLineWrapInstance, DataTableRowDetailsInstance, DataTableRowInteractivityInstance, DataTableRowOrderInstance<TFeatures, TData>, DataTableRowSelectionInstance, DataTableSubRowsInstance<TFeatures, TData>, DataTableUserActionsInstance<TFeatures>, DataTableVirtualScrollingInstance, DataTablePaginationInstance, DataTableDownloadDataInstance, DataTableGanttChartInstance {
+    interface Table_FeatureMap<in out TFeatures extends TableFeatures, in out TData extends RowData> {
+        DataTableVisualVariantFeature: DataTableVisualVariantTableInstance;
+        DataTableColumnFontStyleFeature: DataTableColumnFontStyleInstance;
+        DataTableColumnOrderFeature: DataTableColumnOrderInstance<TFeatures, TData>;
+        DataTableColumnPinningFeature: DataTableColumnPinningInstance<TFeatures, TData>;
+        DataTableColumnVisiblityFeature: DataTableColumnVisibilityInstance<TFeatures, TData>;
+        DataTableTableLayoutFeature: DataTableLayoutInstance;
+        DataTableColumnLineWrapFeature: DataTableLineWrapInstance;
+        DataTableRowDetailsFeature: DataTableRowDetailsInstance;
+        DataTableRowInteractivityFeature: DataTableRowInteractivityInstance;
+        DataTableRowOrderFeature: DataTableRowOrderInstance<TFeatures, TData>;
+        DataTableRowSelectionFeature: DataTableRowSelectionInstance;
+        DataTableRowSubRowsFeature: DataTableSubRowsInstance<TFeatures, TData>;
+        DataTableUserActionsFeature: DataTableUserActionsInstance<TFeatures>;
+        DataTableVirtualScrollingFeature: DataTableVirtualScrollingInstance;
+        DataTableRowPaginationFeature: DataTablePaginationInstance;
+        DataTableDownloadDataFeature: DataTableDownloadDataInstance;
+        DataTableGanttChartFeature: DataTableGanttChartInstance;
     }
-    interface Column_Plugins<TFeatures extends TableFeatures, TData extends RowData, TValue = CellData> extends DataTableColumnFontStyleColumn, DataTableColumnVisibilityColumn<TFeatures, TData>, DataTableColumnPinningColumn, DataTableLayoutColumn, DataTableLineWrapColumn, DataTableThresholdColumn<TData>, DataTableUserActionsColumn<TData> {
+    interface Column_FeatureMap<in out TFeatures extends TableFeatures, in out TData extends RowData> {
+        DataTableColumnFontStyleFeature: DataTableColumnFontStyleColumn;
+        DataTableColumnOrderFeature: DataTableColumnOrderColumn;
+        DataTableColumnVisiblityFeature: DataTableColumnVisibilityColumn<TFeatures, TData>;
+        DataTableColumnPinningFeature: DataTableColumnPinningColumn;
+        DataTableTableLayoutFeature: DataTableLayoutColumn;
+        DataTableColumnLineWrapFeature: DataTableLineWrapColumn;
+        DataTableRowThresholdsFeature: DataTableThresholdColumn<TData>;
+        DataTableUserActionsFeature: DataTableUserActionsColumn<TData>;
     }
-    interface Header_Plugins<TFeatures extends TableFeatures, TData extends RowData, TValue extends CellData = CellData> extends DataTableColumnOrderHeader, DataTableColumnPinningHeader, DataTableColumnSizingHeader, DataTableLayoutHeader, DataTableSortingHeader, DataTableDownloadDataHeader {
+    interface Header_FeatureMap {
+        DataTableColumnOrderFeature: DataTableColumnOrderHeader;
+        DataTableColumnPinningFeature: DataTableColumnPinningHeader;
+        DataTableColumnSizingFeature: DataTableColumnSizingHeader;
+        DataTableTableLayoutFeature: DataTableLayoutHeader;
+        DataTableRowSortingFeature: DataTableSortingHeader;
+        DataTableDownloadDataFeature: DataTableDownloadDataHeader;
     }
-    interface Row_Plugins<TFeatures extends TableFeatures, TData extends RowData> extends DataTableRowDetailsRow, DataTableLayoutRow, DataTableRowInteractivityRow, DataTableRowOrderRow, DataTableRowSelectionRow, DataTableSortingRow, DataTableSubRowsRow<TFeatures, TData>, DataTableThresholdRow {
+    interface Row_FeatureMap<in out TFeatures extends TableFeatures, in out TData extends RowData> {
+        DataTableRowDetailsFeature: DataTableRowDetailsRow;
+        DataTableTableLayoutFeature: DataTableLayoutRow;
+        DataTableRowInteractivityFeature: DataTableRowInteractivityRow;
+        DataTableRowOrderFeature: DataTableRowOrderRow;
+        DataTableRowSelectionFeature: DataTableRowSelectionRow;
+        DataTableRowSortingFeature: DataTableSortingRow;
+        DataTableRowSubRowsFeature: DataTableSubRowsRow<TFeatures, TData>;
+        DataTableRowThresholdsFeature: DataTableThresholdRow;
     }
-    interface TableOptions_Plugins<TFeatures extends TableFeatures, TData extends RowData> extends DataTableColumnFontStyleOptions, DataTableLayoutOptions, DataTableColumnOrderOptions, DataTableLineWrapOptions, DataTableColumnPinningOptions, DataTableRowIdentificationOptions, DataTableVisibilityOptions, DataTableRowInteractivityOptions<TFeatures, TData>, DataTableRowOrderOptions<TFeatures, TData>, DataTableRowSelectionOptions<TFeatures, TData>, DataTableSortingOptions<TData>, DataTableSubRowsOptions<TData>, DataTableRowThresholdOptions<TData>, DataTableUserActionsOptions<TData>, DataTablePaginationOptions<TFeatures, TData>, DataTableRowDetailsOptions<TData>, DataTableDownloadDataOptions {
+    interface TableOptions_FeatureMap<in out TFeatures extends TableFeatures, in out TData extends RowData> {
+        DataTableColumnFontStyleFeature: DataTableColumnFontStyleOptions;
+        DataTableTableLayoutFeature: DataTableLayoutOptions;
+        DataTableColumnOrderFeature: DataTableColumnOrderOptions;
+        DataTableColumnLineWrapFeature: DataTableLineWrapOptions;
+        DataTableColumnPinningFeature: DataTableColumnPinningOptions;
+        DataTableColumnVisiblityFeature: DataTableVisibilityOptions;
+        DataTableRowInteractivityFeature: DataTableRowInteractivityOptions<TFeatures, TData>;
+        DataTableRowOrderFeature: DataTableRowOrderOptions<TFeatures, TData> & {
+            rowOrderRowModel?: (table: Table<TFeatures, TData>) => () => RowModel<TFeatures, TData>;
+        };
+        DataTableRowSelectionFeature: DataTableRowSelectionOptions<TFeatures, TData> & DataTableRowIdentificationOptions;
+        DataTableRowSortingFeature: DataTableSortingOptions<TData>;
+        DataTableRowSubRowsFeature: DataTableSubRowsOptions<TData>;
+        DataTableRowThresholdsFeature: DataTableRowThresholdOptions<TData>;
+        DataTableUserActionsFeature: DataTableUserActionsOptions<TData>;
+        DataTableRowPaginationFeature: DataTablePaginationOptions<TFeatures, TData>;
+        DataTableRowDetailsFeature: DataTableRowDetailsOptions<TData> & {
+            detailsRowModel?: (table: Table<TFeatures, TData>) => () => RowModel<TFeatures, TData>;
+        };
+        DataTableDownloadDataFeature: DataTableDownloadDataOptions;
     }
-    interface Cell_Plugins<TFeatures extends TableFeatures, TData extends RowData, TValue extends CellData = CellData> extends DataTableThresholdCell, DataTableDownloadDataCell, DataTableUserActionsCell {
+    interface Cell_FeatureMap {
+        DataTableRowThresholdsFeature: DataTableThresholdCell;
+        DataTableDownloadDataFeature: DataTableDownloadDataCell;
+        DataTableUserActionsFeature: DataTableUserActionsCell;
     }
     interface Plugins {
         DataTableVisualVariantFeature: typeof DataTableVisualVariantFeature;

package/tables/DataTable/features/features.js

@@ -27,18 +27,22 @@ var import_ColumnOrder = require("./ColumnOrder/ColumnOrder.js");
 var import_ColumnPinning = require("./ColumnPinning/ColumnPinning.js");
 var import_ColumnSizing = require("./ColumnSizing/ColumnSizing.js");
 var import_ColumnVisibility = require("./ColumnVisibility/ColumnVisibility.js");
+var import_createCoreRowModel = require("./createCoreRowModel.js");
 var import_Download = require("./Download/Download.js");
 var import_GanttChart = require("./GanttChart/GanttChart.js");
 var import_Layout = require("./Layout/Layout.js");
 var import_LineWrap = require("./LineWrap/LineWrap.js");
 var import_LoadingState = require("./LoadingState/LoadingState.js");
 var import_MeterBarChart = require("./MeterBarChart/MeterBarChart.js");
+var import_pagination_row_model = require("./Pagination/pagination-row-model.js");
 var import_Pagination = require("./Pagination/Pagination.js");
 var import_RowDetails = require("./RowDetails/RowDetails.js");
 var import_RowInteractivity = require("./RowInteractivity/RowInteractivity.js");
 var import_RowOrder = require("./RowOrder/RowOrder.js");
 var import_RowSelection = require("./RowSelection/RowSelection.js");
+var import_sorted_row_model = require("./Sorting/sorted-row-model.js");
 var import_Sorting = require("./Sorting/Sorting.js");
+var import_subrows_row_model = require("./SubRows/subrows-row-model.js");
 var import_SubRows = require("./SubRows/SubRows.js");
 var import_Thresholds = require("./Thresholds/Thresholds.js");
 var import_UserActions = require("./UserActions/UserActions.js");
@@ -76,6 +80,10 @@ const DataTableFeatures = (0, import_react_table.tableFeatures)({
   DataTableDownloadDataFeature: import_Download.DataTableDownloadDataFeature,
   DataTableGanttChartFeature: import_GanttChart.DataTableGanttChartFeature,
   DataTableLoadingStateFeature: import_LoadingState.DataTableLoadingStateFeature,
-  DataTableMeterBarChartColumnTypeFeature: import_MeterBarChart.DataTableMeterBarChartColumnTypeFeature
+  DataTableMeterBarChartColumnTypeFeature: import_MeterBarChart.DataTableMeterBarChartColumnTypeFeature,
+  coreRowModel: (0, import_createCoreRowModel.createCoreRowModel)(),
+  expandedRowModel: (0, import_subrows_row_model.createExpandedRowModel)(),
+  sortedRowModel: (0, import_sorted_row_model.createSortedRowModel)(),
+  paginatedRowModel: (0, import_pagination_row_model.createPaginatedRowModel)()
 });
 const dataTableColumnHelper = (0, import_react_table.createColumnHelper)();

package/tables/DataTable/features/types/features.types.d.ts

@@ -1,28 +1,11 @@
-import { columnOrderingFeature, columnPinningFeature, columnResizingFeature, columnSizingFeature, columnVisibilityFeature, coreHeadersFeature, rowExpandingFeature, rowPaginationFeature, rowSelectionFeature, rowSortingFeature, type RowData, type TableFeature, type TableFeatures } from '@tanstack/react-table';
-import type { ColumnFontStyleFeatureConstructors } from '../ColumnFontStyle/column-font-style-types.js';
-import type { ColumnOrderFeatureConstructors } from '../ColumnOrder/column-order-types.js';
-import type { ColumnPinningFeatureConstructors } from '../ColumnPinning/column-pinning-types.js';
-import type { ColumnSizingFeatureConstructors } from '../ColumnSizing/column-sizing-types.js';
-import type { ColumnVisibilityFeatureConstructors } from '../ColumnVisibility/column-visibility-types.js';
-import type { DownloadDataFeatureConstructors } from '../Download/download-types.js';
-import type { DataTableGanttChartFeatureConstructors } from '../GanttChart/gantt-chart-types.js';
-import type { TableLayoutFeatureConstructors } from '../Layout/layout-types.js';
-import type { ColumnLineWrapFeatureConstructors } from '../LineWrap/line-wrap-types.js';
-import type { LoadingStateFeatureConstructors } from '../LoadingState/loading-state-types.js';
-import type { MeterBarChartColumnTypeFeatureConstructors } from '../MeterBarChart/meterbar-chart-types.js';
-import type { RowPaginationFeatureConstructors } from '../Pagination/pagination-types.js';
-import type { RowDetailsFeatureConstructors } from '../RowDetails/row-details-types.js';
-import type { RowInteractivityFeatureConstructors } from '../RowInteractivity/row-interactivity-types.js';
-import type { RowOrderFeatureConstructors } from '../RowOrder/row-order-types.js';
-import type { RowSelectionFeatureConstructors } from '../RowSelection/row-selection-types.js';
-import type { RowSortingFeatureConstructors } from '../Sorting/sorting-types.js';
-import type { RowSubRowsFeatureConstructors } from '../SubRows/sub-rows-types.js';
-import type { RowThresholdsFeatureConstructors } from '../Thresholds/threshold-types.js';
-import type { UserActionsFeatureConstructors } from '../UserActions/user-actions-types.js';
-import type { VirtualScrollingFeatureConstructors } from '../VirtualScrolling/virtual-scrolling-types.js';
-import type { VisualVariantFeatureConstructors } from '../VisualVariants/visual-variants-types.js';
+import { columnOrderingFeature, columnPinningFeature, columnResizingFeature, columnSizingFeature, columnVisibilityFeature, coreHeadersFeature, rowExpandingFeature, rowPaginationFeature, rowSelectionFeature, rowSortingFeature, type TableFeature, type TableFeatures } from '@tanstack/react-table';
 export type TDataTableFeatures = {
     coreHeadersFeature: typeof coreHeadersFeature;
+    coreRowModelsFeature?: TableFeature;
+    coreRowModel: NonNullable<TableFeatures['coreRowModel']>;
+    expandedRowModel: NonNullable<TableFeatures['expandedRowModel']>;
+    sortedRowModel: NonNullable<TableFeatures['sortedRowModel']>;
+    paginatedRowModel: NonNullable<TableFeatures['paginatedRowModel']>;
     columnVisibilityFeature: typeof columnVisibilityFeature;
     columnOrderingFeature: typeof columnOrderingFeature;
     columnPinningFeature: typeof columnPinningFeature;
@@ -32,27 +15,27 @@ export type TDataTableFeatures = {
     rowSelectionFeature: typeof rowSelectionFeature;
     columnSizingFeature: typeof columnSizingFeature;
     columnResizingFeature: typeof columnResizingFeature;
-    DataTableColumnSizingFeature: TableFeature<ColumnSizingFeatureConstructors>;
-    DataTableColumnLineWrapFeature: TableFeature<ColumnLineWrapFeatureConstructors>;
-    DataTableTableLayoutFeature: TableFeature<TableLayoutFeatureConstructors>;
-    DataTableVisualVariantFeature: TableFeature<VisualVariantFeatureConstructors>;
-    DataTableUserActionsFeature: TableFeature<UserActionsFeatureConstructors<TableFeatures, RowData>>;
-    DataTableRowSortingFeature: TableFeature<RowSortingFeatureConstructors<RowData>>;
-    DataTableColumnVisiblityFeature: TableFeature<ColumnVisibilityFeatureConstructors<TableFeatures, RowData>>;
-    DataTableColumnOrderFeature: TableFeature<ColumnOrderFeatureConstructors<TableFeatures, RowData>>;
-    DataTableRowSelectionFeature: TableFeature<RowSelectionFeatureConstructors<TableFeatures, RowData>>;
-    DataTableRowThresholdsFeature: TableFeature<RowThresholdsFeatureConstructors<RowData>>;
-    DataTableRowSubRowsFeature: TableFeature<RowSubRowsFeatureConstructors<TableFeatures, RowData>>;
-    DataTableRowDetailsFeature: TableFeature<RowDetailsFeatureConstructors<RowData>>;
-    DataTableRowInteractivityFeature: TableFeature<RowInteractivityFeatureConstructors<TableFeatures, RowData>>;
-    DataTableVirtualScrollingFeature: TableFeature<VirtualScrollingFeatureConstructors>;
-    DataTableColumnFontStyleFeature: TableFeature<ColumnFontStyleFeatureConstructors>;
-    DataTableRowPaginationFeature: TableFeature<RowPaginationFeatureConstructors<TableFeatures, RowData>>;
-    DataTableRowOrderFeature: TableFeature<RowOrderFeatureConstructors<TableFeatures, RowData>>;
-    DataTableColumnPinningFeature: TableFeature<ColumnPinningFeatureConstructors<TableFeatures, RowData>>;
-    DataTableDownloadDataFeature: TableFeature<DownloadDataFeatureConstructors>;
-    DataTableGanttChartFeature: TableFeature<DataTableGanttChartFeatureConstructors>;
-    DataTableLoadingStateFeature: TableFeature<LoadingStateFeatureConstructors>;
-    DataTableMeterBarChartColumnTypeFeature: TableFeature<MeterBarChartColumnTypeFeatureConstructors>;
+    DataTableColumnSizingFeature: TableFeature;
+    DataTableColumnLineWrapFeature: TableFeature;
+    DataTableTableLayoutFeature: TableFeature;
+    DataTableVisualVariantFeature: TableFeature;
+    DataTableUserActionsFeature: TableFeature;
+    DataTableRowSortingFeature: TableFeature;
+    DataTableColumnVisiblityFeature: TableFeature;
+    DataTableColumnOrderFeature: TableFeature;
+    DataTableRowSelectionFeature: TableFeature;
+    DataTableRowThresholdsFeature: TableFeature;
+    DataTableRowSubRowsFeature: TableFeature;
+    DataTableRowDetailsFeature: TableFeature;
+    DataTableRowInteractivityFeature: TableFeature;
+    DataTableVirtualScrollingFeature: TableFeature;
+    DataTableColumnFontStyleFeature: TableFeature;
+    DataTableRowPaginationFeature: TableFeature;
+    DataTableRowOrderFeature: TableFeature;
+    DataTableColumnPinningFeature: TableFeature;
+    DataTableDownloadDataFeature: TableFeature;
+    DataTableGanttChartFeature: TableFeature;
+    DataTableLoadingStateFeature: TableFeature;
+    DataTableMeterBarChartColumnTypeFeature: TableFeature;
 };
 //# sourceMappingURL=features.types.d.ts.map

package/tables/DataTable/features/types/table.types.d.ts

@@ -0,0 +1,47 @@
+import type { ReactTable, RowData, Table, TableFeature, TableOptions, TableState, tableMemo } from '@tanstack/react-table';
+import type { TDataTableFeatures } from './features.types.js';
+/**
+ * The DataTable's `useTable` instance.
+ *
+ * The table subscribes to no state slice at all. Components and hooks
+ * subscribe to the specific slice they need close to where they use it, so
+ * `table.state` carries nothing here. The third `ReactTable` generic argument
+ * is pinned to `null` to keep that explicit in the type and to discourage
+ * reading `table.state` from the table instance.
+ */
+export type DataTableInstance<TData extends RowData> = ReactTable<TDataTableFeatures, TData, null>;
+/**
+ * The table options composed by the DataTable config hooks.
+ *
+ * In the TanStack Table 9 beta typings used here, `state` is `readonly`.
+ * Before the options are handed to `useTable`, the object is still owned by
+ * DataTable and its state slices are composed incrementally.
+ */
+export type DataTableOptions<TData extends RowData> = TableOptions<TDataTableFeatures, TData> & {
+    state?: Partial<TableState<TDataTableFeatures>>;
+};
+/**
+ * The `table` option of `tableMemo`.
+ *
+ * Upstream types it as `Table<TFeatures, any>`. TanStack Table 9 marks `TData`
+ * invariant, which means a table that stays generic over its row type is not
+ * assignable to that shape. The row model factories use this alias instead of
+ * repeating the upstream lookup.
+ */
+export type TableMemoTable = Parameters<typeof tableMemo>[0]['table'];
+type DataTablePrototypeConstructor = (prototype: Record<string, unknown>, table: Table<TDataTableFeatures, RowData>) => void;
+type DataTableTableConstructor = (table: Table<TDataTableFeatures, RowData>) => void;
+type TableFeaturePrototypeConstructor = NonNullable<TableFeature['assignColumnPrototype']>;
+type TableFeatureTableConstructor = NonNullable<TableFeature['constructTableAPIs']>;
+/**
+ * Narrows an upstream table lifecycle callback to DataTable's feature map.
+ * @internal
+ */
+export declare function createPrototypeConstructor(constructor: DataTablePrototypeConstructor): TableFeaturePrototypeConstructor;
+/**
+ * Narrows an upstream table API lifecycle callback to DataTable's feature map.
+ * @internal
+ */
+export declare function createTableConstructor(constructor: DataTableTableConstructor): TableFeatureTableConstructor;
+export {};
+//# sourceMappingURL=table.types.d.ts.map