@1money/component-ui 0.0.49 → 0.0.50

package/es/components/Table/internal/kernel/VirtualTable/VirtualCell.js

@@ -0,0 +1,105 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+// @ts-nocheck
+import { useContext } from '../selector-context';
+import { clsx } from 'clsx';
+import * as React from 'react';
+import { getCellProps } from '../Body/BodyRow';
+import Cell from '../Cell';
+import { GridContext } from './context';
+/**
+ * Return the width of the column by `colSpan`.
+ * When `colSpan` is `0` will be trade as `1`.
+ */
+export function getColumnWidth(colIndex, colSpan, columnsOffset) {
+  var mergedColSpan = colSpan || 1;
+  return columnsOffset[colIndex + mergedColSpan] - (columnsOffset[colIndex] || 0);
+}
+var VirtualCell = function VirtualCell(props) {
+  var rowInfo = props.rowInfo,
+    column = props.column,
+    colIndex = props.colIndex,
+    indent = props.indent,
+    index = props.index,
+    component = props.component,
+    renderIndex = props.renderIndex,
+    record = props.record,
+    style = props.style,
+    className = props.className,
+    inverse = props.inverse,
+    getHeight = props.getHeight;
+  var render = column.render,
+    dataIndex = column.dataIndex,
+    columnClassName = column.className,
+    colWidth = column.width;
+  var _useContext = useContext(GridContext, ['columnsOffset']),
+    columnsOffset = _useContext.columnsOffset;
+  // TODO: support `expandableRowOffset`
+  var _getCellProps = getCellProps(rowInfo, column, colIndex, indent, index),
+    key = _getCellProps.key,
+    fixedInfo = _getCellProps.fixedInfo,
+    appendCellNode = _getCellProps.appendCellNode,
+    additionalCellProps = _getCellProps.additionalCellProps;
+  var cellStyle = additionalCellProps.style,
+    _additionalCellProps$ = additionalCellProps.colSpan,
+    colSpan = _additionalCellProps$ === void 0 ? 1 : _additionalCellProps$,
+    _additionalCellProps$2 = additionalCellProps.rowSpan,
+    rowSpan = _additionalCellProps$2 === void 0 ? 1 : _additionalCellProps$2;
+  // ========================= ColWidth =========================
+  // column width
+  var startColIndex = colIndex - 1;
+  var concatColWidth = getColumnWidth(startColIndex, colSpan, columnsOffset);
+  // margin offset
+  var marginOffset = colSpan > 1 ? colWidth - concatColWidth : 0;
+  // ========================== Style ===========================
+  var mergedStyle = Object.assign(Object.assign(Object.assign({}, cellStyle), style), {
+    flex: "0 0 ".concat(concatColWidth, "px"),
+    width: "".concat(concatColWidth, "px"),
+    marginRight: marginOffset,
+    pointerEvents: 'auto'
+  });
+  // When `colSpan` or `rowSpan` is `0`, should skip render.
+  var needHide = React.useMemo(function () {
+    if (inverse) {
+      return rowSpan <= 1;
+    } else {
+      return colSpan === 0 || rowSpan === 0 || rowSpan > 1;
+    }
+  }, [rowSpan, colSpan, inverse]);
+  // 0 rowSpan or colSpan should not render
+  if (needHide) {
+    mergedStyle.visibility = 'hidden';
+  } else if (inverse) {
+    mergedStyle.height = getHeight === null || getHeight === void 0 ? void 0 : getHeight(rowSpan);
+  }
+  var mergedRender = needHide ? function () {
+    return null;
+  } : render;
+  // ========================== Render ==========================
+  var cellSpan = {};
+  // Virtual should reset `colSpan` & `rowSpan`
+  if (rowSpan === 0 || colSpan === 0) {
+    cellSpan.rowSpan = 1;
+    cellSpan.colSpan = 1;
+  }
+  return _jsx(Cell, Object.assign({
+    className: clsx(columnClassName, className),
+    ellipsis: column.ellipsis,
+    align: column.align,
+    scope: column.rowScope,
+    component: component,
+    prefixCls: rowInfo.prefixCls,
+    record: record,
+    index: index,
+    renderIndex: renderIndex,
+    dataIndex: dataIndex,
+    render: mergedRender,
+    shouldCellUpdate: column.shouldCellUpdate
+  }, fixedInfo, {
+    appendNode: appendCellNode,
+    additionalProps: Object.assign(Object.assign(Object.assign({}, additionalCellProps), {
+      style: mergedStyle
+    }), cellSpan)
+  }), key);
+};
+export default VirtualCell;
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["components/Table/internal/kernel/VirtualTable/VirtualCell.js","components/Table/internal/kernel/src/components/Table/internal/kernel/VirtualTable/VirtualCell.tsx"],"names":["jsx","_jsx","useContext","clsx","React","getCellProps","Cell","GridContext","getColumnWidth","colIndex","colSpan","columnsOffset","mergedColSpan","VirtualCell","props","rowInfo","column","indent","index","component","renderIndex","record","style","className","inverse","getHeight","render","dataIndex","columnClassName","colWidth","width","_useContext","_getCellProps","key","fixedInfo","appendCellNode","additionalCellProps","cellStyle","_additionalCellProps$","_additionalCellProps$2","rowSpan","startColIndex","concatColWidth","marginOffset","mergedStyle","Object","assign","flex","concat","marginRight","pointerEvents","needHide","useMemo","visibility","height","mergedRender","cellSpan","ellipsis","align","scope","rowScope","prefixCls","shouldCellUpdate","appendNode","additionalProps"],"mappings":"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","file":"components/Table/internal/kernel/VirtualTable/VirtualCell.js","sourcesContent":["import { jsx as _jsx } from \"react/jsx-runtime\";\n// @ts-nocheck\nimport { useContext } from '../selector-context';\nimport { clsx } from 'clsx';\nimport * as React from 'react';\nimport { getCellProps } from '../Body/BodyRow';\nimport Cell from '../Cell';\nimport { GridContext } from './context';\n/**\n * Return the width of the column by `colSpan`.\n * When `colSpan` is `0` will be trade as `1`.\n */\nexport function getColumnWidth(colIndex, colSpan, columnsOffset) {\n    const mergedColSpan = colSpan || 1;\n    return columnsOffset[colIndex + mergedColSpan] - (columnsOffset[colIndex] || 0);\n}\nconst VirtualCell = (props) => {\n    const { rowInfo, column, colIndex, indent, index, component, renderIndex, record, style, className, inverse, getHeight, } = props;\n    const { render, dataIndex, className: columnClassName, width: colWidth } = column;\n    const { columnsOffset } = useContext(GridContext, ['columnsOffset']);\n    // TODO: support `expandableRowOffset`\n    const { key, fixedInfo, appendCellNode, additionalCellProps } = getCellProps(rowInfo, column, colIndex, indent, index);\n    const { style: cellStyle, colSpan = 1, rowSpan = 1 } = additionalCellProps;\n    // ========================= ColWidth =========================\n    // column width\n    const startColIndex = colIndex - 1;\n    const concatColWidth = getColumnWidth(startColIndex, colSpan, columnsOffset);\n    // margin offset\n    const marginOffset = colSpan > 1 ? colWidth - concatColWidth : 0;\n    // ========================== Style ===========================\n    const mergedStyle = Object.assign(Object.assign(Object.assign({}, cellStyle), style), { flex: `0 0 ${concatColWidth}px`, width: `${concatColWidth}px`, marginRight: marginOffset, pointerEvents: 'auto' });\n    // When `colSpan` or `rowSpan` is `0`, should skip render.\n    const needHide = React.useMemo(() => {\n        if (inverse) {\n            return rowSpan <= 1;\n        }\n        else {\n            return colSpan === 0 || rowSpan === 0 || rowSpan > 1;\n        }\n    }, [rowSpan, colSpan, inverse]);\n    // 0 rowSpan or colSpan should not render\n    if (needHide) {\n        mergedStyle.visibility = 'hidden';\n    }\n    else if (inverse) {\n        mergedStyle.height = getHeight === null || getHeight === void 0 ? void 0 : getHeight(rowSpan);\n    }\n    const mergedRender = needHide ? () => null : render;\n    // ========================== Render ==========================\n    const cellSpan = {};\n    // Virtual should reset `colSpan` & `rowSpan`\n    if (rowSpan === 0 || colSpan === 0) {\n        cellSpan.rowSpan = 1;\n        cellSpan.colSpan = 1;\n    }\n    return (_jsx(Cell, Object.assign({ className: clsx(columnClassName, className), ellipsis: column.ellipsis, align: column.align, scope: column.rowScope, component: component, prefixCls: rowInfo.prefixCls, record: record, index: index, renderIndex: renderIndex, dataIndex: dataIndex, render: mergedRender, shouldCellUpdate: column.shouldCellUpdate }, fixedInfo, { appendNode: appendCellNode, additionalProps: Object.assign(Object.assign(Object.assign({}, additionalCellProps), { style: mergedStyle }), cellSpan) }), key));\n};\nexport default VirtualCell;",null],"sourceRoot":"../../../../../../../../../../../../src"}

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

