@sheinx/hooks 3.0.0-alpha.1

package/cjs/components/use-table/use-table-sort.js

@@ -0,0 +1,169 @@
+"use strict";
+
+require("core-js/modules/es.object.get-own-property-descriptors.js");
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+require("core-js/modules/es.array.iterator.js");
+require("core-js/modules/es.map.js");
+require("core-js/modules/web.dom-collections.iterator.js");
+require("core-js/modules/es.array.map.js");
+require("core-js/modules/es.array.sort.js");
+require("core-js/modules/es.array.filter.js");
+require("core-js/modules/es.array.from.js");
+require("core-js/modules/web.dom-collections.for-each.js");
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _react = require("react");
+var _ = require("../..");
+var _is = require("../../utils/is");
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+var useTableSort = function useTableSort(props) {
+  var sorter = props.sorter,
+    data = props.data;
+  var _useState = (0, _react.useState)(new Map()),
+    _useState2 = (0, _slicedToArray2.default)(_useState, 2),
+    sortInfo = _useState2[0],
+    setSortInfo = _useState2[1];
+  var _useRef = (0, _react.useRef)({
+      mounted: false,
+      sortInfo: new Map()
+    }),
+    context = _useRef.current;
+  if (!context.sortInfo) {
+    context.sortInfo = sortInfo;
+  }
+  var getSortList = (0, _.usePersistFn)(function (info) {
+    return Array.from(info.keys()).filter(function (name) {
+      var _info$get;
+      return (_info$get = info.get(name)) === null || _info$get === void 0 ? void 0 : _info$get.order;
+    }).sort(function (a, b) {
+      var _info$get2, _info$get3;
+      return (((_info$get2 = info.get(a)) === null || _info$get2 === void 0 ? void 0 : _info$get2.weight) || 0) - (((_info$get3 = info.get(b)) === null || _info$get3 === void 0 ? void 0 : _info$get3.weight) || 0);
+    }).map(function (name) {
+      var _info$get4;
+      return _objectSpread(_objectSpread({
+        key: name
+      }, info.get(name)), {}, {
+        order: (_info$get4 = info.get(name)) === null || _info$get4 === void 0 ? void 0 : _info$get4.order
+      });
+    });
+  });
+  var sortedData = (0, _react.useMemo)(function () {
+    var newData = (0, _toConsumableArray2.default)(data || []);
+    var sortList = getSortList(sortInfo);
+    sortList.forEach(function (sort) {
+      if (sort.sort) newData.sort(sort.sort);
+    });
+    return newData;
+  }, [sortInfo, data]);
+  var onSorterChange = (0, _.usePersistFn)(function (columnKey, direction) {
+    var manual = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
+    var columnSorter = arguments.length > 3 ? arguments[3] : undefined;
+    var sortName = undefined;
+    if (typeof columnSorter === 'string') {
+      sortName = columnSorter;
+    } else if ((0, _is.isObject)(columnSorter) && !(0, _is.isFunc)(columnSorter)) {
+      if (typeof columnSorter.rule === 'string') {
+        sortName = columnSorter.rule;
+      }
+    }
+    if (direction) {
+      var _Array$from$;
+      var _sortInfo = context.sortInfo;
+      var multiple = (_Array$from$ = Array.from(_sortInfo.values())[0]) === null || _Array$from$ === void 0 ? void 0 : _Array$from$.multiple;
+      var sortObj = {
+        weight: 0,
+        manual: manual,
+        order: direction,
+        multiple: false
+      };
+      var newInfo = multiple ? new Map(_sortInfo) : new Map();
+      newInfo.set(columnKey, sortObj);
+      if ((0, _is.isFunc)(columnSorter)) {
+        sortObj.sort = columnSorter(direction);
+        sortObj.multiple = false;
+      } else if ((0, _is.isObject)(columnSorter)) {
+        sortObj.weight = columnSorter.weight || 0;
+        sortObj.multiple = true;
+        var rule = columnSorter.rule;
+        if (typeof rule === 'string') {} else if ((0, _is.isFunc)(rule)) {
+          var infoList = getSortList(newInfo).map(function (item) {
+            return {
+              key: item.key,
+              order: item.order,
+              weight: item.weight,
+              manual: !!item.manual
+            };
+          });
+          sortObj.sort = rule(infoList);
+        }
+      } else if (typeof columnSorter === 'string') {
+        sortObj.multiple = false;
+        sortObj.weight = 0;
+      }
+      if (sortName && sorter) {
+        var _infoList = getSortList(newInfo).map(function (item) {
+          return {
+            key: item.key,
+            order: item.order,
+            weight: item.weight,
+            manual: !!item.manual
+          };
+        });
+        sortObj.sort = sorter(sortName, direction, _infoList);
+      }
+      setSortInfo(newInfo);
+      context.sortInfo = newInfo;
+    } else {
+      var _sortInfo$get;
+      var beforeSortOrder = (_sortInfo$get = sortInfo.get(columnKey)) === null || _sortInfo$get === void 0 ? void 0 : _sortInfo$get.order;
+      var info = new Map(sortInfo);
+      info.delete(columnKey);
+      setSortInfo(info);
+      context.sortInfo = info;
+      var _infoList2 = getSortList(info).map(function (item) {
+        return {
+          key: item.key,
+          order: item.order,
+          weight: item.weight,
+          manual: !!item.manual
+        };
+      });
+      if (sortName) {
+        var _props$onSortCancel;
+        (_props$onSortCancel = props.onSortCancel) === null || _props$onSortCancel === void 0 ? void 0 : _props$onSortCancel.call(props, beforeSortOrder, columnKey, _infoList2, sortName);
+      }
+    }
+  });
+  (0, _react.useEffect)(function () {
+    if (context.mounted) return;
+    var hasSingleDefaultOrder = false;
+    for (var i = 0; i < props.columns.length; i++) {
+      var col = props.columns[i];
+      if (col.defaultOrder && col.sorter) {
+        if ((0, _typeof2.default)(col.sorter) !== 'object') {
+          if (hasSingleDefaultOrder) {
+            break;
+          } else {
+            hasSingleDefaultOrder = true;
+          }
+        }
+        onSorterChange(col.key, col.defaultOrder, false, col.sorter);
+      }
+    }
+    context.mounted = true;
+  }, []);
+  return {
+    sortInfo: sortInfo,
+    onSorterChange: onSorterChange,
+    sortedData: sortedData
+  };
+};
+var _default = useTableSort;
+exports.default = _default;

