useblocks 1.1.85-dev.1 → 1.1.85-dev.10

package/vendor/@rc-component/table/es/Table.js

@@ -0,0 +1,511 @@
+import "../../util/es/warning.js";
+import { getDOM } from "../../util/es/Dom/findDOMNode.js";
+import useEvent from "../../util/es/hooks/useEvent.js";
+import useLayoutEffect$1 from "../../util/es/hooks/useLayoutEffect.js";
+import { getTargetScrollBarSize } from "../../util/es/getScrollBarSize.js";
+import isEqual from "../../util/es/isEqual.js";
+import pickAttrs from "../../util/es/pickAttrs.js";
+import get from "../../util/es/utils/get.js";
+import RefResizeObserver from "../../resize-observer/es/index.js";
+import { clsx } from "../../../clsx/dist/clsx.js";
+import { EXPAND_COLUMN, INTERNAL_HOOKS } from "./constant.js";
+import TableContext, { makeImmutable } from "./context/TableContext.js";
+import { getColumnsKey, validNumberValue, validateValue } from "./utils/valueUtil.js";
+import Summary from "./Footer/Summary.js";
+import Footer_default, { FooterComponents } from "./Footer/index.js";
+import Column from "./sugar/Column.js";
+import ColumnGroup from "./sugar/ColumnGroup.js";
+import Body_default from "./Body/index.js";
+import ColGroup from "./ColGroup.js";
+import FixedHolder_default from "./FixedHolder/index.js";
+import Header_default from "./Header/Header.js";
+import useColumns from "./hooks/useColumns/index.js";
+import useExpand from "./hooks/useExpand.js";
+import useFixedInfo from "./hooks/useFixedInfo.js";
+import { useTimeoutLock } from "./hooks/useFrame.js";
+import useHover from "./hooks/useHover.js";
+import useSticky from "./hooks/useSticky.js";
+import useStickyOffsets from "./hooks/useStickyOffsets.js";
+import Panel from "./Panel/index.js";
+import stickyScrollBar_default from "./stickyScrollBar.js";
+import * as React$1 from "../../../react/index.js";
+//#region node_modules/@rc-component/table/es/Table.js
+/**
+* Feature:
+*  - fixed not need to set width
+*  - support `rowExpandable` to config row expand logic
+*  - add `summary` to support `() => ReactNode`
+*
+* Update:
+*  - `dataIndex` is `array[]` now
+*  - `expandable` wrap all the expand related props
+*
+* Removed:
+*  - expandIconAsCell
+*  - useFixedHeader
+*  - rowRef
+*  - columns[number].onCellClick
+*  - onRowClick
+*  - onRowDoubleClick
+*  - onRowMouseEnter
+*  - onRowMouseLeave
+*  - getBodyWrapper
+*  - bodyStyle
+*
+* Deprecated:
+*  - All expanded props, move into expandable
+*/
+function _extends() {
+	_extends = Object.assign ? Object.assign.bind() : function(target) {
+		for (var i = 1; i < arguments.length; i++) {
+			var source = arguments[i];
+			for (var key in source) if (Object.prototype.hasOwnProperty.call(source, key)) target[key] = source[key];
+		}
+		return target;
+	};
+	return _extends.apply(this, arguments);
+}
+const DEFAULT_PREFIX = "rc-table";
+const EMPTY_DATA = [];
+const EMPTY_SCROLL_TARGET = {};
+function defaultEmpty() {
+	return "No Data";
+}
+const Table = (tableProps, ref) => {
+	const props = {
+		rowKey: "key",
+		prefixCls: DEFAULT_PREFIX,
+		emptyText: defaultEmpty,
+		...tableProps
+	};
+	const { prefixCls, className, rowClassName, style, classNames, styles, data, rowKey, scroll, tableLayout, direction, title, footer, summary, caption, id, showHeader, components, emptyText, onRow, onHeaderRow, measureRowRender, onScroll, internalHooks, transformColumns, internalRefs, tailor, getContainerWidth, sticky, rowHoverable = true } = props;
+	const mergedData = data || EMPTY_DATA;
+	const hasData = !!mergedData.length;
+	const useInternalHooks = internalHooks === INTERNAL_HOOKS;
+	const getComponent = React$1.useCallback((path, defaultComponent) => get(components, path) || defaultComponent, [components]);
+	const getRowKey = React$1.useMemo(() => {
+		if (typeof rowKey === "function") return rowKey;
+		return (record) => {
+			return record && record[rowKey];
+		};
+	}, [rowKey]);
+	const customizeScrollBody = getComponent(["body"]);
+	const [startRow, endRow, onHover] = useHover();
+	const [expandableConfig, expandableType, mergedExpandedKeys, mergedExpandIcon, mergedChildrenColumnName, onTriggerExpand] = useExpand(props, mergedData, getRowKey);
+	const scrollX = scroll?.x;
+	const [componentWidth, setComponentWidth] = React$1.useState(0);
+	const [columns, flattenColumns, flattenScrollX] = useColumns({
+		...props,
+		...expandableConfig,
+		expandable: !!expandableConfig.expandedRowRender,
+		columnTitle: expandableConfig.columnTitle,
+		expandedKeys: mergedExpandedKeys,
+		getRowKey,
+		onTriggerExpand,
+		expandIcon: mergedExpandIcon,
+		expandIconColumnIndex: expandableConfig.expandIconColumnIndex,
+		direction,
+		scrollWidth: useInternalHooks && tailor && typeof scrollX === "number" ? scrollX : null,
+		clientWidth: componentWidth
+	}, useInternalHooks ? transformColumns : null);
+	const mergedScrollX = flattenScrollX ?? scrollX;
+	const columnContext = React$1.useMemo(() => ({
+		columns,
+		flattenColumns
+	}), [columns, flattenColumns]);
+	const fullTableRef = React$1.useRef(null);
+	const scrollHeaderRef = React$1.useRef(null);
+	const scrollBodyRef = React$1.useRef(null);
+	const scrollBodyContainerRef = React$1.useRef(null);
+	React$1.useImperativeHandle(ref, () => {
+		return {
+			nativeElement: fullTableRef.current,
+			scrollTo: (config) => {
+				if (scrollBodyRef.current instanceof HTMLElement) {
+					const { index, top, key, offset } = config;
+					if (validNumberValue(top)) scrollBodyRef.current?.scrollTo({ top });
+					else {
+						const mergedKey = key ?? getRowKey(mergedData[index]);
+						const targetElement = scrollBodyRef.current.querySelector(`[data-row-key="${mergedKey}"]`);
+						if (targetElement) {
+							if (!offset) targetElement.scrollIntoView();
+							else {
+								const elementTop = targetElement.offsetTop;
+								scrollBodyRef.current.scrollTo({ top: elementTop + offset });
+							}
+						}
+					}
+				} else if (scrollBodyRef.current?.scrollTo) scrollBodyRef.current.scrollTo(config);
+			}
+		};
+	});
+	const scrollSummaryRef = React$1.useRef(null);
+	const [shadowStart, setShadowStart] = React$1.useState(false);
+	const [shadowEnd, setShadowEnd] = React$1.useState(false);
+	const [colsWidths, updateColsWidths] = React$1.useState(/* @__PURE__ */ new Map());
+	const pureColWidths = getColumnsKey(flattenColumns).map((columnKey) => colsWidths.get(columnKey));
+	const colWidths = React$1.useMemo(() => pureColWidths, [pureColWidths.join("_")]);
+	const stickyOffsets = useStickyOffsets(colWidths, flattenColumns);
+	const fixHeader = scroll && validateValue(scroll.y);
+	const horizonScroll = scroll && validateValue(mergedScrollX) || Boolean(expandableConfig.fixed);
+	const fixColumn = horizonScroll && flattenColumns.some(({ fixed }) => fixed);
+	const stickyRef = React$1.useRef(null);
+	const { isSticky, offsetHeader, offsetSummary, offsetScroll, stickyClassName, container } = useSticky(sticky, prefixCls);
+	const summaryNode = React$1.useMemo(() => summary?.(mergedData), [summary, mergedData]);
+	const fixFooter = (fixHeader || isSticky) && /*#__PURE__*/ React$1.isValidElement(summaryNode) && summaryNode.type === Summary && summaryNode.props.fixed;
+	let scrollXStyle;
+	let scrollYStyle;
+	let scrollTableStyle;
+	if (fixHeader) scrollYStyle = {
+		overflowY: hasData ? "scroll" : "auto",
+		maxHeight: scroll.y
+	};
+	if (horizonScroll) {
+		scrollXStyle = { overflowX: "auto" };
+		if (!fixHeader) scrollYStyle = { overflowY: "hidden" };
+		scrollTableStyle = {
+			width: mergedScrollX === true ? "auto" : mergedScrollX,
+			minWidth: "100%"
+		};
+	}
+	const onColumnResize = React$1.useCallback((columnKey, width) => {
+		updateColsWidths((widths) => {
+			if (widths.get(columnKey) !== width) {
+				const newWidths = new Map(widths);
+				newWidths.set(columnKey, width);
+				return newWidths;
+			}
+			return widths;
+		});
+	}, []);
+	const [setScrollTarget, getScrollTarget] = useTimeoutLock(null);
+	function forceScroll(scrollLeft, target) {
+		if (!target) return;
+		if (typeof target === "function") target(scrollLeft);
+		else if (target.scrollLeft !== scrollLeft) {
+			target.scrollLeft = scrollLeft;
+			if (target.scrollLeft !== scrollLeft) setTimeout(() => {
+				target.scrollLeft = scrollLeft;
+			}, 0);
+		}
+	}
+	const [scrollInfo, setScrollInfo] = React$1.useState([0, 0]);
+	const onInternalScroll = useEvent(({ currentTarget, scrollLeft }) => {
+		const mergedScrollLeft = typeof scrollLeft === "number" ? scrollLeft : currentTarget.scrollLeft;
+		const compareTarget = currentTarget || EMPTY_SCROLL_TARGET;
+		if (!getScrollTarget() || getScrollTarget() === compareTarget) {
+			setScrollTarget(compareTarget);
+			forceScroll(mergedScrollLeft, scrollHeaderRef.current);
+			forceScroll(mergedScrollLeft, scrollBodyRef.current);
+			forceScroll(mergedScrollLeft, scrollSummaryRef.current);
+			forceScroll(mergedScrollLeft, stickyRef.current?.setScrollLeft);
+		}
+		const measureTarget = currentTarget || scrollHeaderRef.current;
+		if (measureTarget) {
+			const scrollWidth = useInternalHooks && tailor && typeof mergedScrollX === "number" ? mergedScrollX : measureTarget.scrollWidth;
+			const clientWidth = measureTarget.clientWidth;
+			const absScrollStart = Math.abs(mergedScrollLeft);
+			setScrollInfo((ori) => {
+				const nextScrollInfo = [absScrollStart, scrollWidth - clientWidth];
+				return isEqual(ori, nextScrollInfo) ? ori : nextScrollInfo;
+			});
+			if (scrollWidth === clientWidth) {
+				setShadowStart(false);
+				setShadowEnd(false);
+				return;
+			}
+			setShadowStart(absScrollStart > 0);
+			setShadowEnd(absScrollStart < scrollWidth - clientWidth - 1);
+		}
+	});
+	const onBodyScroll = useEvent((e) => {
+		onInternalScroll(e);
+		onScroll?.(e);
+	});
+	const triggerOnScroll = () => {
+		if (horizonScroll && scrollBodyRef.current) onInternalScroll({
+			currentTarget: getDOM(scrollBodyRef.current),
+			scrollLeft: scrollBodyRef.current?.scrollLeft
+		});
+		else {
+			setShadowStart(false);
+			setShadowEnd(false);
+		}
+	};
+	const onFullTableResize = (offsetWidth) => {
+		stickyRef.current?.checkScrollBarVisible();
+		let mergedWidth = offsetWidth ?? fullTableRef.current?.offsetWidth ?? 0;
+		if (useInternalHooks && getContainerWidth && fullTableRef.current) mergedWidth = getContainerWidth(fullTableRef.current, mergedWidth) || mergedWidth;
+		if (mergedWidth !== componentWidth) {
+			triggerOnScroll();
+			setComponentWidth(mergedWidth);
+		}
+	};
+	useLayoutEffect$1(() => {
+		if (horizonScroll) onFullTableResize();
+	}, [horizonScroll]);
+	const mounted = React$1.useRef(false);
+	React$1.useEffect(() => {
+		if (mounted.current) triggerOnScroll();
+	}, [
+		horizonScroll,
+		data,
+		columns.length
+	]);
+	React$1.useEffect(() => {
+		mounted.current = true;
+	}, []);
+	const [scrollbarSize, setScrollbarSize] = React$1.useState(0);
+	useLayoutEffect$1(() => {
+		if (!tailor || !useInternalHooks) {
+			if (scrollBodyRef.current instanceof Element) setScrollbarSize(getTargetScrollBarSize(scrollBodyRef.current).width);
+			else setScrollbarSize(getTargetScrollBarSize(scrollBodyContainerRef.current).width);
+		}
+	}, []);
+	React$1.useEffect(() => {
+		if (useInternalHooks && internalRefs) internalRefs.body.current = scrollBodyRef.current;
+	});
+	const renderFixedHeaderTable = React$1.useCallback((fixedHolderPassProps) => /*#__PURE__*/ React$1.createElement(React$1.Fragment, null, /*#__PURE__*/ React$1.createElement(Header_default, fixedHolderPassProps), fixFooter === "top" && /*#__PURE__*/ React$1.createElement(Footer_default, fixedHolderPassProps, summaryNode)), [fixFooter, summaryNode]);
+	const renderFixedFooterTable = React$1.useCallback((fixedHolderPassProps) => /*#__PURE__*/ React$1.createElement(Footer_default, fixedHolderPassProps, summaryNode), [summaryNode]);
+	const TableComponent = getComponent(["table"], "table");
+	const mergedTableLayout = React$1.useMemo(() => {
+		if (tableLayout) return tableLayout;
+		if (fixColumn) return mergedScrollX === "max-content" ? "auto" : "fixed";
+		if (fixHeader || isSticky || flattenColumns.some(({ ellipsis }) => ellipsis)) return "fixed";
+		return "auto";
+	}, [
+		fixHeader,
+		fixColumn,
+		flattenColumns,
+		tableLayout,
+		isSticky
+	]);
+	let groupTableNode;
+	const headerProps = {
+		colWidths,
+		columCount: flattenColumns.length,
+		stickyOffsets,
+		onHeaderRow,
+		fixHeader,
+		scroll
+	};
+	const emptyNode = React$1.useMemo(() => {
+		if (hasData) return null;
+		if (typeof emptyText === "function") return emptyText();
+		return emptyText;
+	}, [hasData, emptyText]);
+	const bodyTable = /*#__PURE__*/ React$1.createElement(Body_default, {
+		data: mergedData,
+		measureColumnWidth: fixHeader || horizonScroll || isSticky
+	});
+	const bodyColGroup = /*#__PURE__*/ React$1.createElement(ColGroup, {
+		colWidths: flattenColumns.map(({ width }) => width),
+		columns: flattenColumns
+	});
+	const captionElement = caption !== null && caption !== void 0 ? /*#__PURE__*/ React$1.createElement("caption", { className: `${prefixCls}-caption` }, caption) : void 0;
+	const dataProps = pickAttrs(props, { data: true });
+	const ariaProps = pickAttrs(props, { aria: true });
+	if (fixHeader || isSticky) {
+		let bodyContent;
+		if (typeof customizeScrollBody === "function") {
+			bodyContent = customizeScrollBody(mergedData, {
+				scrollbarSize,
+				ref: scrollBodyRef,
+				onScroll: onInternalScroll
+			});
+			headerProps.colWidths = flattenColumns.map(({ width }, index) => {
+				const colWidth = index === flattenColumns.length - 1 ? width - scrollbarSize : width;
+				if (typeof colWidth === "number" && !Number.isNaN(colWidth)) return colWidth;
+				return 0;
+			});
+		} else bodyContent = /*#__PURE__*/ React$1.createElement("div", {
+			style: {
+				...scrollXStyle,
+				...scrollYStyle
+			},
+			onScroll: onBodyScroll,
+			ref: scrollBodyRef,
+			className: `${prefixCls}-body`
+		}, /*#__PURE__*/ React$1.createElement(TableComponent, _extends({ style: {
+			...scrollTableStyle,
+			tableLayout: mergedTableLayout
+		} }, ariaProps), captionElement, bodyColGroup, bodyTable, !fixFooter && summaryNode && /*#__PURE__*/ React$1.createElement(Footer_default, {
+			stickyOffsets,
+			flattenColumns
+		}, summaryNode)));
+		const fixedHolderProps = {
+			noData: !mergedData.length,
+			maxContentScroll: horizonScroll && mergedScrollX === "max-content",
+			...headerProps,
+			...columnContext,
+			direction,
+			stickyClassName,
+			scrollX: mergedScrollX,
+			tableLayout: mergedTableLayout,
+			onScroll: onInternalScroll
+		};
+		groupTableNode = /*#__PURE__*/ React$1.createElement(React$1.Fragment, null, showHeader !== false && /*#__PURE__*/ React$1.createElement(FixedHolder_default, _extends({}, fixedHolderProps, {
+			stickyTopOffset: offsetHeader,
+			className: `${prefixCls}-header`,
+			ref: scrollHeaderRef,
+			colGroup: bodyColGroup
+		}), renderFixedHeaderTable), bodyContent, fixFooter && fixFooter !== "top" && /*#__PURE__*/ React$1.createElement(FixedHolder_default, _extends({}, fixedHolderProps, {
+			stickyBottomOffset: offsetSummary,
+			className: `${prefixCls}-summary`,
+			ref: scrollSummaryRef,
+			colGroup: bodyColGroup
+		}), renderFixedFooterTable), isSticky && scrollBodyRef.current && scrollBodyRef.current instanceof Element && /*#__PURE__*/ React$1.createElement(stickyScrollBar_default, {
+			ref: stickyRef,
+			offsetScroll,
+			scrollBodyRef,
+			onScroll: onInternalScroll,
+			container,
+			direction
+		}));
+	} else groupTableNode = /*#__PURE__*/ React$1.createElement("div", {
+		style: {
+			...scrollXStyle,
+			...scrollYStyle,
+			...styles?.content
+		},
+		className: clsx(`${prefixCls}-content`, classNames?.content),
+		onScroll: onInternalScroll,
+		ref: scrollBodyRef
+	}, /*#__PURE__*/ React$1.createElement(TableComponent, _extends({ style: {
+		...scrollTableStyle,
+		tableLayout: mergedTableLayout
+	} }, ariaProps), captionElement, bodyColGroup, showHeader !== false && /*#__PURE__*/ React$1.createElement(Header_default, _extends({}, headerProps, columnContext)), bodyTable, summaryNode && /*#__PURE__*/ React$1.createElement(Footer_default, {
+		stickyOffsets,
+		flattenColumns
+	}, summaryNode)));
+	const tableStyle = { ...style };
+	if (isSticky) tableStyle["--columns-count"] = flattenColumns.length;
+	let fullTable = /*#__PURE__*/ React$1.createElement("div", _extends({
+		className: clsx(prefixCls, className, {
+			[`${prefixCls}-rtl`]: direction === "rtl",
+			[`${prefixCls}-fix-start-shadow`]: horizonScroll,
+			[`${prefixCls}-fix-end-shadow`]: horizonScroll,
+			[`${prefixCls}-fix-start-shadow-show`]: horizonScroll && shadowStart,
+			[`${prefixCls}-fix-end-shadow-show`]: horizonScroll && shadowEnd,
+			[`${prefixCls}-layout-fixed`]: tableLayout === "fixed",
+			[`${prefixCls}-fixed-header`]: fixHeader,
+			/** No used but for compatible */
+			[`${prefixCls}-fixed-column`]: fixColumn,
+			[`${prefixCls}-scroll-horizontal`]: horizonScroll,
+			[`${prefixCls}-has-fix-start`]: flattenColumns[0]?.fixed,
+			[`${prefixCls}-has-fix-end`]: flattenColumns[flattenColumns.length - 1]?.fixed === "end"
+		}),
+		style: tableStyle,
+		id,
+		ref: fullTableRef
+	}, dataProps), title && /*#__PURE__*/ React$1.createElement(Panel, {
+		className: clsx(`${prefixCls}-title`, classNames?.title),
+		style: styles?.title
+	}, title(mergedData)), /*#__PURE__*/ React$1.createElement("div", {
+		ref: scrollBodyContainerRef,
+		className: clsx(`${prefixCls}-container`, classNames?.section),
+		style: styles?.section
+	}, groupTableNode), footer && /*#__PURE__*/ React$1.createElement(Panel, {
+		className: clsx(`${prefixCls}-footer`, classNames?.footer),
+		style: styles?.footer
+	}, footer(mergedData)));
+	if (horizonScroll) fullTable = /*#__PURE__*/ React$1.createElement(RefResizeObserver, { onResize: ({ offsetWidth }) => onFullTableResize(offsetWidth) }, fullTable);
+	const fixedInfoList = useFixedInfo(flattenColumns, stickyOffsets);
+	const TableContextValue = React$1.useMemo(() => ({
+		scrollX: mergedScrollX,
+		scrollInfo,
+		classNames,
+		styles,
+		prefixCls,
+		getComponent,
+		scrollbarSize,
+		direction,
+		fixedInfoList,
+		isSticky,
+		componentWidth,
+		fixHeader,
+		fixColumn,
+		horizonScroll,
+		tableLayout: mergedTableLayout,
+		rowClassName,
+		expandedRowClassName: expandableConfig.expandedRowClassName,
+		expandIcon: mergedExpandIcon,
+		expandableType,
+		expandRowByClick: expandableConfig.expandRowByClick,
+		expandedRowRender: expandableConfig.expandedRowRender,
+		expandedRowOffset: expandableConfig.expandedRowOffset,
+		onTriggerExpand,
+		expandIconColumnIndex: expandableConfig.expandIconColumnIndex,
+		indentSize: expandableConfig.indentSize,
+		allColumnsFixedLeft: flattenColumns.every((col) => col.fixed === "start"),
+		emptyNode,
+		columns,
+		flattenColumns,
+		onColumnResize,
+		colWidths,
+		hoverStartRow: startRow,
+		hoverEndRow: endRow,
+		onHover,
+		rowExpandable: expandableConfig.rowExpandable,
+		onRow,
+		getRowKey,
+		expandedKeys: mergedExpandedKeys,
+		childrenColumnName: mergedChildrenColumnName,
+		rowHoverable,
+		measureRowRender
+	}), [
+		mergedScrollX,
+		scrollInfo,
+		classNames,
+		styles,
+		prefixCls,
+		getComponent,
+		scrollbarSize,
+		direction,
+		fixedInfoList,
+		isSticky,
+		componentWidth,
+		fixHeader,
+		fixColumn,
+		horizonScroll,
+		mergedTableLayout,
+		rowClassName,
+		expandableConfig.expandedRowClassName,
+		mergedExpandIcon,
+		expandableType,
+		expandableConfig.expandRowByClick,
+		expandableConfig.expandedRowRender,
+		expandableConfig.expandedRowOffset,
+		onTriggerExpand,
+		expandableConfig.expandIconColumnIndex,
+		expandableConfig.indentSize,
+		emptyNode,
+		columns,
+		flattenColumns,
+		onColumnResize,
+		colWidths,
+		startRow,
+		endRow,
+		onHover,
+		expandableConfig.rowExpandable,
+		onRow,
+		getRowKey,
+		mergedExpandedKeys,
+		mergedChildrenColumnName,
+		rowHoverable,
+		measureRowRender
+	]);
+	return /*#__PURE__*/ React$1.createElement(TableContext.Provider, { value: TableContextValue }, fullTable);
+};
+const RefTable = /*#__PURE__*/ React$1.forwardRef(Table);
+const genTable = (shouldTriggerRender) => {
+	return makeImmutable(RefTable, shouldTriggerRender);
+};
+const ImmutableTable = genTable();
+ImmutableTable.EXPAND_COLUMN = EXPAND_COLUMN;
+ImmutableTable.INTERNAL_HOOKS = INTERNAL_HOOKS;
+ImmutableTable.Column = Column;
+ImmutableTable.ColumnGroup = ColumnGroup;
+ImmutableTable.Summary = FooterComponents;
+//#endregion
+export { DEFAULT_PREFIX, ImmutableTable as default, genTable };