@@ -0,0 +1,13 @@
+import type { GetComponent, TableSticky } from '../interface';
+export interface StaticContextProps {
+    scrollY: number;
+    listItemHeight: number;
+    sticky: boolean | TableSticky;
+    getComponent: GetComponent;
+    onScroll?: React.UIEventHandler<HTMLDivElement>;
+}
+export declare const StaticContext: import("../selector-context").SelectorContext<StaticContextProps>;
+export interface GridContextProps {
+    columnsOffset: number[];
+}
+export declare const GridContext: import("../selector-context").SelectorContext<GridContextProps>;

package/es/components/Table/internal/kernel/VirtualTable/context.js

@@ -0,0 +1,5 @@
+// @ts-nocheck
+import { createContext } from '../selector-context';
+export var StaticContext = createContext(null);
+export var GridContext = createContext(null);
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImNvbXBvbmVudHMvVGFibGUvaW50ZXJuYWwva2VybmVsL3NyYy9jb21wb25lbnRzL1RhYmxlL2ludGVybmFsL2tlcm5lbC9WaXJ0dWFsVGFibGUvY29udGV4dC50cyJdLCJuYW1lcyI6WyJjcmVhdGVDb250ZXh0IiwiU3RhdGljQ29udGV4dCIsIkdyaWRDb250ZXh0Il0sIm1hcHBpbmdzIjoiQUFBQTtBQUNBLFNBQVNBLGFBQWEsUUFBUSxxQkFBcUI7QUFXbkQsT0FBTyxJQUFNQyxhQUFhLEdBQUdELGFBQWEsQ0FBcUIsSUFBSSxDQUFDO0FBTXBFLE9BQU8sSUFBTUUsV0FBVyxHQUFHRixhQUFhLENBQW1CLElBQUksQ0FBQyIsImZpbGUiOiJjb21wb25lbnRzL1RhYmxlL2ludGVybmFsL2tlcm5lbC9WaXJ0dWFsVGFibGUvY29udGV4dC5qcyIsInNvdXJjZXNDb250ZW50IjpbbnVsbF0sInNvdXJjZVJvb3QiOiIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9zcmMifQ==

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

