@redis-ui/table 2.12.0 → 2.18.0

package/dist/Table/components/TableRoot/TableRoot.cjs

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const Table_style = require("../../Table.style.cjs");
+const TableRoot = Table_style.Table;
+exports.TableRoot = TableRoot;

package/dist/Table/components/TableRoot/TableRoot.d.ts

@@ -0,0 +1 @@
+export declare const TableRoot: import("styled-components").StyledComponent<"table", any, {}, never>;

package/dist/Table/components/TableRoot/TableRoot.js

@@ -0,0 +1,5 @@
+import { Table } from "../../Table.style.js";
+const TableRoot = Table;
+export {
+  TableRoot
+};

package/dist/Table/index.d.ts

@@ -1,8 +1,5 @@
 export { default as Table } from './Table';
 export { ShowOnRowHover } from './components/ShowOnRowHover/ShowOnRowHover.style';
-export type { ColumnDefinition } from './Table.types';
-export type { RowDefinition } from './Table.types';
-export type { CellDefinition } from './Table.types';
-export type { PaginationTypes } from './Table.types';
-export type { SortingTypes } from './Table.types';
-export { useTableContext } from './Table.context';
+export * from './Table.types';
+export * from './Table.context';
+export { type TablePluginData, buildPluginContext } from './utils/plugin.utils';

package/dist/Table/plugins/ClickableRowPlugin.cjs

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const redisUiComponents = require("@redislabsdev/redis-ui-components");
+const plugin_utils = require("../utils/plugin.utils.cjs");
+const Table_context = require("../Table.context.cjs");
+const getTrue = () => true;
+const TableClickableRowContextKey = "clickableRow";
+const useClickableRowPlugin = ({
+  getCanRowClick = getTrue,
+  onRowClick,
+  shouldClickOnEnter = false
+}) => {
+  return onRowClick ? {
+    tableOptions: {},
+    context: plugin_utils.buildPluginContext(TableClickableRowContextKey, {
+      getCanRowClick,
+      onRowClick,
+      shouldClickOnEnter
+    })
+  } : void 0;
+};
+const useClickableRowContext = () => Table_context.usePluginContext(TableClickableRowContextKey);
+const useHandleClickableRow = ({
+  row,
+  onClick,
+  onKeyDown
+}) => {
+  const {
+    getCanRowClick,
+    onRowClick,
+    shouldClickOnEnter
+  } = useClickableRowContext() || {};
+  const handleClick = redisUiComponents.combineHandlers(onRowClick && (getCanRowClick == null ? void 0 : getCanRowClick(row)) ? () => onRowClick(row) : void 0, onClick);
+  const handleKeyDown = redisUiComponents.combineHandlers(shouldClickOnEnter && handleClick ? (event) => {
+    var _a;
+    if (event.key === "Enter" && event.target === event.currentTarget) {
+      (_a = event.currentTarget) == null ? void 0 : _a.click();
+    }
+  } : void 0, onKeyDown);
+  return {
+    onClick: handleClick,
+    onKeyDown: handleKeyDown
+  };
+};
+exports.TableClickableRowContextKey = TableClickableRowContextKey;
+exports.useClickableRowContext = useClickableRowContext;
+exports.useClickableRowPlugin = useClickableRowPlugin;
+exports.useHandleClickableRow = useHandleClickableRow;

package/dist/Table/plugins/ClickableRowPlugin.d.ts