package/vendor/@rc-component/table/es/VirtualTable/BodyGrid.js

@@ -0,0 +1,171 @@
+import es_default from "../../../virtual-list/es/index.js";
+import { useContext as useContext$1 } from "../../../context/es/context.js";
+import "../../../context/es/index.js";
+import TableContext, { responseImmutable } from "../context/TableContext.js";
+import useFlattenRecords from "../hooks/useFlattenRecords.js";
+import { GridContext, StaticContext } from "./context.js";
+import ResponseBodyLine from "./BodyLine.js";
+import * as React$1 from "../../../../react/index.js";
+const ResponseGrid = responseImmutable(/* @__PURE__ */ React$1.forwardRef((props, ref) => {
+	const { data, onScroll } = props;
+	const { flattenColumns, onColumnResize, getRowKey, expandedKeys, prefixCls, childrenColumnName, scrollX, direction } = useContext$1(TableContext, [
+		"flattenColumns",
+		"onColumnResize",
+		"getRowKey",
+		"prefixCls",
+		"expandedKeys",
+		"childrenColumnName",
+		"scrollX",
+		"direction"
+	]);
+	const { sticky, scrollY, listItemHeight, getComponent, onScroll: onTablePropScroll } = useContext$1(StaticContext);
+	const listRef = React$1.useRef(null);
+	const flattenData = useFlattenRecords(data, childrenColumnName, expandedKeys, getRowKey);
+	const columnsWidth = React$1.useMemo(() => {
+		let total = 0;
+		return flattenColumns.map(({ width, minWidth, key }) => {
+			const finalWidth = Math.max(width || 0, minWidth || 0);
+			total += finalWidth;
+			return [
+				key,
+				finalWidth,
+				total
+			];
+		});
+	}, [flattenColumns]);
+	const columnsOffset = React$1.useMemo(() => columnsWidth.map((colWidth) => colWidth[2]), [columnsWidth]);
+	React$1.useEffect(() => {
+		columnsWidth.forEach(([key, width]) => {
+			onColumnResize(key, width);
+		});
+	}, [columnsWidth]);
+	React$1.useImperativeHandle(ref, () => {
+		const obj = {
+			scrollTo: (config) => {
+				const { offset, ...restConfig } = config;
+				if (offset) listRef.current?.scrollTo({
+					...restConfig,
+					offset,
+					align: "top"
+				});
+				else listRef.current?.scrollTo(config);
+			},
+			nativeElement: listRef.current?.nativeElement
+		};
+		Object.defineProperty(obj, "scrollLeft", {
+			get: () => listRef.current?.getScrollInfo().x || 0,
+			set: (value) => {
+				listRef.current?.scrollTo({ left: value });
+			}
+		});
+		Object.defineProperty(obj, "scrollTop", {
+			get: () => listRef.current?.getScrollInfo().y || 0,
+			set: (value) => {
+				listRef.current?.scrollTo({ top: value });
+			}
+		});
+		return obj;
+	});
+	const getRowSpan = (column, index) => {
+		const record = flattenData[index]?.record;
+		const { onCell } = column;
+		if (onCell) return onCell(record, index)?.rowSpan ?? 1;
+		return 1;
+	};
+	const extraRender = (info) => {
+		const { start, end, getSize, offsetY } = info;
+		if (end < 0) return null;
+		let firstRowSpanColumns = flattenColumns.filter((column) => getRowSpan(column, start) === 0);
+		let startIndex = start;
+		for (let i = start; i >= 0; i -= 1) {
+			firstRowSpanColumns = firstRowSpanColumns.filter((column) => getRowSpan(column, i) === 0);
+			if (!firstRowSpanColumns.length) {
+				startIndex = i;
+				break;
+			}
+		}
+		let lastRowSpanColumns = flattenColumns.filter((column) => getRowSpan(column, end) !== 1);
+		let endIndex = end;
+		for (let i = end; i < flattenData.length; i += 1) {
+			lastRowSpanColumns = lastRowSpanColumns.filter((column) => getRowSpan(column, i) !== 1);
+			if (!lastRowSpanColumns.length) {
+				endIndex = Math.max(i - 1, end);
+				break;
+			}
+		}
+		const spanLines = [];
+		for (let i = startIndex; i <= endIndex; i += 1) {
+			if (!flattenData[i]) continue;
+			if (flattenColumns.some((column) => getRowSpan(column, i) > 1)) spanLines.push(i);
+		}
+		return spanLines.map((index) => {
+			const item = flattenData[index];
+			const rowKey = getRowKey(item.record, index);
+			const getHeight = (rowSpan) => {
+				const endItemIndex = index + rowSpan - 1;
+				const endItem = flattenData[endItemIndex];
+				if (!endItem || !endItem.record) {
+					const safeEndIndex = Math.min(endItemIndex, flattenData.length - 1);
+					const safeEndItem = flattenData[safeEndIndex];
+					const endItemKey = getRowKey(safeEndItem.record, safeEndIndex);
+					const sizeInfo = getSize(rowKey, endItemKey);
+					return sizeInfo.bottom - sizeInfo.top;
+				}
+				const endItemKey = getRowKey(endItem.record, endItemIndex);
+				const sizeInfo = getSize(rowKey, endItemKey);
+				return sizeInfo.bottom - sizeInfo.top;
+			};
+			const sizeInfo = getSize(rowKey);
+			return /*#__PURE__*/ React$1.createElement(ResponseBodyLine, {
+				key: index,
+				data: item,
+				rowKey,
+				index,
+				style: { top: -offsetY + sizeInfo.top },
+				extra: true,
+				getHeight
+			});
+		});
+	};
+	const gridContext = React$1.useMemo(() => ({ columnsOffset }), [columnsOffset]);
+	const tblPrefixCls = `${prefixCls}-tbody`;
+	const wrapperComponent = getComponent(["body", "wrapper"]);
+	const horizontalScrollBarStyle = {};
+	if (sticky) {
+		horizontalScrollBarStyle.position = "sticky";
+		horizontalScrollBarStyle.bottom = 0;
+		if (typeof sticky === "object" && sticky.offsetScroll) horizontalScrollBarStyle.bottom = sticky.offsetScroll;
+	}
+	return /*#__PURE__*/ React$1.createElement(GridContext.Provider, { value: gridContext }, /*#__PURE__*/ React$1.createElement(es_default, {
+		fullHeight: false,
+		ref: listRef,
+		prefixCls: `${tblPrefixCls}-virtual`,
+		styles: { horizontalScrollBar: horizontalScrollBarStyle },
+		className: tblPrefixCls,
+		height: scrollY,
+		itemHeight: listItemHeight || 24,
+		data: flattenData,
+		itemKey: (item) => getRowKey(item.record),
+		component: wrapperComponent,
+		scrollWidth: scrollX,
+		direction,
+		onVirtualScroll: ({ x }) => {
+			onScroll({
+				currentTarget: listRef.current?.nativeElement,
+				scrollLeft: x
+			});
+		},
+		onScroll: onTablePropScroll,
+		extraRender
+	}, (item, index, itemProps) => {
+		const rowKey = getRowKey(item.record, index);
+		return /*#__PURE__*/ React$1.createElement(ResponseBodyLine, {
+			data: item,
+			rowKey,
+			index,
+			style: itemProps.style
+		});
+	}));
+}));
+//#endregion
+export { ResponseGrid as default };