@@ -0,0 +1,17 @@
+import type { CompareProps } from '../selector-context';
+import * as React from 'react';
+import type { Reference } from '../interface';
+import { type TableProps } from '../Table';
+export interface VirtualTableProps<RecordType> extends Omit<TableProps<RecordType>, 'scroll'> {
+    listItemHeight?: number;
+    scroll: {
+        x?: number;
+        y?: number;
+    };
+}
+export type ForwardGenericVirtualTable = (<RecordType>(props: TableProps<RecordType> & React.RefAttributes<Reference>) => React.ReactElement) & {
+    displayName?: string;
+};
+export declare const genVirtualTable: (shouldTriggerRender?: CompareProps<ForwardGenericVirtualTable>) => ForwardGenericVirtualTable;
+declare const _default: ForwardGenericVirtualTable;
+export default _default;

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

@@ -0,0 +1,90 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { clsx } from 'clsx';
+import { useEventCallback as useEvent } from '@1money/hooks';
+import warning from '../utils/warning';
+import * as React from 'react';
+import { INTERNAL_HOOKS } from '../constant';
+import { makeImmutable } from '../context/TableContext';
+import Table, { DEFAULT_PREFIX } from '../Table';
+import Grid from './BodyGrid';
+import { StaticContext } from './context';
+import getValue from '../utils/get';
+var renderBody = function renderBody(rawData, props) {
+  var ref = props.ref,
+    onScroll = props.onScroll;
+  return _jsx(Grid, {
+    ref: ref,
+    data: rawData,
+    onScroll: onScroll
+  });
+};
+var VirtualTable = function VirtualTable(props, ref) {
+  var data = props.data,
+    columns = props.columns,
+    scroll = props.scroll,
+    sticky = props.sticky,
+    _props$prefixCls = props.prefixCls,
+    prefixCls = _props$prefixCls === void 0 ? DEFAULT_PREFIX : _props$prefixCls,
+    className = props.className,
+    listItemHeight = props.listItemHeight,
+    components = props.components,
+    onScroll = props.onScroll;
+  var _ref = scroll || {},
+    scrollX = _ref.x,
+    scrollY = _ref.y;
+  // Fill scrollX
+  if (typeof scrollX !== 'number') {
+    if (process.env.NODE_ENV !== 'production') {
+      warning(!scrollX, '`scroll.x` in virtual table must be number.');
+    }
+    scrollX = 1;
+  }
+  // Fill scrollY
+  if (typeof scrollY !== 'number') {
+    scrollY = 500;
+    if (process.env.NODE_ENV !== 'production') {
+      warning(false, '`scroll.y` in virtual table must be number.');
+    }
+  }
+  var getComponent = useEvent(function (path, defaultComponent) {
+    return getValue(components, path) || defaultComponent;
+  });
+  // Memo this — guard against undefined to avoid useEventCallback wrapping undefined
+  var onInternalScroll = useEvent(onScroll || function () {});
+  // ========================= Context ==========================
+  var context = React.useMemo(function () {
+    return {
+      sticky: sticky,
+      scrollY: scrollY,
+      listItemHeight: listItemHeight,
+      getComponent: getComponent,
+      onScroll: onInternalScroll
+    };
+  }, [sticky, scrollY, listItemHeight, getComponent, onInternalScroll]);
+  // ========================== Render ==========================
+  return _jsx(StaticContext.Provider, {
+    value: context,
+    children: _jsx(Table, Object.assign({}, props, {
+      className: clsx(className, "".concat(prefixCls, "-virtual")),
+      scroll: Object.assign(Object.assign({}, scroll), {
+        x: scrollX
+      }),
+      components: Object.assign(Object.assign({}, components), {
+        body: (data === null || data === void 0 ? void 0 : data.length) ? renderBody : undefined
+      }),
+      columns: columns,
+      internalHooks: INTERNAL_HOOKS,
+      tailor: true,
+      ref: ref
+    }))
+  });
+};
+var RefVirtualTable = /*#__PURE__*/React.forwardRef(VirtualTable);
+if (process.env.NODE_ENV !== 'production') {
+  RefVirtualTable.displayName = 'VirtualTable';
+}
+export var genVirtualTable = function genVirtualTable(shouldTriggerRender) {
+  return makeImmutable(RefVirtualTable, shouldTriggerRender);
+};
+export default genVirtualTable();
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["components/Table/internal/kernel/VirtualTable/index.js","components/Table/internal/kernel/src/components/Table/internal/kernel/VirtualTable/index.tsx"],"names":["jsx","_jsx","clsx","useEventCallback","useEvent","warning","React","INTERNAL_HOOKS","makeImmutable","Table","DEFAULT_PREFIX","Grid","StaticContext","getValue","renderBody","rawData","props","ref","onScroll","data","VirtualTable","columns","scroll","sticky","_props$prefixCls","prefixCls","className","listItemHeight","components","_ref","scrollX","x","scrollY","y","process","env","NODE_ENV","getComponent","path","defaultComponent","onInternalScroll","context","useMemo","Provider","value","children","Object","assign","concat","body","length","undefined","internalHooks","tailor","RefVirtualTable","forwardRef","displayName","genVirtualTable","shouldTriggerRender"],"mappings":"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","file":"components/Table/internal/kernel/VirtualTable/index.js","sourcesContent":["import { jsx as _jsx } from \"react/jsx-runtime\";\nimport { clsx } from 'clsx';\nimport { useEventCallback as useEvent } from '@1money/hooks';\nimport warning from '../utils/warning';\nimport * as React from 'react';\nimport { INTERNAL_HOOKS } from '../constant';\nimport { makeImmutable } from '../context/TableContext';\nimport Table, { DEFAULT_PREFIX } from '../Table';\nimport Grid from './BodyGrid';\nimport { StaticContext } from './context';\nimport getValue from '../utils/get';\nconst renderBody = (rawData, props) => {\n    const { ref, onScroll } = props;\n    return _jsx(Grid, { ref: ref, data: rawData, onScroll: onScroll });\n};\nconst VirtualTable = (props, ref) => {\n    const { data, columns, scroll, sticky, prefixCls = DEFAULT_PREFIX, className, listItemHeight, components, onScroll, } = props;\n    let { x: scrollX, y: scrollY } = scroll || {};\n    // Fill scrollX\n    if (typeof scrollX !== 'number') {\n        if (process.env.NODE_ENV !== 'production') {\n            warning(!scrollX, '`scroll.x` in virtual table must be number.');\n        }\n        scrollX = 1;\n    }\n    // Fill scrollY\n    if (typeof scrollY !== 'number') {\n        scrollY = 500;\n        if (process.env.NODE_ENV !== 'production') {\n            warning(false, '`scroll.y` in virtual table must be number.');\n        }\n    }\n    const getComponent = useEvent((path, defaultComponent) => getValue(components, path) || defaultComponent);\n    // Memo this — guard against undefined to avoid useEventCallback wrapping undefined\n    const onInternalScroll = useEvent(onScroll || (() => { }));\n    // ========================= Context ==========================\n    const context = React.useMemo(() => ({ sticky, scrollY, listItemHeight, getComponent, onScroll: onInternalScroll }), [sticky, scrollY, listItemHeight, getComponent, onInternalScroll]);\n    // ========================== Render ==========================\n    return (_jsx(StaticContext.Provider, { value: context, children: _jsx(Table, Object.assign({}, props, { className: clsx(className, `${prefixCls}-virtual`), scroll: Object.assign(Object.assign({}, scroll), { x: scrollX }), components: Object.assign(Object.assign({}, components), { body: (data === null || data === void 0 ? void 0 : data.length) ? renderBody : undefined }), columns: columns, internalHooks: INTERNAL_HOOKS, tailor: true, ref: ref })) }));\n};\nconst RefVirtualTable = React.forwardRef(VirtualTable);\nif (process.env.NODE_ENV !== 'production') {\n    RefVirtualTable.displayName = 'VirtualTable';\n}\nexport const genVirtualTable = (shouldTriggerRender) => {\n    return makeImmutable(RefVirtualTable, shouldTriggerRender);\n};\nexport default genVirtualTable();",null],"sourceRoot":"../../../../../../../../../../../../src"}

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