package/cjs/components/use-table/use-table-tree.d.ts

@@ -0,0 +1,18 @@
+import type { BaseTableProps } from './use-table.type';
+import { OptionalToRequired } from '../../common/type';
+export interface UseTableTreeProps extends Pick<OptionalToRequired<BaseTableProps<any>>, 'onTreeExpand' | 'treeCheckAll' | 'treeExpandKeys' | 'defaultTreeExpandKeys' | 'keygen'> {
+    treeColumnsName: string | undefined;
+    data: any[];
+}
+export declare const useTableTree: (props: UseTableTreeProps) => {
+    data: any[];
+    treeExpandLevel: Map<any, number>;
+    changedByExpand: boolean;
+    isEmptyTree: boolean;
+    func: {
+        isTreeExpanded: (data: any, index: number) => boolean;
+        handleTreeExpand: (data: any, index: number) => void;
+    };
+};
+export default useTableTree;
+//# sourceMappingURL=use-table-tree.d.ts.map

package/cjs/components/use-table/use-table-tree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-table-tree.d.ts","sourceRoot":"","sources":["use-table-tree.tsx"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAEvD,OAAO,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAGvD,MAAM,WAAW,iBACf,SAAQ,IAAI,CACV,kBAAkB,CAAC,cAAc,CAAC,GAAG,CAAC,CAAC,EACvC,cAAc,GAAG,cAAc,GAAG,gBAAgB,GAAG,uBAAuB,GAAG,QAAQ,CACxF;IACD,eAAe,EAAE,MAAM,GAAG,SAAS,CAAC;IACpC,IAAI,EAAE,GAAG,EAAE,CAAC;CACb;AAED,eAAO,MAAM,YAAY,UAAW,iBAAiB;;;;;;+BA4DR,GAAG,SAAS,MAAM;iCA9ChB,GAAG,SAAS,MAAM;;CAsEhE,CAAC;AAEF,eAAe,YAAY,CAAC"}

