@1money/component-ui 0.0.1

package/es/components/Table/core/useTableColumns.js

@@ -0,0 +1,191 @@
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useMemo } from 'react';
+import { SelectionControl, SelectionHeaderControl } from '../features/SelectionColumn';
+import { ExpandTrigger } from '../features/ExpandTrigger';
+import { HeaderCell } from '../renderers/HeaderCell';
+import { BodyCell } from '../renderers/BodyCell';
+import { TABLE_DEFAULT_PREFIX } from '../constants';
+function isColumnGroup(col) {
+  return 'children' in col && Array.isArray(col.children);
+}
+function makeExpandTransform(config) {
+  var expandable = config.expandable,
+    mergedExpandedRowKeys = config.mergedExpandedRowKeys,
+    triggerExpand = config.triggerExpand,
+    getRowKey = config.getRowKey;
+  var customExpandIcon = expandable === null || expandable === void 0 ? void 0 : expandable.expandIcon;
+  return function (columns) {
+    return [{
+      key: '__expand__',
+      width: 48,
+      render: function render(_, record, index) {
+        var recordKey = getRowKey(record, index);
+        var expanded = mergedExpandedRowKeys.includes(recordKey);
+        if (customExpandIcon) {
+          return customExpandIcon({
+            prefixCls: TABLE_DEFAULT_PREFIX,
+            expanded: expanded,
+            record: record,
+            expandable: true,
+            onExpand: function onExpand(rec, e) {
+              e.stopPropagation();
+              triggerExpand(getRowKey(rec, index), rec);
+            }
+          });
+        }
+        return _jsx(ExpandTrigger, {
+          expanded: expanded,
+          onToggle: function onToggle() {
+            return triggerExpand(recordKey, record);
+          }
+        });
+      }
+    }].concat(_toConsumableArray(columns));
+  };
+}
+function makeSelectionTransform(config) {
+  var _a;
+  var rowSelection = config.rowSelection,
+    mergedSelectedRowKeys = config.mergedSelectedRowKeys,
+    checkboxPropsMap = config.checkboxPropsMap,
+    isAllSelected = config.isAllSelected,
+    isIndeterminate = config.isIndeterminate,
+    triggerSelection = config.triggerSelection,
+    triggerSelectAll = config.triggerSelectAll,
+    getRowKey = config.getRowKey;
+  if (!rowSelection) return null;
+  var selectionType = (_a = rowSelection.type) !== null && _a !== void 0 ? _a : 'checkbox';
+  return function (columns) {
+    var _a;
+    return [Object.assign(Object.assign({
+      key: '__selection__',
+      width: (_a = rowSelection.columnWidth) !== null && _a !== void 0 ? _a : 48,
+      fixed: rowSelection.fixed ? 'left' : undefined
+    }, selectionType === 'checkbox' ? {
+      renderHeader: function renderHeader() {
+        return _jsx(SelectionHeaderControl, {
+          checked: isAllSelected,
+          indeterminate: isIndeterminate,
+          onChange: triggerSelectAll
+        });
+      }
+    } : {}), {
+      render: function render(_, record, index) {
+        var recordKey = getRowKey(record, index);
+        var checkboxProps = checkboxPropsMap.get(recordKey);
+        return _jsx(SelectionControl, {
+          type: selectionType,
+          checked: mergedSelectedRowKeys.includes(recordKey),
+          disabled: checkboxProps === null || checkboxProps === void 0 ? void 0 : checkboxProps.disabled,
+          onChange: function onChange() {
+            return triggerSelection(recordKey);
+          }
+        });
+      }
+    })].concat(_toConsumableArray(columns));
+  };
+}
+function makeSortTransform(config) {
+  var size = config.size,
+    sorter = config.sorter,
+    setSorter = config.setSorter;
+  return function (columns) {
+    return columns.map(function (column) {
+      var _a;
+      if (isColumnGroup(column)) return column;
+      return Object.assign(Object.assign({}, column), {
+        title: column.renderHeader ? column.renderHeader({
+          column: column
+        }) : _jsx(HeaderCell, {
+          column: column,
+          size: size,
+          sortOrder: sorter.columnKey === column.key ? (_a = sorter.order) !== null && _a !== void 0 ? _a : null : null,
+          onSortClick: function onSortClick() {
+            return setSorter(function (currentSorter) {
+              return {
+                columnKey: column.key,
+                order: currentSorter.columnKey !== column.key || currentSorter.order === null ? 'ascend' : currentSorter.order === 'ascend' ? 'descend' : null
+              };
+            });
+          }
+        })
+      });
+    });
+  };
+}
+var SPACER_COLUMN_CLS = 'om-react-ui-table-cell--spacer';
+function makeSpacerTransform() {
+  return function (columns) {
+    return [{
+      key: '__spacer_start__',
+      width: 16,
+      title: '',
+      className: SPACER_COLUMN_CLS,
+      render: function render() {
+        return null;
+      }
+    }].concat(_toConsumableArray(columns), [{
+      key: '__spacer_end__',
+      width: 16,
+      title: '',
+      className: SPACER_COLUMN_CLS,
+      render: function render() {
+        return null;
+      }
+    }]);
+  };
+}
+function makeRenderTransform() {
+  return function (columns) {
+    return columns.map(function (column) {
+      if (isColumnGroup(column)) return column;
+      return Object.assign(Object.assign({}, column), {
+        render: function render(value, record, index) {
+          return BodyCell({
+            column: column,
+            value: value,
+            record: record,
+            index: index
+          });
+        }
+      });
+    });
+  };
+}
+export function useTableColumns(config) {
+  var columns = config.columns,
+    variant = config.variant,
+    expandable = config.expandable,
+    rowSelection = config.rowSelection,
+    mergedExpandedRowKeys = config.mergedExpandedRowKeys,
+    mergedSelectedRowKeys = config.mergedSelectedRowKeys,
+    checkboxPropsMap = config.checkboxPropsMap,
+    isAllSelected = config.isAllSelected,
+    isIndeterminate = config.isIndeterminate,
+    triggerExpand = config.triggerExpand,
+    triggerSelection = config.triggerSelection,
+    triggerSelectAll = config.triggerSelectAll,
+    sorter = config.sorter,
+    setSorter = config.setSorter,
+    size = config.size,
+    getRowKey = config.getRowKey;
+  return useMemo(function () {
+    var transforms = [];
+    if (expandable && expandable.showExpandColumn !== false) {
+      transforms.push(makeExpandTransform(config));
+    }
+    if (rowSelection) {
+      transforms.push(makeSelectionTransform(config));
+    }
+    transforms.push(makeSortTransform(config));
+    transforms.push(makeRenderTransform());
+    if (variant === 'stroke') {
+      transforms.push(makeSpacerTransform());
+    }
+    return transforms.reduce(function (cols, fn) {
+      return fn(cols);
+    }, columns);
+  }, [columns, variant, expandable, rowSelection, mergedExpandedRowKeys, mergedSelectedRowKeys, checkboxPropsMap, isAllSelected, isIndeterminate, triggerExpand, triggerSelection, triggerSelectAll, sorter, setSorter, size, getRowKey]);
+}
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["components/Table/core/useTableColumns.js","components/Table/src/components/Table/core/useTableColumns.tsx"],"names":["jsx","_jsx","useMemo","SelectionControl","SelectionHeaderControl","ExpandTrigger","HeaderCell","BodyCell","TABLE_DEFAULT_PREFIX","isColumnGroup","col","Array","isArray","children","makeExpandTransform","config","expandable","mergedExpandedRowKeys","triggerExpand","getRowKey","customExpandIcon","expandIcon","columns","key","width","render","_","record","index","recordKey","expanded","includes","prefixCls","onExpand","rec","e","stopPropagation","onToggle","concat","_toConsumableArray","makeSelectionTransform","_a","rowSelection","mergedSelectedRowKeys","checkboxPropsMap","isAllSelected","isIndeterminate","triggerSelection","triggerSelectAll","selectionType","type","Object","assign","columnWidth","fixed","undefined","renderHeader","checked","indeterminate","onChange","checkboxProps","get","disabled","makeSortTransform","size","sorter","setSorter","map","column","title","sortOrder","columnKey","order","onSortClick","currentSorter","SPACER_COLUMN_CLS","makeSpacerTransform","className","makeRenderTransform","value","useTableColumns","variant","transforms","showExpandColumn","push","reduce","cols","fn"],"mappings":"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","file":"components/Table/core/useTableColumns.js","sourcesContent":["import { jsx as _jsx } from \"react/jsx-runtime\";\nimport { useMemo } from 'react';\nimport { SelectionControl, SelectionHeaderControl } from '../features/SelectionColumn';\nimport { ExpandTrigger } from '../features/ExpandTrigger';\nimport { HeaderCell } from '../renderers/HeaderCell';\nimport { BodyCell } from '../renderers/BodyCell';\nimport { TABLE_DEFAULT_PREFIX } from '../constants';\nfunction isColumnGroup(col) {\n    return 'children' in col && Array.isArray(col.children);\n}\nfunction makeExpandTransform(config) {\n    const { expandable, mergedExpandedRowKeys, triggerExpand, getRowKey } = config;\n    const customExpandIcon = expandable === null || expandable === void 0 ? void 0 : expandable.expandIcon;\n    return (columns) => [\n        {\n            key: '__expand__',\n            width: 48,\n            render: (_, record, index) => {\n                const recordKey = getRowKey(record, index);\n                const expanded = mergedExpandedRowKeys.includes(recordKey);\n                if (customExpandIcon) {\n                    return customExpandIcon({\n                        prefixCls: TABLE_DEFAULT_PREFIX,\n                        expanded,\n                        record,\n                        expandable: true,\n                        onExpand: (rec, e) => {\n                            e.stopPropagation();\n                            triggerExpand(getRowKey(rec, index), rec);\n                        },\n                    });\n                }\n                return (_jsx(ExpandTrigger, { expanded: expanded, onToggle: () => triggerExpand(recordKey, record) }));\n            },\n        },\n        ...columns,\n    ];\n}\nfunction makeSelectionTransform(config) {\n    var _a;\n    const { rowSelection, mergedSelectedRowKeys, checkboxPropsMap, isAllSelected, isIndeterminate, triggerSelection, triggerSelectAll, getRowKey, } = config;\n    if (!rowSelection)\n        return null;\n    const selectionType = (_a = rowSelection.type) !== null && _a !== void 0 ? _a : 'checkbox';\n    return (columns) => {\n        var _a;\n        return [\n            Object.assign(Object.assign({ key: '__selection__', width: (_a = rowSelection.columnWidth) !== null && _a !== void 0 ? _a : 48, fixed: rowSelection.fixed ? 'left' : undefined }, (selectionType === 'checkbox'\n                ? {\n                    renderHeader: () => (_jsx(SelectionHeaderControl, { checked: isAllSelected, indeterminate: isIndeterminate, onChange: triggerSelectAll })),\n                }\n                : {})), { render: (_, record, index) => {\n                    const recordKey = getRowKey(record, index);\n                    const checkboxProps = checkboxPropsMap.get(recordKey);\n                    return (_jsx(SelectionControl, { type: selectionType, checked: mergedSelectedRowKeys.includes(recordKey), disabled: checkboxProps === null || checkboxProps === void 0 ? void 0 : checkboxProps.disabled, onChange: () => triggerSelection(recordKey) }));\n                } }),\n            ...columns,\n        ];\n    };\n}\nfunction makeSortTransform(config) {\n    const { size, sorter, setSorter } = config;\n    return (columns) => columns.map((column) => {\n        var _a;\n        if (isColumnGroup(column))\n            return column;\n        return Object.assign(Object.assign({}, column), { title: column.renderHeader\n                ? column.renderHeader({ column })\n                : (_jsx(HeaderCell, { column: column, size: size, sortOrder: sorter.columnKey === column.key ? (_a = sorter.order) !== null && _a !== void 0 ? _a : null : null, onSortClick: () => setSorter((currentSorter) => ({\n                        columnKey: column.key,\n                        order: currentSorter.columnKey !== column.key || currentSorter.order === null\n                            ? 'ascend'\n                            : currentSorter.order === 'ascend'\n                                ? 'descend'\n                                : null,\n                    })) })) });\n    });\n}\nconst SPACER_COLUMN_CLS = 'om-react-ui-table-cell--spacer';\nfunction makeSpacerTransform() {\n    return (columns) => [\n        { key: '__spacer_start__', width: 16, title: '', className: SPACER_COLUMN_CLS, render: () => null },\n        ...columns,\n        { key: '__spacer_end__', width: 16, title: '', className: SPACER_COLUMN_CLS, render: () => null },\n    ];\n}\nfunction makeRenderTransform() {\n    return (columns) => columns.map((column) => {\n        if (isColumnGroup(column))\n            return column;\n        return Object.assign(Object.assign({}, column), { render: (value, record, index) => BodyCell({\n                column: column,\n                value,\n                record: record,\n                index,\n            }) });\n    });\n}\nexport function useTableColumns(config) {\n    const { columns, variant, expandable, rowSelection, mergedExpandedRowKeys, mergedSelectedRowKeys, checkboxPropsMap, isAllSelected, isIndeterminate, triggerExpand, triggerSelection, triggerSelectAll, sorter, setSorter, size, getRowKey, } = config;\n    return useMemo(() => {\n        const transforms = [];\n        if (expandable && expandable.showExpandColumn !== false) {\n            transforms.push(makeExpandTransform(config));\n        }\n        if (rowSelection) {\n            transforms.push(makeSelectionTransform(config));\n        }\n        transforms.push(makeSortTransform(config));\n        transforms.push(makeRenderTransform());\n        if (variant === 'stroke') {\n            transforms.push(makeSpacerTransform());\n        }\n        return transforms.reduce((cols, fn) => fn(cols), columns);\n    }, [\n        columns,\n        variant,\n        expandable,\n        rowSelection,\n        mergedExpandedRowKeys,\n        mergedSelectedRowKeys,\n        checkboxPropsMap,\n        isAllSelected,\n        isIndeterminate,\n        triggerExpand,\n        triggerSelection,\n        triggerSelectAll,\n        sorter,\n        setSorter,\n        size,\n        getRowKey,\n    ]);\n}",null],"sourceRoot":"../../../../../../../../../../src"}