@@ -0,0 +1,2 @@
+export declare const EXPAND_COLUMN: {};
+export declare const INTERNAL_HOOKS = "om-table-internal-hook";

package/es/components/Table/internal/kernel/constant.js

@@ -0,0 +1,4 @@
+// @ts-nocheck
+export var EXPAND_COLUMN = {};
+export var INTERNAL_HOOKS = 'om-table-internal-hook';
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImNvbXBvbmVudHMvVGFibGUvaW50ZXJuYWwvc3JjL2NvbXBvbmVudHMvVGFibGUvaW50ZXJuYWwva2VybmVsL2NvbnN0YW50LnRzIl0sIm5hbWVzIjpbIkVYUEFORF9DT0xVTU4iLCJJTlRFUk5BTF9IT09LUyJdLCJtYXBwaW5ncyI6IkFBQUE7QUFDQSxPQUFPLElBQU1BLGFBQWEsR0FBRyxDQUFBLENBQVc7QUFFeEMsT0FBTyxJQUFNQyxjQUFjLEdBQUcsd0JBQXdCIiwiZmlsZSI6ImNvbXBvbmVudHMvVGFibGUvaW50ZXJuYWwva2VybmVsL2NvbnN0YW50LmpzIiwic291cmNlc0NvbnRlbnQiOltudWxsXSwic291cmNlUm9vdCI6Ii4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3NyYyJ9

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

