@1money/component-ui 0.0.46 → 0.0.48

package/es/components/Table/features/SelectionColumn.js

@@ -1,11 +1,24 @@
+var __rest = this && this.__rest || function (s, e) {
+  var t = {};
+  for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
+  if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+    if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
+  }
+  return t;
+};
 import { jsx as _jsx } from "react/jsx-runtime";
 import { Checkbox } from '../../Checkbox';
 import { Radio } from '../../Radio';
 export var SelectionControl = function SelectionControl(_ref) {
   var checked = _ref.checked,
     type = _ref.type,
-    disabled = _ref.disabled,
+    rowProps = _ref.rowProps,
     _onChange = _ref.onChange;
+  var _a = rowProps !== null && rowProps !== void 0 ? rowProps : {},
+    disabled = _a.disabled,
+    _a$ariaLabel = _a['aria-label'],
+    ariaLabel = _a$ariaLabel === void 0 ? 'Select row' : _a$ariaLabel,
+    rest = __rest(_a, ["disabled", 'aria-label']);
   if (type === 'radio') {
     return _jsx(Radio, {
       checked: checked,
@@ -13,17 +26,17 @@ export var SelectionControl = function SelectionControl(_ref) {
       onChange: function onChange() {
         return _onChange();
       },
-      "aria-label": "Select row"
+      "aria-label": ariaLabel
     });
   }
-  return _jsx(Checkbox, {
+  return _jsx(Checkbox, Object.assign({}, rest, {
     checked: checked,
     disabled: disabled,
     onChange: function onChange() {
       return _onChange();
     },
-    "aria-label": "Select row"
-  });
+    "aria-label": ariaLabel
+  }));
 };
 export var SelectionHeaderControl = function SelectionHeaderControl(_ref2) {
   var checked = _ref2.checked,
@@ -38,4 +51,4 @@ export var SelectionHeaderControl = function SelectionHeaderControl(_ref2) {
     "aria-label": "Select all rows"
   });
 };
-//# sourceMappingURL=data:application/json;charset=utf8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf8;base64,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

package/es/components/Table/interface.d.ts

@@ -1,23 +1,32 @@
 import type React from 'react';
 import type { CSSProperties, HTMLAttributes, Key, ReactNode } from 'react';
+import type { CheckboxProps } from "../Checkbox";
 import type { EmptyProps } from "../Empty";
+import type { DataIndex as InternalDataIndex } from './internal/kernel/interface';
 export type TableSize = 'large' | 'small';
 export type TableVariant = 'fill' | 'stroke';
 export type TableAlign = 'left' | 'center' | 'right';
 export type TableSortOrder = 'ascend' | 'descend' | null;
-export type TableAction = 'paginate' | 'sort';
+export type TableAction = 'paginate' | 'sort' | 'filter';
 export type TableLayout = 'auto' | 'fixed';
 export type TableDirection = 'ltr' | 'rtl';
+/** Default record shape. */
+export type TableRecord = Record<string, any>;
+/**
+ * Path used to derive a value from a record. Re-exported from the kernel so the
+ * recursive deep paths) instead of the previous narrower union.
+ */
+export type TableDataIndex<T extends TableRecord = TableRecord> = InternalDataIndex<T>;
 export interface TablePaginationConfig {
     current?: number;
     defaultCurrent?: number;
     pageSize?: number;
     defaultPageSize?: number;
 }