@@ -0,0 +1,25 @@
+import { KeyboardEventHandler, MouseEventHandler } from 'react';
+import { type Row } from '@tanstack/react-table';
+import { TablePluginData } from '../utils/plugin.utils';
+export declare const TableClickableRowContextKey = "clickableRow";
+export type TableClickableRowContext<T extends object> = {
+    /** Allows individual rows to be clickable */
+    getCanRowClick: (row: Row<T>) => boolean;
+    /** Handles click on the row */
+    onRowClick: (row: Row<T>) => void;
+    /** Allows simulating click on the row, when pressing Enter key */
+    shouldClickOnEnter: boolean;
+};
+export type TableClickableRowParams<T extends object> = Partial<TableClickableRowContext<T>>;
+export declare const useClickableRowPlugin: <T extends object>({ getCanRowClick, onRowClick, shouldClickOnEnter }: Partial<TableClickableRowContext<T>>) => TablePluginData<T>;
+export declare const useClickableRowContext: <T extends object>() => TableClickableRowContext<T> | undefined;
+type UseHandleClickableRowParams<T extends object> = {
+    row: Row<T>;
+    onClick?: MouseEventHandler<HTMLTableRowElement>;
+    onKeyDown?: KeyboardEventHandler<HTMLTableRowElement>;
+};
+export declare const useHandleClickableRow: <T extends object>({ row, onClick, onKeyDown }: UseHandleClickableRowParams<T>) => {
+    onClick: MouseEventHandler<HTMLTableRowElement> | undefined;
+    onKeyDown: ((event: import("react").KeyboardEvent<HTMLTableRowElement>) => void) | undefined;
+};
+export {};

package/dist/Table/plugins/ClickableRowPlugin.js

@@ -0,0 +1,48 @@
+import { combineHandlers } from "@redislabsdev/redis-ui-components";
+import { buildPluginContext } from "../utils/plugin.utils.js";
+import { usePluginContext } from "../Table.context.js";
+const getTrue = () => true;
+const TableClickableRowContextKey = "clickableRow";
+const useClickableRowPlugin = ({
+  getCanRowClick = getTrue,
+  onRowClick,
+  shouldClickOnEnter = false
+}) => {
+  return onRowClick ? {
+    tableOptions: {},
+    context: buildPluginContext(TableClickableRowContextKey, {
+      getCanRowClick,
+      onRowClick,
+      shouldClickOnEnter
+    })
+  } : void 0;
+};
+const useClickableRowContext = () => usePluginContext(TableClickableRowContextKey);
+const useHandleClickableRow = ({
+  row,
+  onClick,
+  onKeyDown
+}) => {
+  const {
+    getCanRowClick,
+    onRowClick,
+    shouldClickOnEnter
+  } = useClickableRowContext() || {};
+  const handleClick = combineHandlers(onRowClick && (getCanRowClick == null ? void 0 : getCanRowClick(row)) ? () => onRowClick(row) : void 0, onClick);
+  const handleKeyDown = combineHandlers(shouldClickOnEnter && handleClick ? (event) => {
+    var _a;
+    if (event.key === "Enter" && event.target === event.currentTarget) {
+      (_a = event.currentTarget) == null ? void 0 : _a.click();
+    }
+  } : void 0, onKeyDown);
+  return {
+    onClick: handleClick,
+    onKeyDown: handleKeyDown
+  };
+};
+export {
+  TableClickableRowContextKey,
+  useClickableRowContext,
+  useClickableRowPlugin,
+  useHandleClickableRow
+};

package/dist/Table/plugins/ExpandableRowPlugin.cjs

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const plugin_utils = require("../utils/plugin.utils.cjs");
+const ClickableRowPlugin = require("./ClickableRowPlugin.cjs");
+const Table_context = require("../Table.context.cjs");
+const index = require("../../node_modules/@tanstack/table-core/build/lib/index.cjs");
+const getTrue = () => true;
+const TableExpandableRowContextKey = "expandableRow";
+const useExpandableRowPlugin = ({
+  getRowCanExpand,
+  renderExpandedRow,
+  expandRowOnClick,
+  expandedRowComponent
+}) => {
+  const clickablePluginData = ClickableRowPlugin.useClickableRowPlugin({
+    getCanRowClick: (row) => !!(expandRowOnClick && row.getCanExpand()),
+    onRowClick: (row) => row.toggleExpanded(),
+    shouldClickOnEnter: true
+  });
+  const isExpandable = !!renderExpandedRow;
+  return isExpandable ? {
+    tableOptions: {
+      getExpandedRowModel: index.getExpandedRowModel(),
+      getRowCanExpand: getRowCanExpand || getTrue
+    },
+    context: {
+      ...plugin_utils.buildPluginContext(TableExpandableRowContextKey, {
+        renderExpandedRow,
+        expandedRowComponent
+      }),
+      ...expandRowOnClick ? clickablePluginData == null ? void 0 : clickablePluginData.context : null
+    }
+  } : void 0;
+};
+const useExpandableRowContext = () => Table_context.usePluginContext(TableExpandableRowContextKey);
+exports.TableExpandableRowContextKey = TableExpandableRowContextKey;
+exports.useExpandableRowContext = useExpandableRowContext;
+exports.useExpandableRowPlugin = useExpandableRowPlugin;