@@ -0,0 +1,6 @@
+import * as React from 'react';
+export interface PerfRecord {
+    renderWithProps: boolean;
+}
+declare const PerfContext: React.Context<PerfRecord>;
+export default PerfContext;

package/es/components/Table/internal/kernel/context/PerfContext.js

@@ -0,0 +1,8 @@
+// @ts-nocheck
+import * as React from 'react';
+// TODO: Remove when use `responsiveImmutable`
+var PerfContext = /*#__PURE__*/React.createContext({
+  renderWithProps: false
+});
+export default PerfContext;
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImNvbXBvbmVudHMvVGFibGUvaW50ZXJuYWwva2VybmVsL3NyYy9jb21wb25lbnRzL1RhYmxlL2ludGVybmFsL2tlcm5lbC9jb250ZXh0L1BlcmZDb250ZXh0LnRzeCIsImNvbXBvbmVudHMvVGFibGUvaW50ZXJuYWwva2VybmVsL2NvbnRleHQvUGVyZkNvbnRleHQuanMiXSwibmFtZXMiOlsiUmVhY3QiLCJQZXJmQ29udGV4dCIsImNyZWF0ZUNvbnRleHQiLCJyZW5kZXJXaXRoUHJvcHMiXSwibWFwcGluZ3MiOiJBQUFBO0FBQ0EsT0FBTyxLQUFLQSxLQUFLLE1BQU0sT0FBTztBQU05QjtBQUNBLElBQU1DLFdBQVcsZ0JBQUdELEtBQUssQ0FBQ0UsYUFBYSxDQUFhO0VBQ2xEQyxlQUFlLEVBQUU7QUNKbkIsQ0RLQyxDQUFDO0FBRUYsZUFBZUYsV0FBVyIsImZpbGUiOiJjb21wb25lbnRzL1RhYmxlL2ludGVybmFsL2tlcm5lbC9jb250ZXh0L1BlcmZDb250ZXh0LmpzIiwic291cmNlc0NvbnRlbnQiOltudWxsLCIvLyBAdHMtbm9jaGVja1xuaW1wb3J0ICogYXMgUmVhY3QgZnJvbSAncmVhY3QnO1xuLy8gVE9ETzogUmVtb3ZlIHdoZW4gdXNlIGByZXNwb25zaXZlSW1tdXRhYmxlYFxuY29uc3QgUGVyZkNvbnRleHQgPSBSZWFjdC5jcmVhdGVDb250ZXh0KHtcbiAgICByZW5kZXJXaXRoUHJvcHM6IGZhbHNlLFxufSk7XG5leHBvcnQgZGVmYXVsdCBQZXJmQ29udGV4dDsiXSwic291cmNlUm9vdCI6Ii4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3NyYyJ9

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