package/es/components/Table/core/useTableDataPipeline.d.ts

@@ -0,0 +1,50 @@
+import type { Key } from 'react';
+import type { TableChangeMeta, TableColumnType, TablePaginationConfig, TableSortOrder } from '../interface';
+export interface TableSorterFieldState {
+    columnKey: Key;
+    order: Exclude<TableSortOrder, null>;
+}
+export interface TableSorterState {
+    columnKey?: Key;
+    order?: TableSortOrder;
+}
+export interface TablePipelineState {
+    sorter: TableSorterState;
+    pagination: false | Required<Pick<TablePaginationConfig, 'current' | 'pageSize'>>;
+}
+export interface ApplyTablePipelineInput<T> extends TablePipelineState {
+    columns: TableColumnType<T>[];
+    dataSource: T[];
+}
+export interface UseTableDataPipelineInput<T> {
+    columns: TableColumnType<T>[];
+    dataSource: T[];
+    pagination?: false | TablePaginationConfig;
+    onChange?: (meta: TableChangeMeta<T>) => void;
+}
+export interface UseTableDataPipelineResult<T> {
+    currentDataSource: T[];
+    total: number;
+    sorter: TableSorterState;
+    sorterStates: TableSorterFieldState[];
+    pagination: false | {
+        current: number;
+        pageSize: number;
+    };
+    setSorter: (updater: TableSorterState | ((current: TableSorterState) => TableSorterState)) => void;
+    setPagination: (updater: {
+        current: number;
+        pageSize: number;
+    } | ((current: {
+        current: number;
+        pageSize: number;
+    }) => {
+        current: number;
+        pageSize: number;
+    })) => void;
+}
+export declare const applyTablePipeline: <T>({ columns, dataSource, sorter, pagination, }: ApplyTablePipelineInput<T>) => {
+    currentDataSource: T[];
+    total: number;
+};
+export declare const useTableDataPipeline: <T>({ columns, dataSource, pagination, onChange, }: UseTableDataPipelineInput<T>) => UseTableDataPipelineResult<T>;

