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

package/dist/VirtualList/hooks/useDiffItem.js

@@ -0,0 +1,39 @@
+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/hooks/useDiffItem.ts
+var useDiffItem_exports = {};
+__export(useDiffItem_exports, {
+  default: () => useDiffItem
+});
+module.exports = __toCommonJS(useDiffItem_exports);
+var import_react = require("react");
+var import_algorithmUtil = require("../utils/algorithmUtil");
+function useDiffItem(data, getKey, onDiff) {
+  const [prevData, setPrevData] = (0, import_react.useState)(data);
+  const [diffItem, setDiffItem] = (0, import_react.useState)(null);
+  (0, import_react.useEffect)(() => {
+    const diff = (0, import_algorithmUtil.findListDiffIndex)(prevData || [], data || [], getKey);
+    if ((diff == null ? void 0 : diff.index) !== void 0) {
+      onDiff == null ? void 0 : onDiff(diff.index);
+      setDiffItem(data[diff.index]);
+    }
+    setPrevData(data);
+  }, [data]);
+  return [diffItem];
+}

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

@@ -0,0 +1,6 @@
+interface FireFoxDOMMouseScrollEvent {
+    detail: number;
+    preventDefault: Function;
+}
+export default function useFrameWheel(inVirtual: boolean, isScrollAtTop: boolean, isScrollAtBottom: boolean, onWheelDelta: (offset: number) => void): [(e: WheelEvent) => void, (e: FireFoxDOMMouseScrollEvent) => void];
+export {};

package/dist/VirtualList/hooks/useFrameWheel.js

@@ -0,0 +1,72 @@
+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/useFrameWheel.ts
+var useFrameWheel_exports = {};
+__export(useFrameWheel_exports, {
+  default: () => useFrameWheel
+});
+module.exports = __toCommonJS(useFrameWheel_exports);
+var import_react = require("react");
+var import_isFirefox = __toESM(require("../utils/isFirefox"));
+var import_raf = __toESM(require("../utils/raf"));
+var import_useOriginScroll = __toESM(require("./useOriginScroll"));
+function useFrameWheel(inVirtual, isScrollAtTop, isScrollAtBottom, onWheelDelta) {
+  const offsetRef = (0, import_react.useRef)(0);
+  const nextFrameRef = (0, import_react.useRef)(null);
+  const wheelValueRef = (0, import_react.useRef)(null);
+  const isMouseScrollRef = (0, import_react.useRef)(false);
+  const originScroll = (0, import_useOriginScroll.default)(isScrollAtTop, isScrollAtBottom);
+  function onWheel(event) {
+    if (!inVirtual) {
+      return;
+    }
+    import_raf.default.cancel(nextFrameRef.current);
+    const { deltaY } = event;
+    offsetRef.current += deltaY;
+    wheelValueRef.current = deltaY;
+    if (originScroll(deltaY)) {
+      return;
+    }
+    if (!import_isFirefox.default) {
+      event.preventDefault();
+    }
+    nextFrameRef.current = (0, import_raf.default)(() => {
+      const patchMultiple = isMouseScrollRef.current ? 10 : 1;
+      onWheelDelta(offsetRef.current * patchMultiple);
+      offsetRef.current = 0;
+    });
+  }
+  function onFireFoxScroll(event) {
+    if (!inVirtual) {
+      return;
+    }
+    isMouseScrollRef.current = event.detail === wheelValueRef.current;
+  }
+  return [onWheel, onFireFoxScroll];
+}

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

@@ -0,0 +1,3 @@
+import type { GetKey } from '../interface';
+import CacheMap from '../utils/CacheMap';
+export default function useHeights<T>(getKey: GetKey<T>, onItemAdd?: (item: T) => void, onItemRemove?: (item: T) => void): [(item: T, instance: HTMLElement) => void, () => void, CacheMap, number];

package/dist/VirtualList/hooks/useHeights.js