@@ -0,0 +1,51 @@
+import type { ColumnsType, ColumnType, Direction, ExpandableConfig, ExpandableType, ExpandedRowRender, GetComponent, GetComponentProps, GetRowKey, RenderExpandIcon, RowClassName, TableLayout, TriggerEventHandler } from '../interface';
+import type { FixedInfo } from '../utils/fixUtil';
+import type { TableProps } from '../Table';
+declare const makeImmutable: <T extends import("react").ComponentType<any>>(Component: T, shouldTriggerRender?: import("../selector-context").CompareProps<T>) => T, responseImmutable: <T extends import("react").ComponentType<any>>(Component: T, propsAreEqual?: import("../selector-context").CompareProps<T>) => T, useImmutableMark: () => number | null;
+export { makeImmutable, responseImmutable, useImmutableMark };
+export type ScrollInfoType = [scrollLeft: number, scrollRange: number];
+export interface TableContextProps<RecordType = unknown> {
+    scrollX: number | string | true;
+    classNames?: TableProps['classNames'];
+    styles?: TableProps['styles'];
+    prefixCls: string;
+    getComponent: GetComponent;
+    scrollbarSize: number;
+    direction: Direction;
+    fixedInfoList: readonly FixedInfo[];
+    isSticky: boolean;
+    componentWidth: number;
+    fixHeader: boolean;
+    fixColumn: boolean;
+    horizonScroll: boolean;
+    scrollInfo: ScrollInfoType;
+    rowClassName: string | RowClassName<RecordType>;
+    expandedRowClassName: string | RowClassName<RecordType>;
+    onRow?: GetComponentProps<RecordType>;
+    emptyNode?: React.ReactNode;
+    tableLayout: TableLayout;
+    indentSize: number;
+    expandableType: ExpandableType;
+    expandRowByClick: boolean;
+    expandedRowRender: ExpandedRowRender<RecordType>;
+    expandIcon: RenderExpandIcon<RecordType>;
+    onTriggerExpand: TriggerEventHandler<RecordType>;
+    expandIconColumnIndex: number;
+    allColumnsFixedLeft: boolean;
+    columns: ColumnsType<RecordType>;
+    flattenColumns: readonly ColumnType<RecordType>[];
+    onColumnResize: (columnKey: React.Key, width: number) => void;
+    colWidths: number[];
+    hoverStartRow: number;
+    hoverEndRow: number;
+    onHover: (start: number, end: number) => void;
+    rowExpandable: (record: RecordType) => boolean;
+    expandedKeys: Set<React.Key>;
+    getRowKey: GetRowKey<RecordType>;
+    childrenColumnName: string;
+    rowHoverable?: boolean;
+    expandedRowOffset: ExpandableConfig<RecordType>['expandedRowOffset'];
+    measureRowRender?: (measureRow: React.ReactNode) => React.ReactNode;
+}
+declare const TableContext: import("../selector-context").SelectorContext<TableContextProps<unknown>>;
+export default TableContext;