package/dist/Table/plugins/ExpandableRowPlugin.d.ts

@@ -0,0 +1,22 @@
+import { ComponentType, ReactNode } from 'react';
+import { type Row } from '@tanstack/react-table';
+import { TablePluginData } from '../utils/plugin.utils';
+import type { TableExpandedRowProps } from '../components/TableExpandedRow';
+export declare const TableExpandableRowContextKey = "expandableRow";
+export type TableExpandableRowContext<T extends object> = {
+    /** Renders content of expanded part */
+    renderExpandedRow?: (row: Row<T>) => ReactNode;
+    /**
+     * Overrides whole expanded part component.<br/>
+     * There are 2 predefined components `Table.ExpandedRow` (default) and `Table.AnimatedExpandedRow`
+     */
+    expandedRowComponent?: ComponentType<TableExpandedRowProps<T>>;
+};
+export interface TableExpandableRowParams<T extends object> extends TableExpandableRowContext<T> {
+    /** Allows expanding row by Click on whole row and by pressing Enter, when row is focused */
+    expandRowOnClick?: boolean;
+    /** Allows individual rows to be expandable */
+    getRowCanExpand?: (row: Row<T>) => boolean;
+}
+export declare const useExpandableRowPlugin: <T extends object>({ getRowCanExpand, renderExpandedRow, expandRowOnClick, expandedRowComponent }: TableExpandableRowParams<T>) => TablePluginData<T>;
+export declare const useExpandableRowContext: <T extends object>() => TableExpandableRowContext<T> | undefined;

package/dist/Table/plugins/ExpandableRowPlugin.js

@@ -0,0 +1,38 @@
+import { buildPluginContext } from "../utils/plugin.utils.js";
+import { useClickableRowPlugin } from "./ClickableRowPlugin.js";
+import { usePluginContext } from "../Table.context.js";
+import { getExpandedRowModel } from "../../node_modules/@tanstack/table-core/build/lib/index.js";
+const getTrue = () => true;
+const TableExpandableRowContextKey = "expandableRow";
+const useExpandableRowPlugin = ({
+  getRowCanExpand,
+  renderExpandedRow,
+  expandRowOnClick,
+  expandedRowComponent
+}) => {
+  const clickablePluginData = useClickableRowPlugin({
+    getCanRowClick: (row) => !!(expandRowOnClick && row.getCanExpand()),
+    onRowClick: (row) => row.toggleExpanded(),
+    shouldClickOnEnter: true
+  });
+  const isExpandable = !!renderExpandedRow;
+  return isExpandable ? {
+    tableOptions: {
+      getExpandedRowModel: getExpandedRowModel(),
+      getRowCanExpand: getRowCanExpand || getTrue
+    },
+    context: {
+      ...buildPluginContext(TableExpandableRowContextKey, {
+        renderExpandedRow,
+        expandedRowComponent
+      }),
+      ...expandRowOnClick ? clickablePluginData == null ? void 0 : clickablePluginData.context : null
+    }
+  } : void 0;
+};
+const useExpandableRowContext = () => usePluginContext(TableExpandableRowContextKey);
+export {
+  TableExpandableRowContextKey,
+  useExpandableRowContext,
+  useExpandableRowPlugin
+};