-export interface TableCellRenderMeta<T> {
+export interface TableCellRenderMeta<T extends TableRecord = TableRecord> {
     column: TableColumn<T>;
 }
-export interface TableHeaderRenderMeta<T> {
+export interface TableHeaderRenderMeta<T extends TableRecord = TableRecord> {
     column: TableColumn<T>;
 }
 export interface TableCellContentValue {
@@ -26,7 +35,7 @@ export interface TableCellContentValue {
     leading?: ReactNode;
     trailing?: ReactNode;
 }
-export interface TableRenderedCell<T> {
+export interface TableRenderedCell<T extends TableRecord = TableRecord> {
     children?: ReactNode;
     props?: {
         colSpan?: number;
@@ -34,16 +43,18 @@ export interface TableRenderedCell<T> {
         className?: string;
         style?: CSSProperties;
     };
+    /** Reserved for future record/column-aware overrides; preserves T for variance. */
+    __recordType?: T;
 }
-export interface TableColumnSorterConfig<T> {
+export interface TableColumnSorterConfig<T extends TableRecord = TableRecord> {
     compare: (a: T, b: T) => number;
     /** Priority number for multi-column sort. Columns with higher values are compared first. */
     multiple: number;
 }
 export type TableGetComponentProps<T> = (data: T, index?: number) => HTMLAttributes<HTMLElement> & React.TdHTMLAttributes<HTMLElement>;
-export type TableRowClassName<T> = string | ((record: T, index: number, indent: number) => string);
+export type TableRowClassName<T extends TableRecord = TableRecord> = string | ((record: T, index: number, indent: number) => string);
 type TableCustomizeComponent = React.ComponentType<any> | React.ForwardRefExoticComponent<any> | React.FC<any> | keyof React.JSX.IntrinsicElements;
-export interface TableComponents<T> {
+export interface TableComponents<T extends TableRecord = TableRecord> {
     table?: TableCustomizeComponent;
     header?: {
         table?: TableCustomizeComponent;
@@ -56,10 +67,31 @@ export interface TableComponents<T> {
         row?: TableCustomizeComponent;
         cell?: TableCustomizeComponent;
     };
+    /** Reserved to preserve record-type variance. */
+    __recordType?: T;
 }
-export interface TableColumn<T> {
+export type TableFilterValue = (Key | boolean)[];
+export interface TableColumnFilterItem {
+    text: ReactNode;
+    value: Key | boolean;
+    children?: TableColumnFilterItem[];
+}
+export interface TableFilterDropdownProps<T extends TableRecord = TableRecord> {
+    prefixCls: string;
+    setSelectedKeys: (selectedKeys: TableFilterValue) => void;
+    selectedKeys: TableFilterValue;
+    /** Apply current selection and close the dropdown. */
+    confirm: () => void;
+    /** Reset selection for this column. */
+    clearFilters?: () => void;
+    filters?: TableColumnFilterItem[];
+    visible: boolean;
+    close: () => void;
+    column: TableColumn<T>;
+}
+export interface TableColumn<T extends TableRecord = TableRecord> {
     key?: Key;
-    dataIndex?: keyof T | string | string[];
+    dataIndex?: TableDataIndex<T>;
     title?: ReactNode;
     width?: number | string;
     minWidth?: number;
@@ -76,6 +108,23 @@ export interface TableColumn<T> {
     sorter?: boolean | ((a: T, b: T) => number) | TableColumnSorterConfig<T>;
     sortOrder?: TableSortOrder;
     defaultSortOrder?: Exclude<TableSortOrder, null>;
+    filters?: TableColumnFilterItem[];
+    filteredValue?: TableFilterValue | null;
+    defaultFilteredValue?: TableFilterValue | null;
+    filterMultiple?: boolean;
+    filterMode?: 'menu' | 'tree';
+    filterSearch?: boolean | ((input: string, item: TableColumnFilterItem) => boolean);
+    filterIcon?: ReactNode | ((filtered: boolean) => ReactNode);
+    filterDropdown?: ReactNode | ((props: TableFilterDropdownProps<T>) => ReactNode);
+    filterDropdownOpen?: boolean;
+    defaultFilterDropdownOpen?: boolean;
+    /**
+     * Predicate used to filter rows when `filters` (built-in UI) or `filteredValue`
+     * (controlled) is set. Receives one filter value at a time per row; row is kept
+     * if the predicate returns `true` for ANY currently selected value.
+     */
+    onFilter?: (value: Key | boolean, record: T) => boolean;
+    onFilterDropdownOpenChange?: (open: boolean) => void;
     onCell?: TableGetComponentProps<T>;
     onHeaderCell?: TableGetComponentProps<TableColumn<T>>;
     shouldCellUpdate?: (record: T, prevRecord: T) => boolean;
@@ -83,37 +132,60 @@ export interface TableColumn<T> {
     headerClassName?: string;
     cellClassName?: string | ((value: unknown, record: T, index: number) => string);
 }
-export interface TableColumnGroup<T> extends Pick<TableColumn<T>, 'key' | 'title' | 'align' | 'className' | 'headerClassName' | 'fixed'> {
+export interface TableColumnGroup<T extends TableRecord = TableRecord> extends Pick<TableColumn<T>, 'key' | 'title' | 'align' | 'className' | 'headerClassName' | 'fixed'> {
     children: TableColumnType<T>[];
 }
-export type TableColumnType<T> = TableColumn<T> | TableColumnGroup<T>;
-export interface TableChangeMeta<T> {
+export type TableColumnType<T extends TableRecord = TableRecord> = TableColumn<T> | TableColumnGroup<T>;
+export interface TableChangeMeta<T extends TableRecord = TableRecord> {
     currentDataSource: T[];
     action: TableAction;
+    /**
+     * Current pagination state after this change. Always present so consumers can
+     * mirror the table's state.
+     */
+    pagination?: {
+        current: number;
+        pageSize: number;
+    } | false;
+    /** Current sorter (single-column shape — `{ columnKey, order }`). */
+    sorter?: {
+        columnKey?: Key;
+        order?: TableSortOrder;
+    };
+    /**
+     * Current filter selection keyed by column key. Required for controlled-mode
+     * consumers who want clicks inside the built-in filter dropdown to round-trip
+     * back to their state — e.g. `onChange={meta => setFilteredValue(meta.filters?.network ?? [])}`.
+     */
+    filters?: Record<string, TableFilterValue | null>;
 }
 export type TableRowSelectMethod = 'all' | 'none' | 'single';
-export interface TableRowSelection<T> {
+/**
+ * Properties returned from `getCheckboxProps`. Mirrors antd: any prop accepted
+ * by the underlying Checkbox EXCEPT `checked` / `defaultChecked` (those are
+ * controlled by the table) can be customized per-row.
+ */
+export type TableCheckboxProps = Partial<Omit<CheckboxProps, 'checked' | 'defaultChecked' | 'onChange'>>;
+export interface TableRowSelection<T extends TableRecord = TableRecord> {
     type?: 'checkbox' | 'radio';
     selectedRowKeys?: Key[];
     defaultSelectedRowKeys?: Key[];
     onChange?: (selectedRowKeys: Key[], selectedRows: T[], info: {
         type: TableRowSelectMethod;
     }) => void;
-    getCheckboxProps?: (record: T) => Partial<{
-        disabled: boolean;
-    }>;
+    getCheckboxProps?: (record: T) => TableCheckboxProps;
     preserveSelectedRowKeys?: boolean;
     fixed?: boolean;
     columnWidth?: number | string;
 }
-export interface TableExpandIconProps<T> {
+export interface TableExpandIconProps<T extends TableRecord = TableRecord> {
     prefixCls: string;
     expanded: boolean;
     record: T;
     expandable: boolean;
     onExpand: (record: T, e: React.MouseEvent<HTMLElement>) => void;
 }
-export interface TableExpandableConfig<T> {
+export interface TableExpandableConfig<T extends TableRecord = TableRecord> {
     expandedRowKeys?: Key[];
     defaultExpandedRowKeys?: Key[];
     defaultExpandAllRows?: boolean;
@@ -123,6 +195,8 @@ export interface TableExpandableConfig<T> {
     expandRowByClick?: boolean;
     showExpandColumn?: boolean;
     expandIcon?: (props: TableExpandIconProps<T>) => ReactNode;
+    /** Header label rendered on the auto-injected expand column. */
+    columnTitle?: ReactNode;
     columnWidth?: number | string;
     fixed?: 'left' | 'right' | boolean;
     onExpand?: (expanded: boolean, record: T) => void;
@@ -137,11 +211,19 @@ export interface TableRef {
         offset?: number;
     }) => void;
 }
-export interface TableProps<T> extends Omit<HTMLAttributes<HTMLDivElement>, 'onChange'> {
+export interface TableProps<T extends TableRecord = TableRecord> extends Omit<HTMLAttributes<HTMLDivElement>, 'onChange'> {
     prefixCls?: string;
     columns: TableColumnType<T>[];
     dataSource: T[];
-    rowKey: keyof T | ((record: T) => Key);
+    /**
+     * Row key for tracking. Accepts:
+     *   - `string` — a property name, including synthetic keys not statically known on `T`
+     *               (e.g. records carrying an injected `key` field).
+     *   - `keyof T` — type-checked property name.
+     *   - `(record) => Key` — function form for composite or computed keys.
+     * Defaults to `'key'` at runtime (kernel falls back to row index if the field is absent).
+     */
+    rowKey?: string | keyof T | ((record: T) => Key);
     size?: TableSize;
     variant?: TableVariant;
     bordered?: boolean;
@@ -170,7 +252,7 @@ export interface TableProps<T> extends Omit<HTMLAttributes<HTMLDivElement>, 'onC
     summary?: (data: readonly T[]) => ReactNode;
     onChange?: (meta: TableChangeMeta<T>) => void;
 }
-export interface VirtualTableProps<T> extends Omit<TableProps<T>, 'scroll'> {
+export interface VirtualTableProps<T extends TableRecord = TableRecord> extends Omit<TableProps<T>, 'scroll'> {
     scroll: {
         x: number;
         y: number;

package/es/components/Table/internal/kernel/FixedHolder/index.js

@@ -157,7 +157,6 @@ var FixedHolder = /*#__PURE__*/React.forwardRef(function (props, ref) {
       style: {
         tableLayout: tableLayout,
         minWidth: '100%',
-        // https://github.com/ant-design/ant-design/issues/54894
         width: scrollX
       },
       children: [isColGroupEmpty ? colGroup : _jsx(ColGroup, {
@@ -178,4 +177,4 @@ if (process.env.NODE_ENV !== 'production') {
 /** Return a table in div as fixed element which contains sticky info */
 // export default responseImmutable(FixedHolder);
 export default /*#__PURE__*/React.memo(FixedHolder);
-//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["components/Table/internal/kernel/FixedHolder/index.js","components/Table/internal/kernel/src/components/Table/internal/kernel/FixedHolder/index.tsx"],"names":["__rest","s","e","t","p","Object","prototype","hasOwnProperty","call","indexOf","getOwnPropertySymbols","i","length","propertyIsEnumerable","jsx","_jsx","jsxs","_jsxs","useContext","clsx","fillRef","React","useMemo","ColGroup","TableContext","devRenderTimes","useColumnWidth","colWidths","columCount","cloneColumns","val","undefined","join","FixedHolder","forwardRef","props","ref","process","env","NODE_ENV","className","style","noData","columns","flattenColumns","colGroup","stickyOffsets","direction","fixHeader","stickyTopOffset","stickyBottomOffset","stickyClassName","scrollX","_props$tableLayout","tableLayout","onScroll","maxContentScroll","children","restProps","_useContext","prefixCls","scrollbarSize","isSticky","getComponent","TableComponent","combinationScrollBarSize","scrollRef","useRef","setScrollRef","useCallback","element","useEffect","onWheel","currentTarget","deltaX","scrollLeft","scrollWidth","clientWidth","maxScrollWidth","nextScroll","Math","max","min","preventDefault","scrollEle","current","addEventListener","passive","removeEventListener","lastColumn","ScrollBarColumn","fixed","scrollbar","onHeaderCell","concat","columnsWithScrollbar","_toConsumableArray","flattenColumnsWithScrollbar","headerStickyOffsets","start","end","assign","map","width","mergedColumnWidth","isColGroupEmpty","noWidth","every","w","overflow","top","bottom","_defineProperty","minWidth","displayName","memo"],"mappings":"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","file":"components/Table/internal/kernel/FixedHolder/index.js","sourcesContent":["var __rest = (this && this.__rest) || function (s, e) {\n    var t = {};\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\n        t[p] = s[p];\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\n                t[p[i]] = s[p[i]];\n        }\n    return t;\n};\nimport { jsx as _jsx, jsxs as _jsxs } from \"react/jsx-runtime\";\n// @ts-nocheck\nimport { useContext } from '../selector-context';\nimport { clsx } from 'clsx';\nimport { fillRef } from '../../../../../utils/ref';\nimport * as React from 'react';\nimport { useMemo } from 'react';\nimport ColGroup from '../ColGroup';\nimport TableContext from '../context/TableContext';\nimport devRenderTimes from '../hooks/useRenderTimes';\nfunction useColumnWidth(colWidths, columCount) {\n    return useMemo(() => {\n        const cloneColumns = [];\n        for (let i = 0; i < columCount; i += 1) {\n            const val = colWidths[i];\n            if (val !== undefined) {\n                cloneColumns[i] = val;\n            }\n            else {\n                return null;\n            }\n        }\n        return cloneColumns;\n    }, [colWidths.join('_'), columCount]);\n}\nconst FixedHolder = React.forwardRef((props, ref) => {\n    if (process.env.NODE_ENV !== 'production') {\n        devRenderTimes(props);\n    }\n    const { className, style, noData, columns, flattenColumns, colWidths, colGroup, columCount, stickyOffsets, direction, fixHeader, stickyTopOffset, stickyBottomOffset, stickyClassName, scrollX, tableLayout = 'fixed', onScroll, maxContentScroll, children } = props, restProps = __rest(props, [\"className\", \"style\", \"noData\", \"columns\", \"flattenColumns\", \"colWidths\", \"colGroup\", \"columCount\", \"stickyOffsets\", \"direction\", \"fixHeader\", \"stickyTopOffset\", \"stickyBottomOffset\", \"stickyClassName\", \"scrollX\", \"tableLayout\", \"onScroll\", \"maxContentScroll\", \"children\"]);\n    const { prefixCls, scrollbarSize, isSticky, getComponent } = useContext(TableContext, [\n        'prefixCls',\n        'scrollbarSize',\n        'isSticky',\n        'getComponent',\n    ]);\n    const TableComponent = getComponent(['header', 'table'], 'table');\n    const combinationScrollBarSize = isSticky && !fixHeader ? 0 : scrollbarSize;\n    // Pass wheel to scroll event\n    const scrollRef = React.useRef(null);\n    const setScrollRef = React.useCallback((element) => {\n        fillRef(ref, element);\n        fillRef(scrollRef, element);\n    }, []);\n    React.useEffect(() => {\n        function onWheel(e) {\n            const { currentTarget, deltaX } = e;\n            if (deltaX) {\n                const { scrollLeft, scrollWidth, clientWidth } = currentTarget;\n                const maxScrollWidth = scrollWidth - clientWidth;\n                let nextScroll = scrollLeft + deltaX;\n                if (direction === 'rtl') {\n                    nextScroll = Math.max(-maxScrollWidth, nextScroll);\n                    nextScroll = Math.min(0, nextScroll);\n                }\n                else {\n                    nextScroll = Math.min(maxScrollWidth, nextScroll);\n                    nextScroll = Math.max(0, nextScroll);\n                }\n                onScroll({\n                    currentTarget,\n                    scrollLeft: nextScroll,\n                });\n                e.preventDefault();\n            }\n        }\n        const scrollEle = scrollRef.current;\n        scrollEle === null || scrollEle === void 0 ? void 0 : scrollEle.addEventListener('wheel', onWheel, { passive: false });\n        return () => {\n            scrollEle === null || scrollEle === void 0 ? void 0 : scrollEle.removeEventListener('wheel', onWheel);\n        };\n    }, []);\n    // Add scrollbar column\n    const lastColumn = flattenColumns[flattenColumns.length - 1];\n    const ScrollBarColumn = {\n        fixed: lastColumn ? lastColumn.fixed : null,\n        scrollbar: true,\n        onHeaderCell: () => ({\n            className: `${prefixCls}-cell-scrollbar`,\n        }),\n    };\n    const columnsWithScrollbar = useMemo(() => (combinationScrollBarSize ? [...columns, ScrollBarColumn] : columns), [combinationScrollBarSize, columns]);\n    const flattenColumnsWithScrollbar = useMemo(() => (combinationScrollBarSize ? [...flattenColumns, ScrollBarColumn] : flattenColumns), [combinationScrollBarSize, flattenColumns]);\n    // Calculate the sticky offsets\n    const headerStickyOffsets = useMemo(() => {\n        const { start, end } = stickyOffsets;\n        return Object.assign(Object.assign({}, stickyOffsets), { \n            // left:\n            //   direction === 'rtl' ? [...left.map(width => width + combinationScrollBarSize), 0] : left,\n            // right:\n            //   direction === 'rtl' ? right : [...right.map(width => width + combinationScrollBarSize), 0],\n            start: start, end: [...end.map(width => width + combinationScrollBarSize), 0], isSticky });\n    }, [combinationScrollBarSize, stickyOffsets, isSticky]);\n    const mergedColumnWidth = useColumnWidth(colWidths, columCount);\n    const isColGroupEmpty = useMemo(() => {\n        // use original ColGroup if no data or no calculated column width, otherwise use calculated column width\n        // Return original colGroup if no data, or mergedColumnWidth is empty, or all widths are falsy\n        const noWidth = !mergedColumnWidth || !mergedColumnWidth.length || mergedColumnWidth.every(w => !w);\n        return noData || noWidth;\n    }, [noData, mergedColumnWidth]);\n    return (_jsx(\"div\", { style: Object.assign(Object.assign({ overflow: 'hidden' }, (isSticky ? { top: stickyTopOffset, bottom: stickyBottomOffset } : {})), style), ref: setScrollRef, className: clsx(className, {\n            [stickyClassName]: !!stickyClassName,\n        }), children: _jsxs(TableComponent, { style: {\n                tableLayout,\n                minWidth: '100%',\n                // https://github.com/ant-design/ant-design/issues/54894\n                width: scrollX,\n            }, children: [isColGroupEmpty ? (colGroup) : (_jsx(ColGroup, { colWidths: [...mergedColumnWidth, combinationScrollBarSize], columCount: columCount + 1, columns: flattenColumnsWithScrollbar })), children(Object.assign(Object.assign({}, restProps), { stickyOffsets: headerStickyOffsets, columns: columnsWithScrollbar, flattenColumns: flattenColumnsWithScrollbar }))] }) }));\n});\nif (process.env.NODE_ENV !== 'production') {\n    FixedHolder.displayName = 'FixedHolder';\n}\n/** Return a table in div as fixed element which contains sticky info */\n// export default responseImmutable(FixedHolder);\nexport default React.memo(FixedHolder);",null],"sourceRoot":"../../../../../../../../../../../../src"}
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["components/Table/internal/kernel/FixedHolder/index.js","components/Table/internal/kernel/src/components/Table/internal/kernel/FixedHolder/index.tsx"],"names":["__rest","s","e","t","p","Object","prototype","hasOwnProperty","call","indexOf","getOwnPropertySymbols","i","length","propertyIsEnumerable","jsx","_jsx","jsxs","_jsxs","useContext","clsx","fillRef","React","useMemo","ColGroup","TableContext","devRenderTimes","useColumnWidth","colWidths","columCount","cloneColumns","val","undefined","join","FixedHolder","forwardRef","props","ref","process","env","NODE_ENV","className","style","noData","columns","flattenColumns","colGroup","stickyOffsets","direction","fixHeader","stickyTopOffset","stickyBottomOffset","stickyClassName","scrollX","_props$tableLayout","tableLayout","onScroll","maxContentScroll","children","restProps","_useContext","prefixCls","scrollbarSize","isSticky","getComponent","TableComponent","combinationScrollBarSize","scrollRef","useRef","setScrollRef","useCallback","element","useEffect","onWheel","currentTarget","deltaX","scrollLeft","scrollWidth","clientWidth","maxScrollWidth","nextScroll","Math","max","min","preventDefault","scrollEle","current","addEventListener","passive","removeEventListener","lastColumn","ScrollBarColumn","fixed","scrollbar","onHeaderCell","concat","columnsWithScrollbar","_toConsumableArray","flattenColumnsWithScrollbar","headerStickyOffsets","start","end","assign","map","width","mergedColumnWidth","isColGroupEmpty","noWidth","every","w","overflow","top","bottom","_defineProperty","minWidth","displayName","memo"],"mappings":"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","file":"components/Table/internal/kernel/FixedHolder/index.js","sourcesContent":["var __rest = (this && this.__rest) || function (s, e) {\n    var t = {};\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\n        t[p] = s[p];\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\n                t[p[i]] = s[p[i]];\n        }\n    return t;\n};\nimport { jsx as _jsx, jsxs as _jsxs } from \"react/jsx-runtime\";\n// @ts-nocheck\nimport { useContext } from '../selector-context';\nimport { clsx } from 'clsx';\nimport { fillRef } from '../../../../../utils/ref';\nimport * as React from 'react';\nimport { useMemo } from 'react';\nimport ColGroup from '../ColGroup';\nimport TableContext from '../context/TableContext';\nimport devRenderTimes from '../hooks/useRenderTimes';\nfunction useColumnWidth(colWidths, columCount) {\n    return useMemo(() => {\n        const cloneColumns = [];\n        for (let i = 0; i < columCount; i += 1) {\n            const val = colWidths[i];\n            if (val !== undefined) {\n                cloneColumns[i] = val;\n            }\n            else {\n                return null;\n            }\n        }\n        return cloneColumns;\n    }, [colWidths.join('_'), columCount]);\n}\nconst FixedHolder = React.forwardRef((props, ref) => {\n    if (process.env.NODE_ENV !== 'production') {\n        devRenderTimes(props);\n    }\n    const { className, style, noData, columns, flattenColumns, colWidths, colGroup, columCount, stickyOffsets, direction, fixHeader, stickyTopOffset, stickyBottomOffset, stickyClassName, scrollX, tableLayout = 'fixed', onScroll, maxContentScroll, children } = props, restProps = __rest(props, [\"className\", \"style\", \"noData\", \"columns\", \"flattenColumns\", \"colWidths\", \"colGroup\", \"columCount\", \"stickyOffsets\", \"direction\", \"fixHeader\", \"stickyTopOffset\", \"stickyBottomOffset\", \"stickyClassName\", \"scrollX\", \"tableLayout\", \"onScroll\", \"maxContentScroll\", \"children\"]);\n    const { prefixCls, scrollbarSize, isSticky, getComponent } = useContext(TableContext, [\n        'prefixCls',\n        'scrollbarSize',\n        'isSticky',\n        'getComponent',\n    ]);\n    const TableComponent = getComponent(['header', 'table'], 'table');\n    const combinationScrollBarSize = isSticky && !fixHeader ? 0 : scrollbarSize;\n    // Pass wheel to scroll event\n    const scrollRef = React.useRef(null);\n    const setScrollRef = React.useCallback((element) => {\n        fillRef(ref, element);\n        fillRef(scrollRef, element);\n    }, []);\n    React.useEffect(() => {\n        function onWheel(e) {\n            const { currentTarget, deltaX } = e;\n            if (deltaX) {\n                const { scrollLeft, scrollWidth, clientWidth } = currentTarget;\n                const maxScrollWidth = scrollWidth - clientWidth;\n                let nextScroll = scrollLeft + deltaX;\n                if (direction === 'rtl') {\n                    nextScroll = Math.max(-maxScrollWidth, nextScroll);\n                    nextScroll = Math.min(0, nextScroll);\n                }\n                else {\n                    nextScroll = Math.min(maxScrollWidth, nextScroll);\n                    nextScroll = Math.max(0, nextScroll);\n                }\n                onScroll({\n                    currentTarget,\n                    scrollLeft: nextScroll,\n                });\n                e.preventDefault();\n            }\n        }\n        const scrollEle = scrollRef.current;\n        scrollEle === null || scrollEle === void 0 ? void 0 : scrollEle.addEventListener('wheel', onWheel, { passive: false });\n        return () => {\n            scrollEle === null || scrollEle === void 0 ? void 0 : scrollEle.removeEventListener('wheel', onWheel);\n        };\n    }, []);\n    // Add scrollbar column\n    const lastColumn = flattenColumns[flattenColumns.length - 1];\n    const ScrollBarColumn = {\n        fixed: lastColumn ? lastColumn.fixed : null,\n        scrollbar: true,\n        onHeaderCell: () => ({\n            className: `${prefixCls}-cell-scrollbar`,\n        }),\n    };\n    const columnsWithScrollbar = useMemo(() => (combinationScrollBarSize ? [...columns, ScrollBarColumn] : columns), [combinationScrollBarSize, columns]);\n    const flattenColumnsWithScrollbar = useMemo(() => (combinationScrollBarSize ? [...flattenColumns, ScrollBarColumn] : flattenColumns), [combinationScrollBarSize, flattenColumns]);\n    // Calculate the sticky offsets\n    const headerStickyOffsets = useMemo(() => {\n        const { start, end } = stickyOffsets;\n        return Object.assign(Object.assign({}, stickyOffsets), { \n            // left:\n            //   direction === 'rtl' ? [...left.map(width => width + combinationScrollBarSize), 0] : left,\n            // right:\n            //   direction === 'rtl' ? right : [...right.map(width => width + combinationScrollBarSize), 0],\n            start: start, end: [...end.map(width => width + combinationScrollBarSize), 0], isSticky });\n    }, [combinationScrollBarSize, stickyOffsets, isSticky]);\n    const mergedColumnWidth = useColumnWidth(colWidths, columCount);\n    const isColGroupEmpty = useMemo(() => {\n        // use original ColGroup if no data or no calculated column width, otherwise use calculated column width\n        // Return original colGroup if no data, or mergedColumnWidth is empty, or all widths are falsy\n        const noWidth = !mergedColumnWidth || !mergedColumnWidth.length || mergedColumnWidth.every(w => !w);\n        return noData || noWidth;\n    }, [noData, mergedColumnWidth]);\n    return (_jsx(\"div\", { style: Object.assign(Object.assign({ overflow: 'hidden' }, (isSticky ? { top: stickyTopOffset, bottom: stickyBottomOffset } : {})), style), ref: setScrollRef, className: clsx(className, {\n            [stickyClassName]: !!stickyClassName,\n        }), children: _jsxs(TableComponent, { style: {\n                tableLayout,\n                minWidth: '100%',\n                width: scrollX,\n            }, children: [isColGroupEmpty ? (colGroup) : (_jsx(ColGroup, { colWidths: [...mergedColumnWidth, combinationScrollBarSize], columCount: columCount + 1, columns: flattenColumnsWithScrollbar })), children(Object.assign(Object.assign({}, restProps), { stickyOffsets: headerStickyOffsets, columns: columnsWithScrollbar, flattenColumns: flattenColumnsWithScrollbar }))] }) }));\n});\nif (process.env.NODE_ENV !== 'production') {\n    FixedHolder.displayName = 'FixedHolder';\n}\n/** Return a table in div as fixed element which contains sticky info */\n// export default responseImmutable(FixedHolder);\nexport default React.memo(FixedHolder);",null],"sourceRoot":"../../../../../../../../../../../../src"}

package/es/components/Table/internal/kernel/Table.d.ts

@@ -30,7 +30,7 @@ import { FooterComponents } from './Footer';
 import type { ColumnsType, ColumnType, DefaultRecordType, Direction, ExpandableConfig, GetComponentProps, GetRowKey, LegacyExpandableProps, PanelRender, Reference, RowClassName, TableComponents, TableLayout, TableSticky } from './interface';
 import Column from './sugar/Column';
 import ColumnGroup from './sugar/ColumnGroup';
-export declare const DEFAULT_PREFIX = "rc-table";
+export declare const DEFAULT_PREFIX = "om-table";
 export type SemanticName = 'section' | 'title' | 'footer' | 'content';
 export type ComponentsSemantic = 'wrapper' | 'cell' | 'row';
 export interface TableProps<RecordType = DefaultRecordType> extends Omit<LegacyExpandableProps<RecordType>, 'showExpandColumn'> {