package/cjs/components/use-table/use-table-tree.js

@@ -0,0 +1,115 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useTableTree = exports.default = void 0;
+require("core-js/modules/es.array.iterator.js");
+require("core-js/modules/es.set.js");
+require("core-js/modules/web.dom-collections.iterator.js");
+require("core-js/modules/es.array.from.js");
+require("core-js/modules/es.map.js");
+require("core-js/modules/web.dom-collections.for-each.js");
+require("core-js/modules/es.array.splice.js");
+require("core-js/modules/es.array.concat.js");
+require("core-js/modules/es.array.includes.js");
+require("core-js/modules/es.string.includes.js");
+require("core-js/modules/es.array.filter.js");
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _react = require("react");
+var _usePersistFn = require("../../common/use-persist-fn");
+var _render = require("../../utils/render");
+var _is = require("../../utils/is");
+var _useLatestObj = require("../../common/use-latest-obj");
+var useTableTree = function useTableTree(props) {
+  var _props$data$filter;
+  var _useState = (0, _react.useState)(props.defaultTreeExpandKeys || []),
+    _useState2 = (0, _slicedToArray2.default)(_useState, 2),
+    expandKeysState = _useState2[0],
+    setExpandKeysState = _useState2[1];
+  var _useRef = (0, _react.useRef)({
+      changedByExpand: false
+    }),
+    context = _useRef.current;
+  (0, _react.useEffect)(function () {
+    context.changedByExpand = false;
+  }, [expandKeysState, props.treeExpandKeys]);
+  var getExpandKeys = function getExpandKeys() {
+    return props.treeExpandKeys === undefined ? expandKeysState : props.treeExpandKeys;
+  };
+  var handleTreeExpand = (0, _usePersistFn.usePersistFn)(function (data, index) {
+    var expandKeys = getExpandKeys();
+    var key = (0, _render.getKey)(props.keygen, data, index);
+    var changeKeys = new Set(expandKeys);
+    if (changeKeys.has(key)) {
+      changeKeys.delete(key);
+    } else {
+      changeKeys.add(key);
+    }
+    if (props.treeExpandKeys === undefined) {
+      setExpandKeysState(Array.from(changeKeys));
+    } else if (props.onTreeExpand) {
+      var _props$onTreeExpand;
+      (_props$onTreeExpand = props.onTreeExpand) === null || _props$onTreeExpand === void 0 ? void 0 : _props$onTreeExpand.call(props, Array.from(changeKeys), data, changeKeys.has(key), index);
+    }
+    context.changedByExpand = true;
+  });
+  var getExpandData = function getExpandData() {
+    var expandKeys = getExpandKeys();
+    var expandSet = new Set(expandKeys);
+    var expandLevel = new Map();
+    if (expandSet.size === 0 || !props.treeColumnsName) {
+      return [props.data, expandLevel];
+    }
+    var newData = (0, _toConsumableArray2.default)(props.data || []);
+    var _loop = function _loop() {
+      if (expandSet.size === 0) return "break";
+      var item = newData[i];
+      var key = (0, _render.getKey)(props.keygen, item, i);
+      var parentLevel = expandLevel.get(key) || 0;
+      var children = (0, _is.isObject)(item) && item[props.treeColumnsName];
+      if (expandSet.has(key) && children) {
+        children.forEach(function (child) {
+          expandLevel.set((0, _render.getKey)(props.keygen, child), parentLevel + 1);
+        });
+        newData.splice.apply(newData, [i + 1, 0].concat((0, _toConsumableArray2.default)(children)));
+        expandSet.delete(key);
+      }
+    };
+    for (var i = 0; i < newData.length; i++) {
+      var _ret = _loop();
+      if (_ret === "break") break;
+    }
+    return [newData, expandLevel];
+  };
+  var isTreeExpanded = (0, _usePersistFn.usePersistFn)(function (data, index) {
+    if (!props.treeColumnsName) return false;
+    var expandKeys = getExpandKeys();
+    var key = (0, _render.getKey)(props.keygen, data, index);
+    return expandKeys.includes(key);
+  });
+  var func = (0, _useLatestObj.useLatestObj)({
+    isTreeExpanded: isTreeExpanded,
+    handleTreeExpand: handleTreeExpand
+  });
+  var _getExpandData = getExpandData(),
+    _getExpandData2 = (0, _slicedToArray2.default)(_getExpandData, 2),
+    treeData = _getExpandData2[0],
+    treeExpandLevel = _getExpandData2[1];
+  var isEmptyTree = ((_props$data$filter = props.data.filter(function (item) {
+    var _item;
+    return (_item = item[props.treeColumnsName]) === null || _item === void 0 ? void 0 : _item.length;
+  })) === null || _props$data$filter === void 0 ? void 0 : _props$data$filter.length) === 0;
+  return {
+    data: treeData,
+    treeExpandLevel: treeExpandLevel,
+    changedByExpand: context.changedByExpand,
+    isEmptyTree: isEmptyTree,
+    func: func
+  };
+};
+exports.useTableTree = useTableTree;
+var _default = useTableTree;
+exports.default = _default;