package/dist/Table/plugins/PaginationPlugin.cjs

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const index = require("../../node_modules/@radix-ui/react-use-controllable-state/dist/index.cjs");
+const plugin_utils = require("../utils/plugin.utils.cjs");
+const Table_context = require("../Table.context.cjs");
+const index$1 = require("../../node_modules/@tanstack/table-core/build/lib/index.cjs");
+const DEFAULT_PAGINATION = {
+  pageIndex: 0,
+  pageSize: 10
+};
+const TablePaginationContextKey = "pagination";
+const usePaginationPlugin = ({
+  pagination,
+  defaultPagination,
+  onPaginationChange,
+  manualPagination,
+  totalRowCount,
+  pageSizes,
+  paginationEnabled = (pagination || defaultPagination || onPaginationChange || pageSizes) !== void 0 || manualPagination !== void 0
+}) => {
+  const [paginationState, setPaginationState] = index.useControllableState({
+    prop: pagination,
+    defaultProp: defaultPagination ?? DEFAULT_PAGINATION,
+    onChange: onPaginationChange
+  });
+  return paginationEnabled ? {
+    tableOptions: {
+      state: {
+        pagination: paginationState
+      },
+      getPaginationRowModel: index$1.getPaginationRowModel(),
+      onPaginationChange: setPaginationState,
+      manualPagination,
+      rowCount: totalRowCount,
+      autoResetPageIndex: false
+    },
+    context: plugin_utils.buildPluginContext(TablePaginationContextKey, {
+      pageSizes
+    })
+  } : void 0;
+};
+const usePaginationContext = () => Table_context.usePluginContext(TablePaginationContextKey);
+exports.TablePaginationContextKey = TablePaginationContextKey;
+exports.usePaginationContext = usePaginationContext;
+exports.usePaginationPlugin = usePaginationPlugin;

package/dist/Table/plugins/PaginationPlugin.d.ts

@@ -0,0 +1,16 @@
+import { PaginationState } from '@tanstack/react-table';
+import { TablePluginData } from '../utils/plugin.utils';
+export declare const TablePaginationContextKey = "pagination";
+export interface TablePaginationContext {
+    pageSizes?: number[];
+    paginationEnabled?: boolean;
+}
+export interface TablePaginationParams extends TablePaginationContext {
+    pagination?: PaginationState;
+    defaultPagination?: PaginationState;
+    onPaginationChange?: (state: PaginationState) => void;
+    manualPagination?: boolean;
+    totalRowCount?: number;
+}
+export declare const usePaginationPlugin: <T extends object>({ pagination, defaultPagination, onPaginationChange, manualPagination, totalRowCount, pageSizes, paginationEnabled }: TablePaginationParams) => TablePluginData<T>;
+export declare const usePaginationContext: () => TablePaginationContext | undefined;

package/dist/Table/plugins/PaginationPlugin.js

@@ -0,0 +1,45 @@
+import { useControllableState } from "../../node_modules/@radix-ui/react-use-controllable-state/dist/index.js";
+import { buildPluginContext } from "../utils/plugin.utils.js";
+import { usePluginContext } from "../Table.context.js";
+import { getPaginationRowModel } from "../../node_modules/@tanstack/table-core/build/lib/index.js";
+const DEFAULT_PAGINATION = {
+  pageIndex: 0,
+  pageSize: 10
+};
+const TablePaginationContextKey = "pagination";
+const usePaginationPlugin = ({
+  pagination,
+  defaultPagination,
+  onPaginationChange,
+  manualPagination,
+  totalRowCount,
+  pageSizes,
+  paginationEnabled = (pagination || defaultPagination || onPaginationChange || pageSizes) !== void 0 || manualPagination !== void 0
+}) => {
+  const [paginationState, setPaginationState] = useControllableState({
+    prop: pagination,
+    defaultProp: defaultPagination ?? DEFAULT_PAGINATION,
+    onChange: onPaginationChange
+  });
+  return paginationEnabled ? {
+    tableOptions: {
+      state: {
+        pagination: paginationState
+      },
+      getPaginationRowModel: getPaginationRowModel(),
+      onPaginationChange: setPaginationState,
+      manualPagination,
+      rowCount: totalRowCount,
+      autoResetPageIndex: false
+    },
+    context: buildPluginContext(TablePaginationContextKey, {
+      pageSizes
+    })
+  } : void 0;
+};
+const usePaginationContext = () => usePluginContext(TablePaginationContextKey);
+export {
+  TablePaginationContextKey,
+  usePaginationContext,
+  usePaginationPlugin
+};