package/es/components/Table/core/useTableDataPipeline.js

@@ -0,0 +1,262 @@
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _typeof from "@babel/runtime/helpers/esm/typeof";
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+import { useMemo } from 'react';
+import { useControlledState, useMemoizedFn } from '@1money/hooks';
+function isColumnGroup(col) {
+  return 'children' in col && Array.isArray(col.children);
+}
+function flattenColumns(columns) {
+  var result = [];
+  var _iterator = _createForOfIteratorHelper(columns),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var col = _step.value;
+      if (isColumnGroup(col)) {
+        result.push.apply(result, _toConsumableArray(flattenColumns(col.children)));
+      } else {
+        result.push(col);
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return result;
+}
+function getSortFunction(sorter) {
+  if (typeof sorter === 'function') return sorter;
+  if (sorter && _typeof(sorter) === 'object' && 'compare' in sorter) return sorter.compare;
+  return false;
+}
+function getMultiplePriority(column) {
+  if (column.sorter && _typeof(column.sorter) === 'object' && 'multiple' in column.sorter) {
+    return column.sorter.multiple;
+  }
+  return false;
+}
+function applySortToData(data, columns, sorterStates) {
+  if (sorterStates.length === 0) return data;
+  var sorted = _toConsumableArray(data);
+  var runningSorters = sorterStates.map(function (state) {
+    var column = columns.find(function (col) {
+      return col.key === state.columnKey;
+    });
+    if (!column) return null;
+    var compareFn = getSortFunction(column.sorter);
+    if (!compareFn) return null;
+    var priority = getMultiplePriority(column);
+    return {
+      compareFn: compareFn,
+      order: state.order,
+      priority: priority
+    };
+  }).filter(Boolean);
+  if (runningSorters.length === 0) return data;
+  // Higher priority number = compared first
+  runningSorters.sort(function (a, b) {
+    var ap = typeof a.priority === 'number' ? a.priority : 0;
+    var bp = typeof b.priority === 'number' ? b.priority : 0;
+    return bp - ap;
+  });
+  sorted.sort(function (record1, record2) {
+    var _iterator2 = _createForOfIteratorHelper(runningSorters),
+      _step2;
+    try {
+      for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+        var _step2$value = _step2.value,
+          compareFn = _step2$value.compareFn,
+          order = _step2$value.order;
+        var result = compareFn(record1, record2);
+        if (result !== 0) {
+          return order === 'ascend' ? result : -result;
+        }
+      }
+    } catch (err) {
+      _iterator2.e(err);
+    } finally {
+      _iterator2.f();
+    }
+    return 0;
+  });
+  return sorted;
+}
+export var applyTablePipeline = function applyTablePipeline(_ref) {
+  var columns = _ref.columns,
+    dataSource = _ref.dataSource,
+    sorter = _ref.sorter,
+    pagination = _ref.pagination;
+  var sorterStates = sorter.columnKey != null && sorter.order ? [{
+    columnKey: sorter.columnKey,
+    order: sorter.order
+  }] : [];
+  var leafColumns = flattenColumns(columns);
+  var sorted = applySortToData(dataSource, leafColumns, sorterStates);
+  if (!pagination) {
+    return {
+      currentDataSource: sorted,
+      total: sorted.length
+    };
+  }
+  var start = (pagination.current - 1) * pagination.pageSize;
+  var end = start + pagination.pageSize;
+  return {
+    currentDataSource: sorted.slice(start, end),
+    total: sorted.length
+  };
+};
+function collectSorterStates(columns) {
+  var _a;
+  var leaves = flattenColumns(columns);
+  var states = [];
+  var _iterator3 = _createForOfIteratorHelper(leaves),
+    _step3;
+  try {
+    for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+      var col = _step3.value;
+      var order = (_a = col.sortOrder) !== null && _a !== void 0 ? _a : col.defaultSortOrder;
+      if (col.key != null && order) {
+        states.push({
+          columnKey: col.key,
+          order: order
+        });
+      }
+    }
+  } catch (err) {
+    _iterator3.e(err);
+  } finally {
+    _iterator3.f();
+  }
+  return states;
+}
+var getInitialSorter = function getInitialSorter(columns) {
+  var states = collectSorterStates(columns);
+  if (states.length === 0) return {};
+  return {
+    columnKey: states[0].columnKey,
+    order: states[0].order
+  };
+};
+var getControlledSorter = function getControlledSorter(columns) {
+  var _a;
+  var leaves = flattenColumns(columns);
+  var controlledColumn = leaves.find(function (column) {
+    return column.sortOrder !== undefined;
+  });
+  if (!controlledColumn) {
+    return undefined;
+  }
+  return {
+    columnKey: controlledColumn.key,
+    order: (_a = controlledColumn.sortOrder) !== null && _a !== void 0 ? _a : null
+  };
+};
+export var useTableDataPipeline = function useTableDataPipeline(_ref2) {
+  var columns = _ref2.columns,
+    dataSource = _ref2.dataSource,
+    pagination = _ref2.pagination,
+    onChange = _ref2.onChange;
+  var _a, _b, _c, _d;
+  var _useControlledState = useControlledState(getInitialSorter(columns), getControlledSorter(columns)),
+    _useControlledState2 = _slicedToArray(_useControlledState, 2),
+    sorter = _useControlledState2[0],
+    setSorter = _useControlledState2[1];
+  var _useControlledState3 = useControlledState(pagination === false ? 1 : (_b = (_a = pagination === null || pagination === void 0 ? void 0 : pagination.defaultCurrent) !== null && _a !== void 0 ? _a : pagination === null || pagination === void 0 ? void 0 : pagination.current) !== null && _b !== void 0 ? _b : 1, pagination === false ? undefined : pagination === null || pagination === void 0 ? void 0 : pagination.current),
+    _useControlledState4 = _slicedToArray(_useControlledState3, 2),
+    current = _useControlledState4[0],
+    setCurrent = _useControlledState4[1];
+  var _useControlledState5 = useControlledState(pagination === false ? 10 : (_d = (_c = pagination === null || pagination === void 0 ? void 0 : pagination.defaultPageSize) !== null && _c !== void 0 ? _c : pagination === null || pagination === void 0 ? void 0 : pagination.pageSize) !== null && _d !== void 0 ? _d : 10, pagination === false ? undefined : pagination === null || pagination === void 0 ? void 0 : pagination.pageSize),
+    _useControlledState6 = _slicedToArray(_useControlledState5, 2),
+    pageSize = _useControlledState6[0],
+    setPageSize = _useControlledState6[1];
+  var mergedPagination = pagination === false ? false : {
+    current: current,
+    pageSize: pageSize
+  };
+  var sorterStates = useMemo(function () {
+    // Start with the primary user-toggled sorter
+    var primary = sorter.columnKey != null && sorter.order ? [{
+      columnKey: sorter.columnKey,
+      order: sorter.order
+    }] : [];
+    // Collect any other columns that have a controlled sortOrder (for multi-sort)
+    var leafColumns = flattenColumns(columns);
+    var additional = leafColumns.filter(function (col) {
+      return col.key != null && col.sortOrder && col.key !== sorter.columnKey;
+    }).map(function (col) {
+      return {
+        columnKey: col.key,
+        order: col.sortOrder
+      };
+    });
+    return [].concat(primary, _toConsumableArray(additional));
+  }, [sorter, columns]);
+  var result = useMemo(function () {
+    return applyTablePipeline({
+      columns: columns,
+      dataSource: dataSource,
+      sorter: sorter,
+      pagination: mergedPagination
+    });
+  }, [columns, dataSource, sorter, mergedPagination]);
+  // useMemoizedFn: stable ref, always calls latest closure — no stale deps risk
+  var wrappedSetSorter = useMemoizedFn(function (updater) {
+    var nextSorter = typeof updater === 'function' ? updater(sorter) : updater;
+    setSorter(nextSorter);
+    // Reset pagination to page 1 when sorting changes
+    if (mergedPagination !== false) {
+      setCurrent(1);
+    }
+    if (onChange) {
+      var resetPagination = mergedPagination === false ? false : {
+        current: 1,
+        pageSize: pageSize
+      };
+      var nextResult = applyTablePipeline({
+        columns: columns,
+        dataSource: dataSource,
+        sorter: nextSorter,
+        pagination: resetPagination
+      });
+      onChange({
+        currentDataSource: nextResult.currentDataSource,
+        action: 'sort'
+      });
+    }
+  });
+  var wrappedSetPagination = useMemoizedFn(function (updater) {
+    if (pagination === false) return;
+    var currentValue = {
+      current: current,
+      pageSize: pageSize
+    };
+    var nextValue = typeof updater === 'function' ? updater(currentValue) : updater;
+    setCurrent(nextValue.current);
+    setPageSize(nextValue.pageSize);
+    if (onChange) {
+      var nextResult = applyTablePipeline({
+        columns: columns,
+        dataSource: dataSource,
+        sorter: sorter,
+        pagination: nextValue
+      });
+      onChange({
+        currentDataSource: nextResult.currentDataSource,
+        action: 'paginate'
+      });
+    }
+  });
+  return Object.assign(Object.assign({}, result), {
+    sorter: sorter,
+    sorterStates: sorterStates,
+    pagination: mergedPagination,
+    setSorter: wrappedSetSorter,
+    setPagination: wrappedSetPagination
+  });
+};
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["components/Table/src/components/Table/core/useTableDataPipeline.ts","components/Table/core/useTableDataPipeline.js"],"names":["useMemo","useControlledState","useMemoizedFn","isColumnGroup","col","Array","isArray","children","flattenColumns","columns","result","_iterator","_createForOfIteratorHelper","_step","s","n","done","value","push","apply","_toConsumableArray","err","e","f","getSortFunction","sorter","_typeof","compare","getMultiplePriority","column","multiple","applySortToData","data","sorterStates","length","sorted","runningSorters","map","state","find","key","columnKey","compareFn","priority","order","filter","Boolean","sort","a","b","ap","bp","record1","record2","_iterator2","_step2","_step2$value","applyTablePipeline","_ref","dataSource","pagination","leafColumns","currentDataSource","total","start","current","pageSize","end","slice","collectSorterStates","_a","leaves","states","_iterator3","_step3","sortOrder","defaultSortOrder","getInitialSorter","getControlledSorter","controlledColumn","undefined","useTableDataPipeline","_ref2","onChange","_b","_c","_d","_useControlledState","_useControlledState2","_slicedToArray","setSorter","_useControlledState3","defaultCurrent","_useControlledState4","setCurrent","_useControlledState5","defaultPageSize","_useControlledState6","setPageSize","mergedPagination","primary","additional","concat","wrappedSetSorter","updater","nextSorter","resetPagination","nextResult","action","wrappedSetPagination","currentValue","nextValue","Object","assign","setPagination"],"mappings":";;;;;;AAAA,SAASA,OAAO,QAAQ,OAAO;AAC/B,SAASC,kBAAkB,EAAEC,aAAa,QAAQ,eAAe;AAIjE,SAASC,aAAaA,CAAIC,GAAuB,EAAA;EAC/C,OAAO,UAAU,IAAIA,GAAG,IAAIC,KAAK,CAACC,OAAO,CAAEF,GAA2B,CAACG,QAAQ,CAAC;AAClF;AAEA,SAASC,cAAcA,CAAIC,OAA6B,EAAA;EACtD,IAAMC,MAAM,GAAqB,EAAE;EAAC,IAAAC,SAAA,GAAAC,0BAAA,CAClBH,OAAO;IAAAI,KAAA;EAAA;IAAzB,KAAAF,SAAA,CAAAG,CAAA,MAAAD,KAAA,GAAAF,SAAA,CAAAI,CAAA,IAAAC,IAAA,GAA2B;MAAA,IAAhBZ,GAAG,GAAAS,KAAA,CAAAI,KAAA;MACZ,IAAId,aAAa,CAACC,GAAG,CAAC,EAAE;QACtBM,MAAM,CAACQ,IAAI,CAAAC,KAAA,CAAXT,MAAM,EAAAU,kBAAA,CAASZ,cAAc,CAACJ,GAAG,CAACG,QAAQ,CAAC,EAAC;MAC9C,CAAC,MAAM;QACLG,MAAM,CAACQ,IAAI,CAACd,GAAG,CAAC;MAClB;IACF;EAAC,SAAAiB,GAAA;IAAAV,SAAA,CAAAW,CAAA,CAAAD,GAAA;EAAA;IAAAV,SAAA,CAAAY,CAAA;EAAA;EACD,OAAOb,MAAM;AACf;AA6CA,SAASc,eAAeA,CACtBC,MAAgC,EAAA;EAEhC,IAAI,OAAOA,MAAM,KAAK,UAAU,EAAE,OAAOA,MAAM;EAC/C,IAAIA,MAAM,IAAIC,OAAA,CAAOD,MAAM,MAAK,QAAQ,IAAI,SAAS,IAAIA,MAAM,EAAE,OAAOA,MAAM,CAACE,OAAO;EACtF,OAAO,KAAK;AACd;AAEA,SAASC,mBAAmBA,CAAIC,MAAsB,EAAA;EACpD,IAAIA,MAAM,CAACJ,MAAM,IAAIC,OAAA,CAAOG,MAAM,CAACJ,MAAM,MAAK,QAAQ,IAAI,UAAU,IAAII,MAAM,CAACJ,MAAM,EAAE;IACrF,OAAQI,MAAM,CAACJ,MAAqC,CAACK,QAAQ;EAC/D;EACA,OAAO,KAAK;AACd;AAEA,SAASC,eAAeA,CACtBC,IAAS,EACTvB,OAAyB,EACzBwB,YAAqC,EAAA;EAErC,IAAIA,YAAY,CAACC,MAAM,KAAK,CAAC,EAAE,OAAOF,IAAI;EAE1C,IAAMG,MAAM,GAAAf,kBAAA,CAAOY,IAAI,CAAC;EAExB,IAAMI,cAAc,GAAGH,YAAY,CAChCI,GAAG,CAAC,UAACC,KAAK,EAAI;IACb,IAAMT,MAAM,GAAGpB,OAAO,CAAC8B,IAAI,CAAC,UAACnC,GAAG;MAAA,OAAKA,GAAG,CAACoC,GAAG,KAAKF,KAAK,CAACG,SAAS;IAAA,EAAC;IACjE,IAAI,CAACZ,MAAM,EAAE,OAAO,IAAI;IACxB,IAAMa,SAAS,GAAGlB,eAAe,CAACK,MAAM,CAACJ,MAAM,CAAC;IAChD,IAAI,CAACiB,SAAS,EAAE,OAAO,IAAI;IAC3B,IAAMC,QAAQ,GAAGf,mBAAmB,CAACC,MAAM,CAAC;IAC5C,OAAO;MAAEa,SAAS,EAATA,SAAS;MAAEE,KAAK,EAAEN,KAAK,CAACM,KAAK;MAAED,QAAQ,EAARA;IAAQ,CAAE;EACpD,CAAC,CAAC,CACDE,MAAM,CAACC,OAAO,CAAmG;EAEpH,IAAIV,cAAc,CAACF,MAAM,KAAK,CAAC,EAAE,OAAOF,IAAI;EAE5C;EACAI,cAAc,CAACW,IAAI,CAAC,UAACC,CAAC,EAAEC,CAAC,EAAI;IAC3B,IAAMC,EAAE,GAAG,OAAOF,CAAC,CAACL,QAAQ,KAAK,QAAQ,GAAGK,CAAC,CAACL,QAAQ,GAAG,CAAC;IAC1D,IAAMQ,EAAE,GAAG,OAAOF,CAAC,CAACN,QAAQ,KAAK,QAAQ,GAAGM,CAAC,CAACN,QAAQ,GAAG,CAAC;IAC1D,OAAOQ,EAAE,GAAGD,EAAE;EAChB,CAAC,CAAC;EAEFf,MAAM,CAACY,IAAI,CAAC,UAACK,OAAO,EAAEC,OAAO,EAAI;IAAA,IAAAC,UAAA,GAAA1C,0BAAA,CACIwB,cAAc;MAAAmB,MAAA;IAAA;MAAjD,KAAAD,UAAA,CAAAxC,CAAA,MAAAyC,MAAA,GAAAD,UAAA,CAAAvC,CAAA,IAAAC,IAAA,GAAmD;QAAA,IAAAwC,YAAA,GAAAD,MAAA,CAAAtC,KAAA;UAAtCyB,SAAS,GAAAc,YAAA,CAATd,SAAS;UAAEE,KAAK,GAAAY,YAAA,CAALZ,KAAK;QAC3B,IAAMlC,MAAM,GAAGgC,SAAS,CAACU,OAAO,EAAEC,OAAO,CAAC;QAC1C,IAAI3C,MAAM,KAAK,CAAC,EAAE;UAChB,OAAOkC,KAAK,KAAK,QAAQ,GAAGlC,MAAM,GAAG,CAACA,MAAM;QAC9C;MACF;IAAC,SAAAW,GAAA;MAAAiC,UAAA,CAAAhC,CAAA,CAAAD,GAAA;IAAA;MAAAiC,UAAA,CAAA/B,CAAA;IAAA;IACD,OAAO,CAAC;EACV,CAAC,CAAC;EAEF,OAAOY,MAAM;AACf;AAEA,OAAO,IAAMsB,kBAAkB,GAAG,SAArBA,kBAAkBA,CAAAC,IAAA,EAKE;EAAA,IAJ/BjD,OAAO,GAAAiD,IAAA,CAAPjD,OAAO;IACPkD,UAAU,GAAAD,IAAA,CAAVC,UAAU;IACVlC,MAAM,GAAAiC,IAAA,CAANjC,MAAM;IACNmC,UAAU,GAAAF,IAAA,CAAVE,UAAU;EAEV,IAAM3B,YAAY,GAChBR,MAAM,CAACgB,SAAS,IAAI,IAAI,IAAIhB,MAAM,CAACmB,KAAK,GACpC,CAAC;IAAEH,SAAS,EAAEhB,MAAM,CAACgB,SAAS;IAAEG,KAAK,EAAEnB,MAAM,CAACmB;EAAK,CAAE,CAAC,GACtD,EAAE;EAER,IAAMiB,WAAW,GAAGrD,cAAc,CAACC,OAAO,CAAC;EAC3C,IAAM0B,MAAM,GAAGJ,eAAe,CAAC4B,UAAU,EAAEE,WAAW,EAAE5B,YAAY,CAAC;EAErE,IAAI,CAAC2B,UAAU,EAAE;IACf,OAAO;MAAEE,iBAAiB,EAAE3B,MAAM;MAAE4B,KAAK,EAAE5B,MAAM,CAACD;IAAM,CAAE;EAC5D;EAEA,IAAM8B,KAAK,GAAG,CAACJ,UAAU,CAACK,OAAO,GAAG,CAAC,IAAIL,UAAU,CAACM,QAAQ;EAC5D,IAAMC,GAAG,GAAGH,KAAK,GAAGJ,UAAU,CAACM,QAAQ;EAEvC,OAAO;IACLJ,iBAAiB,EAAE3B,MAAM,CAACiC,KAAK,CAACJ,KAAK,EAAEG,GAAG,CAAC;IAC3CJ,KAAK,EAAE5B,MAAM,CAACD;ECjEd,CDkED;AACH,CAAC;AAED,SAASmC,mBAAmBA,CAAI5D,OAA6B,EAAA;EClEzD,IAAI6D,EAAE;EDmER,IAAMC,MAAM,GAAG/D,cAAc,CAACC,OAAO,CAAC;EACtC,IAAM+D,MAAM,GAA4B,EAAE;EAAC,IAAAC,UAAA,GAAA7D,0BAAA,CACzB2D,MAAM;IAAAG,MAAA;EAAA;IAAxB,KAAAD,UAAA,CAAA3D,CAAA,MAAA4D,MAAA,GAAAD,UAAA,CAAA1D,CAAA,IAAAC,IAAA,GAA0B;MAAA,IAAfZ,GAAG,GAAAsE,MAAA,CAAAzD,KAAA;MACZ,IAAM2B,KAAK,GAAG,CAAA0B,EAAA,GAAAlE,GAAG,CAACuE,SAAS,MAAA,IAAA,IAAAL,EAAA,KAAA,KAAA,CAAA,GAAAA,EAAA,GAAIlE,GAAG,CAACwE,gBAAgB;MACnD,IAAIxE,GAAG,CAACoC,GAAG,IAAI,IAAI,IAAII,KAAK,EAAE;QAC5B4B,MAAM,CAACtD,IAAI,CAAC;UAAEuB,SAAS,EAAErC,GAAG,CAACoC,GAAG;UAAEI,KAAK,EAALA;QAAK,CAAE,CAAC;MAC5C;IACF;EAAC,SAAAvB,GAAA;IAAAoD,UAAA,CAAAnD,CAAA,CAAAD,GAAA;EAAA;IAAAoD,UAAA,CAAAlD,CAAA;EAAA;EACD,OAAOiD,MAAM;AACf;AAEA,IAAMK,gBAAgB,GAAG,SAAnBA,gBAAgBA,CAAQpE,OAA6B,EAAsB;EAC/E,IAAM+D,MAAM,GAAGH,mBAAmB,CAAC5D,OAAO,CAAC;EAC3C,IAAI+D,MAAM,CAACtC,MAAM,KAAK,CAAC,EAAE,OAAO,CAAA,CAAE;EAClC,OAAO;IAAEO,SAAS,EAAE+B,MAAM,CAAC,CAAC,CAAC,CAAC/B,SAAS;IAAEG,KAAK,EAAE4B,MAAM,CAAC,CAAC,CAAC,CAAC5B;EAAK,CAAE;AACnE,CAAC;AAED,IAAMkC,mBAAmB,GAAG,SAAtBA,mBAAmBA,CAAQrE,OAA6B,EAAkC;EClE5F,IAAI6D,EAAE;EDmER,IAAMC,MAAM,GAAG/D,cAAc,CAACC,OAAO,CAAC;EACtC,IAAMsE,gBAAgB,GAAGR,MAAM,CAAChC,IAAI,CAAC,UAACV,MAAM;IAAA,OAAKA,MAAM,CAAC8C,SAAS,KAAKK,SAAS;EAAA,EAAC;EAEhF,IAAI,CAACD,gBAAgB,EAAE;IACrB,OAAOC,SAAS;EAClB;EAEA,OAAO;IACLvC,SAAS,EAAEsC,gBAAgB,CAACvC,GAAG;IAC/BI,KAAK,EAAE,CAAA0B,EAAA,GAAAS,gBAAgB,CAACJ,SAAS,MAAA,IAAA,IAAAL,EAAA,KAAA,KAAA,CAAA,GAAAA,EAAA,GAAI;ECnErC,CDoED;AACH,CAAC;AAED,OAAO,IAAMW,oBAAoB,GAAG,SAAvBA,oBAAoBA,CAAAC,KAAA,EAKiC;EAAA,IAJhEzE,OAAO,GAAAyE,KAAA,CAAPzE,OAAO;IACPkD,UAAU,GAAAuB,KAAA,CAAVvB,UAAU;IACVC,UAAU,GAAAsB,KAAA,CAAVtB,UAAU;IACVuB,QAAQ,GAAAD,KAAA,CAARC,QAAQ;ECxEN,IAAIb,EAAE,EAAEc,EAAE,EAAEC,EAAE,EAAEC,EAAE;ED0EpB,IAAAC,mBAAA,GAA4BtF,kBAAkB,CAC5C4E,gBAAgB,CAACpE,OAAO,CAAC,EACzBqE,mBAAmB,CAACrE,OAAO,CAAC,CAC7B;IAAA+E,oBAAA,GAAAC,cAAA,CAAAF,mBAAA;IAHM9D,MAAM,GAAA+D,oBAAA;IAAEE,SAAS,GAAAF,oBAAA;EAIxB,IAAAG,oBAAA,GAA8B1F,kBAAkB,CAC9C2D,UAAU,KAAK,KAAK,GAAG,CAAC,GAAI,CAAAwB,EAAA,GAAA,CAAAd,EAAA,GAAAV,UAAU,KAAA,IAAA,IAAVA,UAAU,KAAA,KAAA,CAAA,GAAA,KAAA,CAAA,GAAVA,UAAU,CAAEgC,cAAc,MAAA,IAAA,IAAAtB,EAAA,KAAA,KAAA,CAAA,GAAAA,EAAA,GAAIV,UAAU,KAAA,IAAA,IAAVA,UAAU,KAAA,KAAA,CAAA,GAAA,KAAA,CAAA,GAAVA,UAAU,CAAEK,OAAO,MAAA,IAAA,IAAAmB,EAAA,KAAA,KAAA,CAAA,GAAAA,EAAA,GAAI,CAAE,EACnFxB,UAAU,KAAK,KAAK,GAAGoB,SAAS,GAAGpB,UAAU,KAAA,IAAA,IAAVA,UAAU,KAAA,KAAA,CAAA,GAAA,KAAA,CAAA,GAAVA,UAAU,CAAEK,OAAO,CACvD;IAAA4B,oBAAA,GAAAJ,cAAA,CAAAE,oBAAA;IAHM1B,OAAO,GAAA4B,oBAAA;IAAEC,UAAU,GAAAD,oBAAA;EAI1B,IAAAE,oBAAA,GAAgC9F,kBAAkB,CAChD2D,UAAU,KAAK,KAAK,GAAG,EAAE,GAAI,CAAA0B,EAAA,GAAA,CAAAD,EAAA,GAAAzB,UAAU,KAAA,IAAA,IAAVA,UAAU,KAAA,KAAA,CAAA,GAAA,KAAA,CAAA,GAAVA,UAAU,CAAEoC,eAAe,MAAA,IAAA,IAAAX,EAAA,KAAA,KAAA,CAAA,GAAAA,EAAA,GAAIzB,UAAU,KAAA,IAAA,IAAVA,UAAU,KAAA,KAAA,CAAA,GAAA,KAAA,CAAA,GAAVA,UAAU,CAAEM,QAAQ,MAAA,IAAA,IAAAoB,EAAA,KAAA,KAAA,CAAA,GAAAA,EAAA,GAAI,EAAG,EACvF1B,UAAU,KAAK,KAAK,GAAGoB,SAAS,GAAGpB,UAAU,KAAA,IAAA,IAAVA,UAAU,KAAA,KAAA,CAAA,GAAA,KAAA,CAAA,GAAVA,UAAU,CAAEM,QAAQ,CACxD;IAAA+B,oBAAA,GAAAR,cAAA,CAAAM,oBAAA;IAHM7B,QAAQ,GAAA+B,oBAAA;IAAEC,WAAW,GAAAD,oBAAA;EAK5B,IAAME,gBAAgB,GAAGvC,UAAU,KAAK,KAAK,GACzC,KAAK,GACL;IAAEK,OAAO,EAAPA,OAAO;IAAEC,QAAQ,EAARA;EAAQ,CAAE;EAEzB,IAAMjC,YAAY,GAA4BjC,OAAO,CAAC,YAAK;IACzD;IACA,IAAMoG,OAAO,GACX3E,MAAM,CAACgB,SAAS,IAAI,IAAI,IAAIhB,MAAM,CAACmB,KAAK,GACpC,CAAC;MAAEH,SAAS,EAAEhB,MAAM,CAACgB,SAAS;MAAEG,KAAK,EAAEnB,MAAM,CAACmB;IAAK,CAAE,CAAC,GACtD,EAAE;IAER;IACA,IAAMiB,WAAW,GAAGrD,cAAc,CAACC,OAAO,CAAC;IAC3C,IAAM4F,UAAU,GAAGxC,WAAW,CAC3BhB,MAAM,CAAC,UAACzC,GAAG;MAAA,OAAKA,GAAG,CAACoC,GAAG,IAAI,IAAI,IAAIpC,GAAG,CAACuE,SAAS,IAAIvE,GAAG,CAACoC,GAAG,KAAKf,MAAM,CAACgB,SAAS;IAAA,EAAC,CACjFJ,GAAG,CAAC,UAACjC,GAAG;MAAA,OAAM;QAAEqC,SAAS,EAAErC,GAAG,CAACoC,GAAI;QAAEI,KAAK,EAAExC,GAAG,CAACuE;MAA2C,CAAE;IAAA,CAAC,CAAC;IAElG,UAAA2B,MAAA,CAAWF,OAAO,EAAAhF,kBAAA,CAAKiF,UAAU;EACnC,CAAC,EAAE,CAAC5E,MAAM,EAAEhB,OAAO,CAAC,CAAC;EAErB,IAAMC,MAAM,GAAGV,OAAO,CACpB;IAAA,OAAMyD,kBAAkB,CAAC;MACvBhD,OAAO,EAAPA,OAAO;MACPkD,UAAU,EAAVA,UAAU;MACVlC,MAAM,EAANA,MAAM;MACNmC,UAAU,EAAEuC;ICxFd,CDyFC,CAAC;EAAA,GACF,CAAC1F,OAAO,EAAEkD,UAAU,EAAElC,MAAM,EAAE0E,gBAAgB,CAAC,CAChD;EAED;EACA,IAAMI,gBAAgB,GAAGrG,aAAa,CACpC,UAACsG,OAA6E,EAAI;IAChF,IAAMC,UAAU,GAAG,OAAOD,OAAO,KAAK,UAAU,GAAGA,OAAO,CAAC/E,MAAM,CAAC,GAAG+E,OAAO;IAC5Ed,SAAS,CAACe,UAAU,CAAC;IAErB;IACA,IAAIN,gBAAgB,KAAK,KAAK,EAAE;MAC9BL,UAAU,CAAC,CAAC,CAAC;IACf;IAEA,IAAIX,QAAQ,EAAE;MACZ,IAAMuB,eAAe,GAAGP,gBAAgB,KAAK,KAAK,GAC9C,KAAK,GACL;QAAElC,OAAO,EAAE,CAAC;QAAEC,QAAQ,EAARA;MAAQ,CAAE;MAC5B,IAAMyC,UAAU,GAAGlD,kBAAkB,CAAC;QACpChD,OAAO,EAAPA,OAAO;QACPkD,UAAU,EAAVA,UAAU;QACVlC,MAAM,EAAEgF,UAAU;QAClB7C,UAAU,EAAE8C;MC9FV,CD+FH,CAAC;MACFvB,QAAQ,CAAC;QAAErB,iBAAiB,EAAE6C,UAAU,CAAC7C,iBAAiB;QAAE8C,MAAM,EAAE;MAAM,CAAE,CAAC;IAC/E;EACF,CAAC,CACF;EAED,IAAMC,oBAAoB,GAAG3G,aAAa,CACxC,UACEsG,OACkG,EAChG;IACF,IAAI5C,UAAU,KAAK,KAAK,EAAE;IAE1B,IAAMkD,YAAY,GAAG;MAAE7C,OAAO,EAAPA,OAAO;MAAEC,QAAQ,EAARA;IAAQ,CAAE;IAC1C,IAAM6C,SAAS,GAAG,OAAOP,OAAO,KAAK,UAAU,GAAGA,OAAO,CAACM,YAAY,CAAC,GAAGN,OAAO;IAEjFV,UAAU,CAACiB,SAAS,CAAC9C,OAAO,CAAC;IAC7BiC,WAAW,CAACa,SAAS,CAAC7C,QAAQ,CAAC;IAE/B,IAAIiB,QAAQ,EAAE;MACZ,IAAMwB,UAAU,GAAGlD,kBAAkB,CAAC;QACpChD,OAAO,EAAPA,OAAO;QACPkD,UAAU,EAAVA,UAAU;QACVlC,MAAM,EAANA,MAAM;QACNmC,UAAU,EAAEmD;MCtGV,CDuGH,CAAC;MACF5B,QAAQ,CAAC;QAAErB,iBAAiB,EAAE6C,UAAU,CAAC7C,iBAAiB;QAAE8C,MAAM,EAAE;MAAU,CAAE,CAAC;IACnF;EACF,CAAC,CACF;EAED,OAAAI,MAAA,CAAAC,MAAA,CAAAD,MAAA,CAAAC,MAAA,CAAA,CAAA,CAAA,EACKvG,MAAM,CAAA,EAAA;IACTe,MAAM,EAANA,MAAM;IACNQ,YAAY,EAAZA,YAAY;IACZ2B,UAAU,EAAEuC,gBAAgB;IAC5BT,SAAS,EAAEa,gBAAgB;IAC3BW,aAAa,EAAEL;EAAoB,CAAA,CAAA;AAEvC,CAAC","file":"components/Table/core/useTableDataPipeline.js","sourcesContent":[null,"import { useMemo } from 'react';\nimport { useControlledState, useMemoizedFn } from '@1money/hooks';\nfunction isColumnGroup(col) {\n    return 'children' in col && Array.isArray(col.children);\n}\nfunction flattenColumns(columns) {\n    const result = [];\n    for (const col of columns) {\n        if (isColumnGroup(col)) {\n            result.push(...flattenColumns(col.children));\n        }\n        else {\n            result.push(col);\n        }\n    }\n    return result;\n}\nfunction getSortFunction(sorter) {\n    if (typeof sorter === 'function')\n        return sorter;\n    if (sorter && typeof sorter === 'object' && 'compare' in sorter)\n        return sorter.compare;\n    return false;\n}\nfunction getMultiplePriority(column) {\n    if (column.sorter && typeof column.sorter === 'object' && 'multiple' in column.sorter) {\n        return column.sorter.multiple;\n    }\n    return false;\n}\nfunction applySortToData(data, columns, sorterStates) {\n    if (sorterStates.length === 0)\n        return data;\n    const sorted = [...data];\n    const runningSorters = sorterStates\n        .map((state) => {\n        const column = columns.find((col) => col.key === state.columnKey);\n        if (!column)\n            return null;\n        const compareFn = getSortFunction(column.sorter);\n        if (!compareFn)\n            return null;\n        const priority = getMultiplePriority(column);\n        return { compareFn, order: state.order, priority };\n    })\n        .filter(Boolean);\n    if (runningSorters.length === 0)\n        return data;\n    // Higher priority number = compared first\n    runningSorters.sort((a, b) => {\n        const ap = typeof a.priority === 'number' ? a.priority : 0;\n        const bp = typeof b.priority === 'number' ? b.priority : 0;\n        return bp - ap;\n    });\n    sorted.sort((record1, record2) => {\n        for (const { compareFn, order } of runningSorters) {\n            const result = compareFn(record1, record2);\n            if (result !== 0) {\n                return order === 'ascend' ? result : -result;\n            }\n        }\n        return 0;\n    });\n    return sorted;\n}\nexport const applyTablePipeline = ({ columns, dataSource, sorter, pagination, }) => {\n    const sorterStates = sorter.columnKey != null && sorter.order\n        ? [{ columnKey: sorter.columnKey, order: sorter.order }]\n        : [];\n    const leafColumns = flattenColumns(columns);\n    const sorted = applySortToData(dataSource, leafColumns, sorterStates);\n    if (!pagination) {\n        return { currentDataSource: sorted, total: sorted.length };\n    }\n    const start = (pagination.current - 1) * pagination.pageSize;\n    const end = start + pagination.pageSize;\n    return {\n        currentDataSource: sorted.slice(start, end),\n        total: sorted.length,\n    };\n};\nfunction collectSorterStates(columns) {\n    var _a;\n    const leaves = flattenColumns(columns);\n    const states = [];\n    for (const col of leaves) {\n        const order = (_a = col.sortOrder) !== null && _a !== void 0 ? _a : col.defaultSortOrder;\n        if (col.key != null && order) {\n            states.push({ columnKey: col.key, order });\n        }\n    }\n    return states;\n}\nconst getInitialSorter = (columns) => {\n    const states = collectSorterStates(columns);\n    if (states.length === 0)\n        return {};\n    return { columnKey: states[0].columnKey, order: states[0].order };\n};\nconst getControlledSorter = (columns) => {\n    var _a;\n    const leaves = flattenColumns(columns);\n    const controlledColumn = leaves.find((column) => column.sortOrder !== undefined);\n    if (!controlledColumn) {\n        return undefined;\n    }\n    return {\n        columnKey: controlledColumn.key,\n        order: (_a = controlledColumn.sortOrder) !== null && _a !== void 0 ? _a : null,\n    };\n};\nexport const useTableDataPipeline = ({ columns, dataSource, pagination, onChange, }) => {\n    var _a, _b, _c, _d;\n    const [sorter, setSorter] = useControlledState(getInitialSorter(columns), getControlledSorter(columns));\n    const [current, setCurrent] = useControlledState(pagination === false ? 1 : ((_b = (_a = pagination === null || pagination === void 0 ? void 0 : pagination.defaultCurrent) !== null && _a !== void 0 ? _a : pagination === null || pagination === void 0 ? void 0 : pagination.current) !== null && _b !== void 0 ? _b : 1), pagination === false ? undefined : pagination === null || pagination === void 0 ? void 0 : pagination.current);\n    const [pageSize, setPageSize] = useControlledState(pagination === false ? 10 : ((_d = (_c = pagination === null || pagination === void 0 ? void 0 : pagination.defaultPageSize) !== null && _c !== void 0 ? _c : pagination === null || pagination === void 0 ? void 0 : pagination.pageSize) !== null && _d !== void 0 ? _d : 10), pagination === false ? undefined : pagination === null || pagination === void 0 ? void 0 : pagination.pageSize);\n    const mergedPagination = pagination === false\n        ? false\n        : { current, pageSize };\n    const sorterStates = useMemo(() => {\n        // Start with the primary user-toggled sorter\n        const primary = sorter.columnKey != null && sorter.order\n            ? [{ columnKey: sorter.columnKey, order: sorter.order }]\n            : [];\n        // Collect any other columns that have a controlled sortOrder (for multi-sort)\n        const leafColumns = flattenColumns(columns);\n        const additional = leafColumns\n            .filter((col) => col.key != null && col.sortOrder && col.key !== sorter.columnKey)\n            .map((col) => ({ columnKey: col.key, order: col.sortOrder }));\n        return [...primary, ...additional];\n    }, [sorter, columns]);\n    const result = useMemo(() => applyTablePipeline({\n        columns,\n        dataSource,\n        sorter,\n        pagination: mergedPagination,\n    }), [columns, dataSource, sorter, mergedPagination]);\n    // useMemoizedFn: stable ref, always calls latest closure — no stale deps risk\n    const wrappedSetSorter = useMemoizedFn((updater) => {\n        const nextSorter = typeof updater === 'function' ? updater(sorter) : updater;\n        setSorter(nextSorter);\n        // Reset pagination to page 1 when sorting changes\n        if (mergedPagination !== false) {\n            setCurrent(1);\n        }\n        if (onChange) {\n            const resetPagination = mergedPagination === false\n                ? false\n                : { current: 1, pageSize };\n            const nextResult = applyTablePipeline({\n                columns,\n                dataSource,\n                sorter: nextSorter,\n                pagination: resetPagination,\n            });\n            onChange({ currentDataSource: nextResult.currentDataSource, action: 'sort' });\n        }\n    });\n    const wrappedSetPagination = useMemoizedFn((updater) => {\n        if (pagination === false)\n            return;\n        const currentValue = { current, pageSize };\n        const nextValue = typeof updater === 'function' ? updater(currentValue) : updater;\n        setCurrent(nextValue.current);\n        setPageSize(nextValue.pageSize);\n        if (onChange) {\n            const nextResult = applyTablePipeline({\n                columns,\n                dataSource,\n                sorter,\n                pagination: nextValue,\n            });\n            onChange({ currentDataSource: nextResult.currentDataSource, action: 'paginate' });\n        }\n    });\n    return Object.assign(Object.assign({}, result), { sorter,\n        sorterStates, pagination: mergedPagination, setSorter: wrappedSetSorter, setPagination: wrappedSetPagination });\n};"],"sourceRoot":"../../../../../../../../../../src"}