package/cjs/components/use-table/use-table-virtual.d.ts

@@ -0,0 +1,28 @@
+/// <reference types="react" />
+interface UseTableVirtualProps {
+    data: any[];
+    rowsInView: number;
+    rowHeight: number;
+    scrollRef: React.RefObject<HTMLDivElement>;
+    innerRef: React.RefObject<HTMLDivElement>;
+    scrollLeft?: number;
+}
+declare const useTableVirtual: (props: UseTableVirtualProps) => {
+    scrollHeight: number;
+    startIndex: number;
+    innerLeft: number;
+    innerTop: number;
+    data: any[];
+    handleScroll: (info: {
+        scrollLeft: number;
+        scrollTop: number;
+        y: number;
+        height: number;
+        fromDrag: boolean;
+    }) => void;
+    setRowHeight: (index: number, height: number) => void;
+    getTranslate: (left?: number, top?: number) => string;
+    scrollToIndex: (index: number) => void;
+};
+export default useTableVirtual;
+//# sourceMappingURL=use-table-virtual.d.ts.map

package/cjs/components/use-table/use-table-virtual.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-table-virtual.d.ts","sourceRoot":"","sources":["use-table-virtual.tsx"],"names":[],"mappings":";AAIA,UAAU,oBAAoB;IAC5B,IAAI,EAAE,GAAG,EAAE,CAAC;IACZ,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,KAAK,CAAC,SAAS,CAAC,cAAc,CAAC,CAAC;IAC3C,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC,cAAc,CAAC,CAAC;IAC1C,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AACD,QAAA,MAAM,eAAe,UAAW,oBAAoB;;;;;;;oBA6FpC,MAAM;mBACP,MAAM;WACd,MAAM;gBACD,MAAM;kBACJ,OAAO;;0BAhEuB,MAAM,UAAU,MAAM;0BAdtB,MAAM,QAAQ,MAAM;2BA4GnB,MAAM;CAkDlD,CAAC;AAEF,eAAe,eAAe,CAAC"}