package/dist/Table/plugins/RowSelectionPlugin.cjs

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const index = require("../../node_modules/@radix-ui/react-use-controllable-state/dist/index.cjs");
+const DEFAULT_ROW_SELECTION = {};
+const useRowSelectionPlugin = ({
+  rowSelection,
+  defaultRowSelection,
+  onRowSelectionChange,
+  rowSelectionMode,
+  getRowCanSelect
+}) => {
+  const [rowSelectionState = DEFAULT_ROW_SELECTION, setRowSelectionState] = index.useControllableState({
+    prop: rowSelection,
+    defaultProp: defaultRowSelection,
+    onChange: onRowSelectionChange
+  });
+  return rowSelectionMode && {
+    tableOptions: {
+      state: {
+        rowSelection: rowSelectionState
+      },
+      enableRowSelection: getRowCanSelect ?? true,
+      enableMultiRowSelection: rowSelectionMode === "multiple",
+      onRowSelectionChange: setRowSelectionState
+    }
+  };
+};
+exports.useRowSelectionPlugin = useRowSelectionPlugin;

package/dist/Table/plugins/RowSelectionPlugin.d.ts

@@ -0,0 +1,12 @@
+import type { Row, RowSelectionState } from '@tanstack/react-table';
+import { TablePluginData } from '../utils/plugin.utils';
+export interface TableRowSelectionParams<T extends object> {
+    rowSelection?: RowSelectionState;
+    defaultRowSelection?: RowSelectionState;
+    onRowSelectionChange?: (state: RowSelectionState) => void;
+    /** Enables row selection sets selection mode */
+    rowSelectionMode?: 'single' | 'multiple';
+    /** Allows individual rows to be selectable */
+    getRowCanSelect?: (row: Row<T>) => boolean;
+}
+export declare const useRowSelectionPlugin: <T extends object>({ rowSelection, defaultRowSelection, onRowSelectionChange, rowSelectionMode, getRowCanSelect }: TableRowSelectionParams<T>) => TablePluginData<T>;

package/dist/Table/plugins/RowSelectionPlugin.js

@@ -0,0 +1,28 @@
+import { useControllableState } from "../../node_modules/@radix-ui/react-use-controllable-state/dist/index.js";
+const DEFAULT_ROW_SELECTION = {};
+const useRowSelectionPlugin = ({
+  rowSelection,
+  defaultRowSelection,
+  onRowSelectionChange,
+  rowSelectionMode,
+  getRowCanSelect
+}) => {
+  const [rowSelectionState = DEFAULT_ROW_SELECTION, setRowSelectionState] = useControllableState({
+    prop: rowSelection,
+    defaultProp: defaultRowSelection,
+    onChange: onRowSelectionChange
+  });
+  return rowSelectionMode && {
+    tableOptions: {
+      state: {
+        rowSelection: rowSelectionState
+      },
+      enableRowSelection: getRowCanSelect ?? true,
+      enableMultiRowSelection: rowSelectionMode === "multiple",
+      onRowSelectionChange: setRowSelectionState
+    }
+  };
+};
+export {
+  useRowSelectionPlugin
+};