@@ -0,0 +1,83 @@
+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/useHeights.tsx
+var useHeights_exports = {};
+__export(useHeights_exports, {
+  default: () => useHeights
+});
+module.exports = __toCommonJS(useHeights_exports);
+var import_react = require("react");
+var import_CacheMap = __toESM(require("../utils/CacheMap"));
+var import_findDOMNode = __toESM(require("../utils/findDOMNode"));
+var import_raf = __toESM(require("../utils/raf"));
+function useHeights(getKey, onItemAdd, onItemRemove) {
+  const [updatedMark, setUpdatedMark] = (0, import_react.useState)(0);
+  const instanceRef = (0, import_react.useRef)(/* @__PURE__ */ new Map());
+  const heightsRef = (0, import_react.useRef)(new import_CacheMap.default());
+  const collectRafRef = (0, import_react.useRef)();
+  function cancelRaf() {
+    import_raf.default.cancel(collectRafRef.current);
+  }
+  function collectHeight() {
+    cancelRaf();
+    collectRafRef.current = (0, import_raf.default)(() => {
+      instanceRef.current.forEach((element, key) => {
+        if (element && element.offsetParent) {
+          const htmlElement = (0, import_findDOMNode.default)(element);
+          const { offsetHeight } = htmlElement;
+          if (heightsRef.current.get(key) !== offsetHeight) {
+            heightsRef.current.set(key, htmlElement.offsetHeight);
+          }
+        }
+      });
+      setUpdatedMark((c) => c + 1);
+    });
+  }
+  function setInstanceRef(item, instance) {
+    const key = getKey(item);
+    const origin = instanceRef.current.get(key);
+    if (instance) {
+      instanceRef.current.set(key, instance);
+      collectHeight();
+    } else {
+      instanceRef.current.delete(key);
+    }
+    if (!origin !== !instance) {
+      if (instance) {
+        onItemAdd == null ? void 0 : onItemAdd(item);
+      } else {
+        onItemRemove == null ? void 0 : onItemRemove(item);
+      }
+    }
+  }
+  (0, import_react.useEffect)(() => {
+    return cancelRaf;
+  }, []);
+  return [setInstanceRef, collectHeight, heightsRef.current, updatedMark];
+}

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

@@ -0,0 +1,3 @@
+import { useEffect } from 'react';
+declare const useLayoutEffect: typeof useEffect;
+export default useLayoutEffect;

package/dist/VirtualList/hooks/useLayoutEffect.js

@@ -0,0 +1,30 @@
+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/hooks/useLayoutEffect.ts
+var useLayoutEffect_exports = {};
+__export(useLayoutEffect_exports, {
+  default: () => useLayoutEffect_default
+});
+module.exports = __toCommonJS(useLayoutEffect_exports);
+var import_react = require("react");
+function canUseDom() {
+  return !!(typeof window !== "undefined" && window.document && window.document.createElement);
+}
+var useLayoutEffect = canUseDom() ? import_react.useLayoutEffect : import_react.useEffect;
+var useLayoutEffect_default = useLayoutEffect;

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

@@ -0,0 +1,2 @@
+import { RefObject } from 'react';
+export default function useMobileTouchMove(inVirtual: boolean, listRef: RefObject<HTMLDivElement>, callback: (offsetY: number, smoothOffset?: boolean) => boolean): void;

package/dist/VirtualList/hooks/useMobileTouchMove.js

@@ -0,0 +1,92 @@
+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/useMobileTouchMove.ts
+var useMobileTouchMove_exports = {};
+__export(useMobileTouchMove_exports, {
+  default: () => useMobileTouchMove
+});
+module.exports = __toCommonJS(useMobileTouchMove_exports);
+var import_react = require("react");
+var import_useLayoutEffect = __toESM(require("./useLayoutEffect"));
+var SMOOTH_PTG = 14 / 15;
+function useMobileTouchMove(inVirtual, listRef, callback) {
+  const touchedRef = (0, import_react.useRef)(false);
+  const touchYRef = (0, import_react.useRef)(0);
+  const elementRef = (0, import_react.useRef)(null);
+  const intervalRef = (0, import_react.useRef)(null);
+  let cleanUpEvents;
+  const onTouchMove = (e) => {
+    if (touchedRef.current) {
+      const currentY = Math.ceil(e.touches[0].pageY);
+      let offsetY = touchYRef.current - currentY;
+      touchYRef.current = currentY;
+      if (callback(offsetY)) {
+        e.preventDefault();
+      }
+      clearInterval(intervalRef.current);
+      intervalRef.current = setInterval(() => {
+        offsetY *= SMOOTH_PTG;
+        if (!callback(offsetY, true) || Math.abs(offsetY) <= 0.1) {
+          clearInterval(intervalRef.current);
+        }
+      }, 16);
+    }
+  };
+  const onTouchEnd = () => {
+    touchedRef.current = false;
+    cleanUpEvents();
+  };
+  const onTouchStart = (e) => {
+    cleanUpEvents();
+    if (e.touches.length === 1 && !touchedRef.current) {
+      touchedRef.current = true;
+      touchYRef.current = Math.ceil(e.touches[0].pageY);
+      elementRef.current = e.target;
+      elementRef.current.addEventListener("touchmove", onTouchMove);
+      elementRef.current.addEventListener("touchend", onTouchEnd);
+    }
+  };
+  cleanUpEvents = () => {
+    if (elementRef.current) {
+      elementRef.current.removeEventListener("touchmove", onTouchMove);
+      elementRef.current.removeEventListener("touchend", onTouchEnd);
+    }
+  };
+  (0, import_useLayoutEffect.default)(() => {
+    if (inVirtual) {
+      listRef.current.addEventListener("touchstart", onTouchStart);
+    }
+    return () => {
+      var _a;
+      (_a = listRef.current) == null ? void 0 : _a.removeEventListener("touchstart", onTouchStart);
+      cleanUpEvents();
+      clearInterval(intervalRef.current);
+    };
+  }, [inVirtual]);
+}

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

