@qsxy/element-plus-react 1.0.0-next.1

package/dist/VirtualList/Item.js

@@ -0,0 +1,37 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/VirtualList/Item.tsx
+var Item_exports = {};
+__export(Item_exports, {
+  Item: () => Item
+});
+module.exports = __toCommonJS(Item_exports);
+var import_react = require("react");
+function Item({ children, setRef }) {
+  const refFunc = (0, import_react.useCallback)((node) => {
+    setRef(node);
+  }, []);
+  return (0, import_react.cloneElement)(import_react.Children.only(children), {
+    ref: refFunc
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Item
+});

package/dist/VirtualList/ScrollBar.d.ts

@@ -0,0 +1,43 @@
+/// <reference types="node" />
+import React, { Component } from 'react';
+export interface ScrollBarProps {
+    prefixCls: string;
+    scrollTop: number;
+    scrollHeight: number;
+    height: number;
+    count: number;
+    onScroll: (scrollTop: number) => void;
+    onStartMove: () => void;
+    onStopMove: () => void;
+}
+interface ScrollBarState {
+    dragging: boolean;
+    pageY: number;
+    startTop: number;
+    visible: boolean;
+}
+export default class ScrollBar extends Component<ScrollBarProps, ScrollBarState> {
+    moveRaf: number;
+    scrollbarRef: React.RefObject<HTMLDivElement>;
+    thumbRef: React.RefObject<HTMLDivElement>;
+    visibleTimeout: NodeJS.Timeout;
+    state: ScrollBarState;
+    componentDidMount(): void;
+    componentDidUpdate(prevProps: ScrollBarProps): void;
+    componentWillUnmount(): void;
+    delayHidden: () => void;
+    onScrollbarTouchStart: (e: TouchEvent) => void;
+    onContainerMouseDown: React.MouseEventHandler<any>;
+    patchEvents: () => void;
+    removeEvents: () => void;
+    onMouseDown: (e: any) => void;
+    onMouseMove: (e: MouseEvent | TouchEvent) => void;
+    onMouseUp: () => void;
+    getSpinHeight: () => number;
+    getEnableScrollRange: () => number;
+    getEnableHeightRange: () => number;
+    getTop: () => number;
+    showScroll: () => boolean;
+    render(): React.JSX.Element;
+}
+export {};

package/dist/VirtualList/ScrollBar.js

@@ -0,0 +1,216 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/VirtualList/ScrollBar.tsx
+var ScrollBar_exports = {};
+__export(ScrollBar_exports, {
+  default: () => ScrollBar
+});
+module.exports = __toCommonJS(ScrollBar_exports);
+var import_classnames = __toESM(require("classnames"));
+var import_react = __toESM(require("react"));
+var import_raf = __toESM(require("./utils/raf"));
+var MIN_SIZE = 20;
+function getPageY(e) {
+  return "touches" in e ? e.touches[0].pageY : e.pageY;
+}
+var ScrollBar = class extends import_react.Component {
+  constructor() {
+    super(...arguments);
+    this.moveRaf = null;
+    this.scrollbarRef = (0, import_react.createRef)();
+    this.thumbRef = (0, import_react.createRef)();
+    // eslint-disable-next-line no-undef
+    this.visibleTimeout = null;
+    this.state = {
+      dragging: false,
+      pageY: null,
+      startTop: null,
+      visible: false
+    };
+    this.delayHidden = () => {
+      clearTimeout(this.visibleTimeout);
+      this.setState({ visible: true });
+      this.visibleTimeout = setTimeout(() => {
+        this.setState({ visible: false });
+      }, 2e3);
+    };
+    this.onScrollbarTouchStart = (e) => {
+      e.preventDefault();
+    };
+    this.onContainerMouseDown = (e) => {
+      e.stopPropagation();
+      e.preventDefault();
+    };
+    // ======================= Clean =======================
+    this.patchEvents = () => {
+      window.addEventListener("mousemove", this.onMouseMove);
+      window.addEventListener("mouseup", this.onMouseUp);
+      this.thumbRef.current.addEventListener("touchmove", this.onMouseMove);
+      this.thumbRef.current.addEventListener("touchend", this.onMouseUp);
+    };
+    this.removeEvents = () => {
+      window.removeEventListener("mousemove", this.onMouseMove);
+      window.removeEventListener("mouseup", this.onMouseUp);
+      this.scrollbarRef.current.removeEventListener("touchstart", this.onScrollbarTouchStart);
+      this.thumbRef.current.removeEventListener("touchstart", this.onMouseDown);
+      this.thumbRef.current.removeEventListener("touchmove", this.onMouseMove);
+      this.thumbRef.current.removeEventListener("touchend", this.onMouseUp);
+      import_raf.default.cancel(this.moveRaf);
+    };
+    // ======================= Thumb =======================
+    this.onMouseDown = (e) => {
+      const { onStartMove } = this.props;
+      this.setState({
+        dragging: true,
+        pageY: getPageY(e),
+        startTop: this.getTop()
+      });
+      onStartMove();
+      this.patchEvents();
+      e.stopPropagation();
+      e.preventDefault();
+    };
+    this.onMouseMove = (e) => {
+      const { dragging, pageY, startTop } = this.state;
+      const { onScroll } = this.props;
+      import_raf.default.cancel(this.moveRaf);
+      if (dragging) {
+        const offsetY = getPageY(e) - pageY;
+        const newTop = startTop + offsetY;
+        const enableScrollRange = this.getEnableScrollRange();
+        const enableHeightRange = this.getEnableHeightRange();
+        const ptg = enableHeightRange ? newTop / enableHeightRange : 0;
+        const newScrollTop = Math.ceil(ptg * enableScrollRange);
+        this.moveRaf = (0, import_raf.default)(() => {
+          onScroll(newScrollTop);
+        });
+      }
+    };
+    this.onMouseUp = () => {
+      const { onStopMove } = this.props;
+      this.setState({ dragging: false });
+      onStopMove();
+      this.removeEvents();
+    };
+    // ===================== Calculate =====================
+    this.getSpinHeight = () => {
+      const { height, count } = this.props;
+      let baseHeight = height / count * 10;
+      baseHeight = Math.max(baseHeight, MIN_SIZE);
+      baseHeight = Math.min(baseHeight, height / 2);
+      return Math.floor(baseHeight);
+    };
+    this.getEnableScrollRange = () => {
+      const { scrollHeight, height } = this.props;
+      return scrollHeight - height || 0;
+    };
+    this.getEnableHeightRange = () => {
+      const { height } = this.props;
+      const spinHeight = this.getSpinHeight();
+      return height - spinHeight || 0;
+    };
+    this.getTop = () => {
+      const { scrollTop } = this.props;
+      const enableScrollRange = this.getEnableScrollRange();
+      const enableHeightRange = this.getEnableHeightRange();
+      if (scrollTop === 0 || enableScrollRange === 0) {
+        return 0;
+      }
+      const ptg = scrollTop / enableScrollRange;
+      return ptg * enableHeightRange;
+    };
+    // Not show scrollbar when height is large than scrollHeight
+    this.showScroll = () => {
+      const { height, scrollHeight } = this.props;
+      return scrollHeight > height;
+    };
+  }
+  componentDidMount() {
+    this.scrollbarRef.current.addEventListener("touchstart", this.onScrollbarTouchStart);
+    this.thumbRef.current.addEventListener("touchstart", this.onMouseDown);
+  }
+  componentDidUpdate(prevProps) {
+    if (prevProps.scrollTop !== this.props.scrollTop) {
+      this.delayHidden();
+    }
+  }
+  componentWillUnmount() {
+    this.removeEvents();
+    clearTimeout(this.visibleTimeout);
+  }
+  // ====================== Render =======================
+  render() {
+    const { dragging, visible } = this.state;
+    const { prefixCls } = this.props;
+    const spinHeight = this.getSpinHeight();
+    const top = this.getTop();
+    const canScroll = this.showScroll();
+    const mergedVisible = canScroll && visible;
+    return /* @__PURE__ */ import_react.default.createElement(
+      "div",
+      {
+        ref: this.scrollbarRef,
+        className: (0, import_classnames.default)(`${prefixCls}-scrollbar`, {
+          [`${prefixCls}-scrollbar-show`]: canScroll
+        }),
+        style: {
+          width: 6,
+          top: 0,
+          bottom: 0,
+          right: 0,
+          position: "absolute",
+          display: mergedVisible ? null : "none"
+        },
+        onMouseDown: this.onContainerMouseDown,
+        onMouseMove: this.delayHidden
+      },
+      /* @__PURE__ */ import_react.default.createElement(
+        "div",
+        {
+          ref: this.thumbRef,
+          className: (0, import_classnames.default)(`${prefixCls}-scrollbar-thumb`, {
+            [`${prefixCls}-scrollbar-thumb-moving`]: dragging
+          }),
+          style: {
+            width: "100%",
+            height: spinHeight,
+            top,
+            left: 0,
+            position: "absolute",
+            background: "rgba(144, 147, 153, 0.3)",
+            borderRadius: 99,
+            cursor: "pointer",
+            userSelect: "none"
+          },
+          onMouseDown: this.onMouseDown
+        }
+      )
+    );
+  }
+};

package/dist/VirtualList/VirtualList.d.ts

@@ -0,0 +1,33 @@
+import React, { ComponentClass, FC, Key, Ref } from 'react';
+import type { RenderFunc } from './interface';
+export type ScrollAlign = 'top' | 'bottom' | 'auto';
+export type ScrollConfig = {
+    index: number;
+    align?: ScrollAlign;
+    offset?: number;
+} | {
+    key: Key;
+    align?: ScrollAlign;
+    offset?: number;
+};
+export type ScrollTo = (arg: number | ScrollConfig) => void;
+export type ListRef = {
+    scrollTo: ScrollTo;
+};
+export interface ListProps<T = any> extends Omit<React.AllHTMLAttributes<any>, 'data' | 'children'> {
+    prefixCls?: string;
+    children: RenderFunc<T>;
+    data: T[];
+    height?: number;
+    itemHeight?: number;
+    style?: React.CSSProperties;
+    fullHeight?: boolean;
+    itemKey: Key | ((item: T) => Key);
+    component?: string | FC<any> | ComponentClass<any>;
+    virtual?: boolean;
+    onScroll?: React.UIEventHandler<HTMLElement>;
+    onVisibleChange?: (visibleList: T[], fullList: T[]) => void;
+}
+export declare function RawList<T>(props: ListProps<T>, ref: Ref<ListRef>): React.JSX.Element;
+declare const List: React.ForwardRefExoticComponent<ListProps<any> & React.RefAttributes<ListRef>>;
+export default List;

package/dist/VirtualList/VirtualList.js

@@ -0,0 +1,280 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/VirtualList/VirtualList.tsx
+var VirtualList_exports = {};
+__export(VirtualList_exports, {
+  RawList: () => RawList,
+  default: () => VirtualList_default
+});
+module.exports = __toCommonJS(VirtualList_exports);
+var import_classnames = __toESM(require("classnames"));
+var import_react = __toESM(require("react"));
+var import_Filler = __toESM(require("./Filler"));
+var import_ScrollBar = __toESM(require("./ScrollBar"));
+var import_useChildren = __toESM(require("./hooks/useChildren"));
+var import_useDiffItem = __toESM(require("./hooks/useDiffItem"));
+var import_useFrameWheel = __toESM(require("./hooks/useFrameWheel"));
+var import_useHeights = __toESM(require("./hooks/useHeights"));
+var import_useLayoutEffect = __toESM(require("./hooks/useLayoutEffect"));
+var import_useMobileTouchMove = __toESM(require("./hooks/useMobileTouchMove"));
+var import_useOriginScroll = __toESM(require("./hooks/useOriginScroll"));
+var import_useScrollTo = __toESM(require("./hooks/useScrollTo"));
+var EMPTY_DATA = [];
+var ScrollStyle = {
+  overflowY: "auto",
+  overflowAnchor: "none"
+};
+function RawList(props, ref) {
+  const {
+    prefixCls = "rc-virtual-list",
+    className,
+    height,
+    itemHeight,
+    fullHeight = true,
+    style,
+    data,
+    children,
+    itemKey,
+    virtual,
+    component: Component = "div",
+    onScroll,
+    onVisibleChange,
+    ...restProps
+  } = props;
+  const useVirtual = !!(virtual !== false && height && itemHeight);
+  const inVirtual = useVirtual && data && itemHeight * data.length > height;
+  const [scrollTop, setScrollTop] = (0, import_react.useState)(0);
+  const [scrollMoving, setScrollMoving] = (0, import_react.useState)(false);
+  const mergedClassName = (0, import_classnames.default)(prefixCls, className);
+  const mergedData = data || EMPTY_DATA;
+  const componentRef = (0, import_react.useRef)();
+  const fillerInnerRef = (0, import_react.useRef)();
+  const scrollBarRef = (0, import_react.useRef)();
+  const getKey = (0, import_react.useCallback)(
+    (item) => {
+      if (typeof itemKey === "function") {
+        return itemKey(item);
+      }
+      return item == null ? void 0 : item[itemKey];
+    },
+    [itemKey]
+  );
+  const sharedConfig = {
+    getKey
+  };
+  function syncScrollTop(newTop) {
+    setScrollTop((origin) => {
+      let value;
+      if (typeof newTop === "function") {
+        value = newTop(origin);
+      } else {
+        value = newTop;
+      }
+      const alignedTop = keepInRange(value);
+      componentRef.current.scrollTop = alignedTop;
+      return alignedTop;
+    });
+  }
+  const rangeRef = (0, import_react.useRef)({ start: 0, end: mergedData.length });
+  const diffItemRef = (0, import_react.useRef)();
+  const [diffItem] = (0, import_useDiffItem.default)(mergedData, getKey);
+  diffItemRef.current = diffItem;
+  const [setInstanceRef, collectHeight, heights, heightUpdatedMark] = (0, import_useHeights.default)(getKey, null, null);
+  const { scrollHeight, start, end, offset } = (0, import_react.useMemo)(() => {
+    var _a;
+    if (!useVirtual) {
+      return {
+        scrollHeight: void 0,
+        start: 0,
+        end: mergedData.length - 1,
+        offset: void 0
+      };
+    }
+    if (!inVirtual) {
+      return {
+        scrollHeight: ((_a = fillerInnerRef.current) == null ? void 0 : _a.offsetHeight) || 0,
+        start: 0,
+        end: mergedData.length - 1,
+        offset: void 0
+      };
+    }
+    let itemTop = 0;
+    let startIndex;
+    let startOffset;
+    let endIndex;
+    const dataLen = mergedData.length;
+    for (let i = 0; i < dataLen; i += 1) {
+      const item = mergedData[i];
+      const key = getKey(item);
+      const cacheHeight = heights.get(key);
+      const currentItemBottom = itemTop + (cacheHeight === void 0 ? itemHeight : cacheHeight);
+      if (currentItemBottom >= scrollTop && startIndex === void 0) {
+        startIndex = i;
+        startOffset = itemTop;
+      }
+      if (currentItemBottom > scrollTop + height && endIndex === void 0) {
+        endIndex = i;
+      }
+      itemTop = currentItemBottom;
+    }
+    if (startIndex === void 0) {
+      startIndex = 0;
+      startOffset = 0;
+    }
+    if (endIndex === void 0) {
+      endIndex = mergedData.length - 1;
+    }
+    endIndex = Math.min(endIndex + 1, mergedData.length);
+    return {
+      scrollHeight: itemTop,
+      start: startIndex,
+      end: endIndex,
+      offset: startOffset
+    };
+  }, [inVirtual, useVirtual, scrollTop, mergedData, heightUpdatedMark, height]);
+  rangeRef.current.start = start;
+  rangeRef.current.end = end;
+  const maxScrollHeight = scrollHeight - height;
+  const maxScrollHeightRef = (0, import_react.useRef)(maxScrollHeight);
+  maxScrollHeightRef.current = maxScrollHeight;
+  function keepInRange(newScrollTop) {
+    let newTop = newScrollTop;
+    if (!Number.isNaN(maxScrollHeightRef.current)) {
+      newTop = Math.min(newTop, maxScrollHeightRef.current);
+    }
+    newTop = Math.max(newTop, 0);
+    return newTop;
+  }
+  const isScrollAtTop = scrollTop <= 0;
+  const isScrollAtBottom = scrollTop >= maxScrollHeight;
+  const originScroll = (0, import_useOriginScroll.default)(isScrollAtTop, isScrollAtBottom);
+  function onScrollBar(newScrollTop) {
+    const newTop = newScrollTop;
+    syncScrollTop(newTop);
+  }
+  function onFallbackScroll(e) {
+    const { scrollTop: newScrollTop } = e.currentTarget;
+    if (newScrollTop !== scrollTop) {
+      syncScrollTop(newScrollTop);
+    }
+    onScroll == null ? void 0 : onScroll.call(this, e);
+  }
+  const [onRawWheel, onFireFoxScroll] = (0, import_useFrameWheel.default)(useVirtual, isScrollAtTop, isScrollAtBottom, (offsetY) => {
+    syncScrollTop((top) => {
+      const newTop = top + offsetY;
+      return newTop;
+    });
+  });
+  (0, import_useMobileTouchMove.default)(useVirtual, componentRef, (deltaY, smoothOffset) => {
+    if (originScroll(deltaY, smoothOffset)) {
+      return false;
+    }
+    onRawWheel({ preventDefault() {
+    }, deltaY });
+    return true;
+  });
+  (0, import_useLayoutEffect.default)(() => {
+    function onMozMousePixelScroll(e) {
+      if (useVirtual) {
+        e.preventDefault();
+      }
+    }
+    componentRef.current.addEventListener("wheel", onRawWheel);
+    componentRef.current.addEventListener("DOMMouseScroll", onFireFoxScroll);
+    componentRef.current.addEventListener("MozMousePixelScroll", onMozMousePixelScroll);
+    return () => {
+      if (componentRef.current) {
+        componentRef.current.removeEventListener("wheel", onRawWheel);
+        componentRef.current.removeEventListener("DOMMouseScroll", onFireFoxScroll);
+        componentRef.current.removeEventListener("MozMousePixelScroll", onMozMousePixelScroll);
+      }
+    };
+  }, [useVirtual]);
+  const scrollTo = (0, import_useScrollTo.default)(componentRef, mergedData, heights, itemHeight, getKey, collectHeight, syncScrollTop, () => {
+    var _a;
+    (_a = scrollBarRef.current) == null ? void 0 : _a.delayHidden();
+  });
+  (0, import_react.useImperativeHandle)(ref, () => ({
+    scrollTo
+  }));
+  (0, import_useLayoutEffect.default)(() => {
+    if (onVisibleChange) {
+      const renderList = mergedData.slice(start, end + 1);
+      onVisibleChange(renderList, mergedData);
+    }
+  }, [start, end, mergedData]);
+  const listChildren = (0, import_useChildren.default)(mergedData, start, end, setInstanceRef, children, sharedConfig);
+  let componentStyle = null;
+  if (height) {
+    componentStyle = { [fullHeight ? "height" : "maxHeight"]: height, ...ScrollStyle };
+    if (useVirtual) {
+      componentStyle.overflowY = "hidden";
+      if (scrollMoving) {
+        componentStyle.pointerEvents = "none";
+      }
+    }
+  }
+  return /* @__PURE__ */ import_react.default.createElement(
+    "div",
+    {
+      style: {
+        ...style,
+        position: "relative"
+      },
+      className: mergedClassName,
+      ...restProps
+    },
+    /* @__PURE__ */ import_react.default.createElement(Component, { className: `${prefixCls}-holder`, style: componentStyle, ref: componentRef, onScroll: onFallbackScroll }, /* @__PURE__ */ import_react.default.createElement(import_Filler.default, { prefixCls, height: scrollHeight, offset, onInnerResize: collectHeight, ref: fillerInnerRef }, listChildren)),
+    useVirtual && /* @__PURE__ */ import_react.default.createElement(
+      import_ScrollBar.default,
+      {
+        ref: scrollBarRef,
+        prefixCls,
+        scrollTop,
+        height,
+        scrollHeight,
+        count: mergedData.length,
+        onScroll: onScrollBar,
+        onStartMove: () => {
+          setScrollMoving(true);
+        },
+        onStopMove: () => {
+          setScrollMoving(false);
+        }
+      }
+    )
+  );
+}
+var List = (0, import_react.forwardRef)(RawList);
+List.displayName = "List";
+var VirtualList_default = List;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RawList
+});