package/dist/Table/plugins/SortingPlugin.cjs

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const index = require("../../node_modules/@radix-ui/react-use-controllable-state/dist/index.cjs");
+const React = require("react");
+const plugin_utils = require("../utils/plugin.utils.cjs");
+const Table_context = require("../Table.context.cjs");
+const index$1 = require("../../node_modules/@tanstack/table-core/build/lib/index.cjs");
+const TableSortingContextKey = "sorting";
+const useSortingPlugin = ({
+  defaultSorting,
+  onSortingChange,
+  sorting,
+  manualSorting = false,
+  enableSorting = true
+  // added plugin is enabled by default
+}) => {
+  const [sortedByUser, setSortedByUser] = React.useState(false);
+  const [sortingState, setSortingState] = index.useControllableState({
+    prop: sorting,
+    defaultProp: defaultSorting,
+    onChange: onSortingChange
+  });
+  return enableSorting ? {
+    tableOptions: {
+      enableSorting: true,
+      getSortedRowModel: index$1.getSortedRowModel(),
+      state: {
+        sorting: sortingState
+      },
+      manualSorting,
+      onSortingChange: (value) => {
+        setSortingState(value);
+        setSortedByUser(true);
+      }
+    },
+    context: plugin_utils.buildPluginContext(TableSortingContextKey, {
+      sortedByUser
+    })
+  } : void 0;
+};
+const useSortingContext = () => Table_context.usePluginContext(TableSortingContextKey);
+exports.TableSortingContextKey = TableSortingContextKey;
+exports.useSortingContext = useSortingContext;
+exports.useSortingPlugin = useSortingPlugin;

package/dist/Table/plugins/SortingPlugin.d.ts

@@ -0,0 +1,18 @@
+import { SortingState } from '@tanstack/react-table';
+import { TablePluginData } from '../utils/plugin.utils';
+export declare const TableSortingContextKey = "sorting";
+export interface TableSortingContext {
+    /** true, if user clicked on sorting. Ignores programmatic state changes from outside */
+    sortedByUser: boolean;
+}
+export interface TableSortingParams {
+    sorting?: SortingState;
+    defaultSorting?: SortingState;
+    onSortingChange?: (state: SortingState) => void;
+    /** If true, then table expects that items are sorted out of the table */
+    manualSorting?: boolean;
+    /** Set false to disable sorting */
+    enableSorting?: boolean;
+}
+export declare const useSortingPlugin: <T extends object>({ defaultSorting, onSortingChange, sorting, manualSorting, enableSorting }: TableSortingParams) => TablePluginData<T>;
+export declare const useSortingContext: () => TableSortingContext | undefined;

package/dist/Table/plugins/SortingPlugin.js

@@ -0,0 +1,44 @@
+import { useControllableState } from "../../node_modules/@radix-ui/react-use-controllable-state/dist/index.js";
+import { useState } from "react";
+import { buildPluginContext } from "../utils/plugin.utils.js";
+import { usePluginContext } from "../Table.context.js";
+import { getSortedRowModel } from "../../node_modules/@tanstack/table-core/build/lib/index.js";
+const TableSortingContextKey = "sorting";
+const useSortingPlugin = ({
+  defaultSorting,
+  onSortingChange,
+  sorting,
+  manualSorting = false,
+  enableSorting = true
+  // added plugin is enabled by default
+}) => {
+  const [sortedByUser, setSortedByUser] = useState(false);
+  const [sortingState, setSortingState] = useControllableState({
+    prop: sorting,
+    defaultProp: defaultSorting,
+    onChange: onSortingChange
+  });
+  return enableSorting ? {
+    tableOptions: {
+      enableSorting: true,
+      getSortedRowModel: getSortedRowModel(),
+      state: {
+        sorting: sortingState
+      },
+      manualSorting,
+      onSortingChange: (value) => {
+        setSortingState(value);
+        setSortedByUser(true);
+      }
+    },
+    context: buildPluginContext(TableSortingContextKey, {
+      sortedByUser
+    })
+  } : void 0;
+};
+const useSortingContext = () => usePluginContext(TableSortingContextKey);
+export {
+  TableSortingContextKey,
+  useSortingContext,
+  useSortingPlugin
+};