package/es/components/Table/internal/kernel/context/TableContext.js

@@ -0,0 +1,10 @@
+// @ts-nocheck
+import { createContext, createImmutable } from '../selector-context';
+var _createImmutable = createImmutable(),
+  makeImmutable = _createImmutable.makeImmutable,
+  responseImmutable = _createImmutable.responseImmutable,
+  useImmutableMark = _createImmutable.useImmutableMark;
+export { makeImmutable, responseImmutable, useImmutableMark };
+var TableContext = createContext();
+export default TableContext;
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImNvbXBvbmVudHMvVGFibGUvaW50ZXJuYWwva2VybmVsL3NyYy9jb21wb25lbnRzL1RhYmxlL2ludGVybmFsL2tlcm5lbC9jb250ZXh0L1RhYmxlQ29udGV4dC50c3giXSwibmFtZXMiOlsiY3JlYXRlQ29udGV4dCIsImNyZWF0ZUltbXV0YWJsZSIsIl9jcmVhdGVJbW11dGFibGUiLCJtYWtlSW1tdXRhYmxlIiwicmVzcG9uc2VJbW11dGFibGUiLCJ1c2VJbW11dGFibGVNYXJrIiwiVGFibGVDb250ZXh0Il0sIm1hcHBpbmdzIjoiQUFBQTtBQUNBLFNBQVNBLGFBQWEsRUFBRUMsZUFBZSxRQUFRLHFCQUFxQjtBQW1CcEUsSUFBQUMsZ0JBQUEsR0FBK0RELGVBQWUsQ0FBQSxDQUFFO0VBQXhFRSxhQUFhLEdBQUFELGdCQUFBLENBQWJDLGFBQWE7RUFBRUMsaUJBQWlCLEdBQUFGLGdCQUFBLENBQWpCRSxpQkFBaUI7RUFBRUMsZ0JBQWdCLEdBQUFILGdCQUFBLENBQWhCRyxnQkFBZ0I7QUFDMUQsU0FBU0YsYUFBYSxFQUFFQyxpQkFBaUIsRUFBRUMsZ0JBQWdCO0FBZ0UzRCxJQUFNQyxZQUFZLEdBQUdOLGFBQWEsQ0FBQSxDQUFxQjtBQUV2RCxlQUFlTSxZQUFZIiwiZmlsZSI6ImNvbXBvbmVudHMvVGFibGUvaW50ZXJuYWwva2VybmVsL2NvbnRleHQvVGFibGVDb250ZXh0LmpzIiwic291cmNlc0NvbnRlbnQiOltudWxsXSwic291cmNlUm9vdCI6Ii4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3NyYyJ9