@@ -0,0 +1,2 @@
+declare const _default: (isScrollAtTop: boolean, isScrollAtBottom: boolean) => (deltaY: number, smoothOffset?: boolean) => boolean;
+export default _default;

package/dist/VirtualList/hooks/useOriginScroll.js

@@ -0,0 +1,56 @@
+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/hooks/useOriginScroll.ts
+var useOriginScroll_exports = {};
+__export(useOriginScroll_exports, {
+  default: () => useOriginScroll_default
+});
+module.exports = __toCommonJS(useOriginScroll_exports);
+var import_react = require("react");
+var useOriginScroll_default = (isScrollAtTop, isScrollAtBottom) => {
+  const lockRef = (0, import_react.useRef)(false);
+  const lockTimeoutRef = (0, import_react.useRef)(null);
+  function lockScroll() {
+    clearTimeout(lockTimeoutRef.current);
+    lockRef.current = true;
+    lockTimeoutRef.current = setTimeout(() => {
+      lockRef.current = false;
+    }, 50);
+  }
+  const scrollPingRef = (0, import_react.useRef)({
+    top: isScrollAtTop,
+    bottom: isScrollAtBottom
+  });
+  scrollPingRef.current.top = isScrollAtTop;
+  scrollPingRef.current.bottom = isScrollAtBottom;
+  return (deltaY, smoothOffset = false) => {
+    const originScroll = (
+      // Pass origin wheel when on the top
+      deltaY < 0 && scrollPingRef.current.top || // Pass origin wheel when on the bottom
+      deltaY > 0 && scrollPingRef.current.bottom
+    );
+    if (smoothOffset && originScroll) {
+      clearTimeout(lockTimeoutRef.current);
+      lockRef.current = false;
+    } else if (!originScroll || lockRef.current) {
+      lockScroll();
+    }
+    return !lockRef.current && originScroll;
+  };
+};

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

@@ -0,0 +1,5 @@
+import { RefObject } from 'react';
+import type { ScrollTo } from '../VirtualList';
+import type { GetKey } from '../interface';
+import type CacheMap from '../utils/CacheMap';
+export default function useScrollTo<T>(containerRef: RefObject<HTMLDivElement>, data: T[], heights: CacheMap, itemHeight: number, getKey: GetKey<T>, collectHeight: () => void, syncScrollTop: (newTop: number) => void, triggerFlash: () => void): ScrollTo;

package/dist/VirtualList/hooks/useScrollTo.js