package/dist/Table/tanStackExtendedTypes.d.ts

@@ -0,0 +1,11 @@
+import '@tanstack/table-core';
+declare module '@tanstack/table-core' {
+    interface StringHeaderIdentifier {
+        isHeaderHidden?: boolean;
+        isHeaderCustom?: boolean;
+    }
+    interface IdIdentifier<TData, TValue> {
+        isHeaderHidden?: boolean;
+        isHeaderCustom?: boolean;
+    }
+}

package/dist/Table/utils/plugin.utils.cjs

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const mergeArrays = (key, container1, container2) => {
+  const arr1 = container1 == null ? void 0 : container1[key];
+  const arr2 = container2 == null ? void 0 : container2[key];
+  return arr1 && arr2 ? {
+    [key]: [...arr1, ...arr2]
+  } : null;
+};
+const mergeObjects = (key, container1, container2) => {
+  const obj1 = container1 == null ? void 0 : container1[key];
+  const obj2 = container2 == null ? void 0 : container2[key];
+  return obj1 && obj2 ? {
+    [key]: {
+      ...obj1,
+      ...obj2
+    }
+  } : null;
+};
+const mergePluginsData = (plugins) => {
+  const merged = {
+    tableOptions: {},
+    context: {}
+  };
+  if (!(plugins == null ? void 0 : plugins.length)) {
+    return merged;
+  }
+  plugins.forEach((plugin) => {
+    if (plugin) {
+      merged.tableOptions = {
+        ...merged.tableOptions,
+        ...plugin.tableOptions,
+        ...mergeArrays("_features", merged.tableOptions, plugin.tableOptions),
+        ...mergeObjects("state", merged.tableOptions, plugin.tableOptions),
+        ...mergeObjects("initialState", merged.tableOptions, plugin.tableOptions)
+      };
+      merged.context = {
+        ...merged.context,
+        ...plugin.context
+      };
+    }
+  });
+  return plugins.map((plugin) => plugin == null ? void 0 : plugin.postMerge).filter(Boolean).reduce((acc, postMerge) => (postMerge == null ? void 0 : postMerge(acc)) ?? acc, merged);
+};
+const buildPluginContext = (key, context) => ({
+  [key]: context
+});
+exports.buildPluginContext = buildPluginContext;
+exports.mergePluginsData = mergePluginsData;

package/dist/Table/utils/plugin.utils.d.ts

@@ -0,0 +1,17 @@
+import { TableOptions } from '@tanstack/table-core';
+import { RowData } from '@tanstack/react-table';
+export type PartialTableOptions<T extends RowData> = Partial<Omit<TableOptions<T>, 'columns' | 'data' | 'getRowId' | 'getSubRows' | 'onStateChange' | 'getCoreRowModel' | 'defaultColumn' | 'debugTable' | 'debugRows' | 'debugHeaders' | 'debugColumns' | 'debugCells' | 'debugAll' | 'autoResetAll' | 'meta'>>;
+export type TablePluginData<T extends RowData> = {
+    /** Partial table options that will be smartly merged with other table options */
+    tableOptions: PartialTableOptions<T>;
+    /** Plugin context data accessible via usePluginContext */
+    context?: Record<string, Record<string, unknown>>;
+    /** Optional function to modify merged plugin data after all plugins are combined */
+    postMerge?: (merged: TableMergedData<T>) => TableMergedData<T>;
+} | undefined;
+export type TableMergedData<T extends RowData> = {
+    tableOptions: PartialTableOptions<T>;
+    context?: Record<string, Record<string, unknown>>;
+};
+export declare const mergePluginsData: <T extends unknown>(plugins?: TablePluginData<T>[] | undefined) => TableMergedData<T>;
+export declare const buildPluginContext: (key: string, context: Record<string, unknown>) => Record<string, Record<string, unknown>>;