package/es/components/Table/internal/kernel/hooks/useColumns/index.d.ts

@@ -0,0 +1,31 @@
+import * as React from 'react';
+import type { ColumnsType, ColumnType, Direction, FixedType, GetRowKey, Key, RenderExpandIcon, TriggerEventHandler } from '../../interface';
+export declare function convertChildrenToColumns<RecordType>(children: React.ReactNode): ColumnsType<RecordType>;
+/**
+ * Parse `columns` & `children` into `columns`.
+ */
+declare function useColumns<RecordType>({ prefixCls, columns, children, expandable, expandedKeys, columnTitle, getRowKey, onTriggerExpand, expandIcon, rowExpandable, expandIconColumnIndex, expandedRowOffset, direction, expandRowByClick, columnWidth, fixed, scrollWidth, clientWidth, }: {
+    prefixCls?: string;
+    columns?: ColumnsType<RecordType>;
+    children?: React.ReactNode;
+    expandable: boolean;
+    expandedKeys: Set<Key>;
+    columnTitle?: React.ReactNode;
+    getRowKey: GetRowKey<RecordType>;
+    onTriggerExpand: TriggerEventHandler<RecordType>;
+    expandIcon?: RenderExpandIcon<RecordType>;
+    rowExpandable?: (record: RecordType) => boolean;
+    expandIconColumnIndex?: number;
+    direction?: Direction;
+    expandRowByClick?: boolean;
+    columnWidth?: number | string;
+    clientWidth: number;
+    fixed?: FixedType;
+    scrollWidth?: number;
+    expandedRowOffset?: number;
+}, transformColumns: (columns: ColumnsType<RecordType>) => ColumnsType<RecordType>): [
+    columns: ColumnsType<RecordType>,
+    flattenColumns: readonly ColumnType<RecordType>[],
+    realScrollWidth: undefined | number
+];
+export default useColumns;