package/es/components/Table/core/useTableExpand.d.ts

@@ -0,0 +1,9 @@
+import type { Key } from 'react';
+import type { TableExpandableConfig } from '../interface';
+export declare const useTableExpand: <T>({ expandable, }: {
+    expandable?: TableExpandableConfig<T>;
+}) => {
+    mergedExpandedRowKeys: Key[];
+    triggerExpand: (recordKey: Key, record: T) => void;
+    onKernelExpand: (expanded: boolean, record: T, recordKey: Key) => void;
+};

package/es/components/Table/core/useTableExpand.js

@@ -0,0 +1,38 @@
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import { useControlledState, useMemoizedFn } from '@1money/hooks';
+export var useTableExpand = function useTableExpand(_ref) {
+  var expandable = _ref.expandable;
+  var _a;
+  var _useControlledState = useControlledState((_a = expandable === null || expandable === void 0 ? void 0 : expandable.defaultExpandedRowKeys) !== null && _a !== void 0 ? _a : [], expandable === null || expandable === void 0 ? void 0 : expandable.expandedRowKeys),
+    _useControlledState2 = _slicedToArray(_useControlledState, 2),
+    mergedExpandedRowKeys = _useControlledState2[0],
+    setMergedExpandedRowKeys = _useControlledState2[1];
+  var triggerExpand = useMemoizedFn(function (recordKey, record) {
+    var _a, _b;
+    var expanded = mergedExpandedRowKeys.includes(recordKey);
+    var nextKeys = expanded ? mergedExpandedRowKeys.filter(function (key) {
+      return key !== recordKey;
+    }) : [].concat(_toConsumableArray(mergedExpandedRowKeys), [recordKey]);
+    setMergedExpandedRowKeys(nextKeys);
+    (_a = expandable === null || expandable === void 0 ? void 0 : expandable.onExpand) === null || _a === void 0 ? void 0 : _a.call(expandable, !expanded, record);
+    (_b = expandable === null || expandable === void 0 ? void 0 : expandable.onExpandedRowsChange) === null || _b === void 0 ? void 0 : _b.call(expandable, nextKeys);
+  });
+  // Called by the kernel's onExpand (e.g. expandRowByClick) — updates state
+  // and delegates to user callbacks
+  var onKernelExpand = useMemoizedFn(function (expanded, record, recordKey) {
+    var _a, _b;
+    var nextKeys = expanded ? [].concat(_toConsumableArray(mergedExpandedRowKeys), [recordKey]) : mergedExpandedRowKeys.filter(function (key) {
+      return key !== recordKey;
+    });
+    setMergedExpandedRowKeys(nextKeys);
+    (_a = expandable === null || expandable === void 0 ? void 0 : expandable.onExpand) === null || _a === void 0 ? void 0 : _a.call(expandable, expanded, record);
+    (_b = expandable === null || expandable === void 0 ? void 0 : expandable.onExpandedRowsChange) === null || _b === void 0 ? void 0 : _b.call(expandable, nextKeys);
+  });
+  return {
+    mergedExpandedRowKeys: mergedExpandedRowKeys,
+    triggerExpand: triggerExpand,
+    onKernelExpand: onKernelExpand
+  };
+};
+//# sourceMappingURL=data:application/json;charset=utf8;base64,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