@@ -0,0 +1,111 @@
+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/useScrollTo.tsx
+var useScrollTo_exports = {};
+__export(useScrollTo_exports, {
+  default: () => useScrollTo
+});
+module.exports = __toCommonJS(useScrollTo_exports);
+var import_react = require("react");
+var import_raf = __toESM(require("../utils/raf"));
+function useScrollTo(containerRef, data, heights, itemHeight, getKey, collectHeight, syncScrollTop, triggerFlash) {
+  const scrollRef = (0, import_react.useRef)();
+  return (arg) => {
+    if (arg === null || arg === void 0) {
+      triggerFlash();
+      return;
+    }
+    import_raf.default.cancel(scrollRef.current);
+    if (typeof arg === "number") {
+      syncScrollTop(arg);
+    } else if (arg && typeof arg === "object") {
+      let index;
+      const { align } = arg;
+      if ("index" in arg) {
+        ({ index } = arg);
+      } else {
+        index = data.findIndex((item) => getKey(item) === arg.key);
+      }
+      const { offset = 0 } = arg;
+      const syncScroll = (times, targetAlign) => {
+        if (times < 0 || !containerRef.current) {
+          return;
+        }
+        const height = containerRef.current.clientHeight;
+        let needCollectHeight = false;
+        let newTargetAlign = targetAlign;
+        if (height) {
+          const mergedAlign = targetAlign || align;
+          let stackTop = 0;
+          let itemTop = 0;
+          let itemBottom = 0;
+          const maxLen = Math.min(data.length, index);
+          for (let i = 0; i <= maxLen; i += 1) {
+            const key = getKey(data[i]);
+            itemTop = stackTop;
+            const cacheHeight = heights.get(key);
+            itemBottom = itemTop + (cacheHeight === void 0 ? itemHeight : cacheHeight);
+            stackTop = itemBottom;
+            if (i === index && cacheHeight === void 0) {
+              needCollectHeight = true;
+            }
+          }
+          let targetTop = null;
+          switch (mergedAlign) {
+            case "top":
+              targetTop = itemTop - offset;
+              break;
+            case "bottom":
+              targetTop = itemBottom - height + offset;
+              break;
+            default: {
+              const { scrollTop } = containerRef.current;
+              const scrollBottom = scrollTop + height;
+              if (itemTop < scrollTop) {
+                newTargetAlign = "top";
+              } else if (itemBottom > scrollBottom) {
+                newTargetAlign = "bottom";
+              }
+            }
+          }
+          if (targetTop !== null && targetTop !== containerRef.current.scrollTop) {
+            syncScrollTop(targetTop);
+          }
+        }
+        scrollRef.current = (0, import_raf.default)(() => {
+          if (needCollectHeight) {
+            collectHeight();
+          }
+          syncScroll(times - 1, newTargetAlign);
+        });
+      };
+      syncScroll(3);
+    }
+  };
+}

package/dist/VirtualList/index.d.ts

@@ -0,0 +1,2 @@
+export { default as VirtualList } from './VirtualList';
+export type { ListProps, ListRef, ScrollTo } from './VirtualList';

package/dist/VirtualList/index.js

@@ -0,0 +1,39 @@
+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/index.ts
+var VirtualList_exports = {};
+__export(VirtualList_exports, {
+  VirtualList: () => import_VirtualList.default
+});
+module.exports = __toCommonJS(VirtualList_exports);
+var import_VirtualList = __toESM(require("./VirtualList"));
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  VirtualList
+});

package/dist/VirtualList/interface.d.ts

@@ -0,0 +1,8 @@
+import React, { Key } from 'react';
+export type RenderFunc<T> = (item: T, index: number, props: {
+    style?: React.CSSProperties;
+}) => React.ReactElement;
+export interface SharedConfig<T> {
+    getKey: (item: T) => Key;
+}
+export type GetKey<T> = (item: T) => Key;

package/dist/VirtualList/interface.js

@@ -0,0 +1,17 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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/interface.ts
+var interface_exports = {};
+module.exports = __toCommonJS(interface_exports);

package/dist/VirtualList/mock.d.ts

@@ -0,0 +1,6 @@
+import React, { Ref } from 'react';
+import { ListProps, ListRef } from './VirtualList';
+declare const List: <Item = any>(props: ListProps<Item> & {
+    ref?: Ref<ListRef>;
+}) => React.ReactElement;
+export default List;

package/dist/VirtualList/mock.js

@@ -0,0 +1,29 @@
+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/mock.tsx
+var mock_exports = {};
+__export(mock_exports, {
+  default: () => mock_default
+});
+module.exports = __toCommonJS(mock_exports);
+var import_react = require("react");
+var import_VirtualList = require("./VirtualList");
+var List = (0, import_react.forwardRef)((props, ref) => (0, import_VirtualList.RawList)({ ...props, virtual: false }, ref));
+List.displayName = "List";
+var mock_default = List;

package/dist/VirtualList/utils/CacheMap.d.ts

@@ -0,0 +1,7 @@
+declare class CacheMap {
+    maps: Record<string, number>;
+    constructor();
+    set(key: string | number, value: number): void;
+    get(key: string | number): number;
+}
+export default CacheMap;