package/dist/VirtualList/hooks/useChildren.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+import type { RenderFunc, SharedConfig } from '../interface';
+export default function useChildren<T>(list: T[], startIndex: number, endIndex: number, setNodeRef: (item: T, element: HTMLElement) => void, renderFunc: RenderFunc<T>, { getKey }: SharedConfig<T>): React.JSX.Element[];

package/dist/VirtualList/hooks/useChildren.js

@@ -0,0 +1,46 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/VirtualList/hooks/useChildren.tsx
+var useChildren_exports = {};
+__export(useChildren_exports, {
+  default: () => useChildren
+});
+module.exports = __toCommonJS(useChildren_exports);
+var import_react = __toESM(require("react"));
+var import_Item = require("../Item");
+function useChildren(list, startIndex, endIndex, setNodeRef, renderFunc, { getKey }) {
+  return list.slice(startIndex, endIndex + 1).map((item, index) => {
+    const eleIndex = startIndex + index;
+    const node = renderFunc(item, eleIndex, {
+      // style: status === 'MEASURE_START' ? { visibility: 'hidden' } : {},
+    });
+    const key = getKey(item);
+    return /* @__PURE__ */ import_react.default.createElement(import_Item.Item, { key, setRef: (ele) => setNodeRef(item, ele) }, node);
+  });
+}

package/dist/VirtualList/hooks/useDiffItem.d.ts

@@ -0,0 +1,2 @@
+import type { GetKey } from '../interface';
+export default function useDiffItem<T>(data: T[], getKey: GetKey<T>, onDiff?: (diffIndex: number) => void): [T];