package/cjs/components/use-table/use-table-virtual.js

@@ -0,0 +1,195 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+require("core-js/modules/es.array.concat.js");
+require("core-js/modules/es.array.slice.js");
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _usePrevious = require("../.../../../common/use-previous");
+var _usePersistFn = require("../../common/use-persist-fn");
+var _react = require("react");
+var useTableVirtual = function useTableVirtual(props) {
+  var _useState = (0, _react.useState)(0),
+    _useState2 = (0, _slicedToArray2.default)(_useState, 2),
+    innerLeft = _useState2[0],
+    setLeft = _useState2[1];
+  var _useState3 = (0, _react.useState)(0),
+    _useState4 = (0, _slicedToArray2.default)(_useState3, 2),
+    innerTop = _useState4[0],
+    setTop = _useState4[1];
+  var _useState5 = (0, _react.useState)(props.data.length * props.rowHeight),
+    _useState6 = (0, _slicedToArray2.default)(_useState5, 2),
+    scrollHeight = _useState6[0],
+    setHeight = _useState6[1];
+  var _useState7 = (0, _react.useState)(0),
+    _useState8 = (0, _slicedToArray2.default)(_useState7, 2),
+    startIndex = _useState8[0],
+    setStartIndex = _useState8[1];
+  var preIndex = (0, _usePrevious.usePrevious)(startIndex);
+  var _useState9 = (0, _react.useState)(0),
+    _useState10 = (0, _slicedToArray2.default)(_useState9, 2),
+    offsetY = _useState10[0],
+    setOffsetY = _useState10[1];
+  var sleft = props.scrollLeft !== undefined ? props.scrollLeft : innerLeft;
+  var _useRef = (0, _react.useRef)({
+      cachedHeight: [],
+      shouldUpdateHeight: true,
+      rateTimer: null,
+      topTimer: null,
+      controlScrollRate: null,
+      heightCallback: null
+    }),
+    context = _useRef.current;
+  var getTranslate = (0, _usePersistFn.usePersistFn)(function (left, top) {
+    var l = left === undefined ? sleft : left;
+    var t = top === undefined ? innerTop + offsetY : top;
+    return "translate3d(-".concat(l, "px, -").concat(t, "px, 0)");
+  });
+  var getContentHeight = function getContentHeight(index) {
+    var sum = 0;
+    for (var i = 0; i <= index; i++) {
+      sum += context.cachedHeight[i] || props.rowHeight;
+    }
+    return sum;
+  };
+  var setRowHeight = (0, _usePersistFn.usePersistFn)(function (index, height) {
+    var beforeHeight = context.cachedHeight[index];
+    if (beforeHeight && beforeHeight === height) return;
+    context.cachedHeight[index] = height;
+    if (context.shouldUpdateHeight) {
+      setHeight(getContentHeight(props.data.length - 1));
+    }
+    if (preIndex && preIndex > startIndex && startIndex === index) {
+      // 发生在顶部
+      if (context.heightCallback) return;
+      var offset = height - (beforeHeight || props.rowHeight);
+      setOffsetY(function (s) {
+        return s + offset;
+      });
+    }
+  });
+  var updateIndexAndTopFromTop = function updateIndexAndTopFromTop(scrollTop) {
+    var sum = 0;
+    var currentIndex = 0;
+    var top = 0;
+    var maxIndex = Math.max(props.data.length - props.rowsInView, 0);
+    for (var i = 0; i <= maxIndex; i++) {
+      sum += context.cachedHeight[i] || props.rowHeight;
+      if (scrollTop < sum || i === maxIndex) {
+        currentIndex = i;
+        var beforeHeight = i === 0 ? 0 : sum - (context.cachedHeight[i] || props.rowHeight);
+        top = scrollTop - beforeHeight;
+        break;
+      }
+    }
+    if (currentIndex !== startIndex) {
+      setStartIndex(currentIndex);
+    }
+    setTop(top);
+  };
+  var updateRateScroll = (0, _usePersistFn.usePersistFn)(function (rate) {
+    var scrollRef = props.scrollRef;
+    var sumHeight = getContentHeight(props.data.length - 1);
+    context.shouldUpdateHeight = true;
+    context.heightCallback = function () {
+      if (scrollRef && scrollRef.current) {
+        var _scrollHeight = scrollRef.current.scrollHeight;
+        var clientHeight = scrollRef.current.clientHeight;
+        var nowTop = scrollRef.current.scrollTop;
+        var max = _scrollHeight - clientHeight;
+        var top = rate * max;
+        if (Math.abs(nowTop - top) < 1) {
+          context.controlScrollRate = null;
+        } else {
+          context.controlScrollRate = rate;
+          scrollRef.current.scrollTop = top;
+        }
+      }
+    };
+    setHeight(sumHeight);
+  });
+  var handleScroll = function handleScroll(info) {
+    var scrollLeft = info.scrollLeft,
+      height = info.height,
+      y = info.y,
+      fromDrag = info.fromDrag;
+    var scrollTop = info.scrollTop;
+    setLeft(scrollLeft);
+    context.shouldUpdateHeight = !fromDrag;
+    var sumHeight = getContentHeight(props.data.length - 1);
+    var max = sumHeight - height;
+    if (scrollTop > max) {
+      scrollTop = max;
+    }
+    if (context.controlScrollRate !== null) {
+      var top = context.controlScrollRate * max;
+      updateIndexAndTopFromTop(top);
+      updateRateScroll(context.controlScrollRate);
+      context.controlScrollRate = null;
+      return;
+    }
+    if (fromDrag) {
+      var _top = y * max;
+      updateIndexAndTopFromTop(_top);
+      if (context.rateTimer) clearTimeout(context.rateTimer);
+      context.rateTimer = setTimeout(function () {
+        updateRateScroll(y);
+      }, 120);
+    } else {
+      updateIndexAndTopFromTop(scrollTop);
+    }
+  };
+  var scrollToIndex = (0, _usePersistFn.usePersistFn)(function (index) {
+    if (props.scrollRef.current) {
+      context.shouldUpdateHeight = true;
+      var i = Math.max(0, Math.min(index, props.data.length - 1));
+      var beforeHeight = getContentHeight(i - 1);
+      context.heightCallback = function () {
+        var beforeHeight2 = getContentHeight(i - 1);
+        if (beforeHeight2 !== beforeHeight) {
+          scrollToIndex(index);
+        }
+      };
+      props.scrollRef.current.scrollTop = beforeHeight;
+    }
+  });
+  (0, _react.useEffect)(function () {
+    if (offsetY) {
+      if (props.scrollRef.current && props.innerRef.current) {
+        setOffsetY(0);
+        setTop(function (s) {
+          return s + offsetY;
+        });
+        props.scrollRef.current.scrollTop += offsetY;
+      }
+    }
+  }, [offsetY, startIndex]);
+  (0, _react.useEffect)(function () {
+    setHeight(getContentHeight(props.data.length - 1));
+  }, [props.data.length]);
+  (0, _react.useEffect)(function () {
+    if (context.heightCallback) {
+      var cb = context.heightCallback;
+      context.heightCallback = null;
+      cb();
+    }
+  }, [scrollHeight]);
+  var renderData = (0, _toConsumableArray2.default)(props.data).slice(startIndex, startIndex + props.rowsInView);
+  return {
+    scrollHeight: scrollHeight,
+    startIndex: startIndex,
+    innerLeft: sleft,
+    innerTop: innerTop + offsetY,
+    data: renderData,
+    handleScroll: handleScroll,
+    setRowHeight: setRowHeight,
+    getTranslate: getTranslate,
+    scrollToIndex: scrollToIndex
+  };
+};
+var _default = useTableVirtual;
+exports.default = _default;