@1money/component-ui 0.0.1

package/es/components/VirtualList/hooks/useChildren.js

@@ -0,0 +1,25 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import * as React from 'react';
+import { Item } from '../Item';
+export default function useChildren(list, startIndex, endIndex, scrollWidth, offsetX, setNodeRef, renderFunc, _ref) {
+  var getKey = _ref.getKey;
+  return React.useMemo(function () {
+    return list.slice(startIndex, endIndex + 1).map(function (item, index) {
+      var eleIndex = startIndex + index;
+      var node = renderFunc(item, eleIndex, {
+        style: {
+          width: scrollWidth
+        },
+        offsetX: offsetX
+      });
+      var key = getKey(item);
+      return _jsx(Item, {
+        setRef: function setRef(ele) {
+          return setNodeRef(item, ele);
+        },
+        children: node
+      }, key);
+    });
+  }, [list, startIndex, endIndex, scrollWidth, offsetX, setNodeRef, renderFunc, getKey]);
+}
+//# sourceMappingURL=data:application/json;charset=utf8;base64,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

package/es/components/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 | null];

package/es/components/VirtualList/hooks/useDiffItem.js

@@ -0,0 +1,16 @@
+import * as React from 'react';
+import { findListDiffIndex } from '../utils/algorithmUtil';
+export default function useDiffItem(data, getKey, onDiff) {
+  var prevDataRef = React.useRef(data);
+  var diffItemRef = React.useRef(null);
+  if (prevDataRef.current !== data) {
+    var diff = findListDiffIndex(prevDataRef.current || [], data || [], getKey);
+    if ((diff === null || diff === void 0 ? void 0 : diff.index) !== undefined) {
+      onDiff === null || onDiff === void 0 ? void 0 : onDiff(diff.index);
+      diffItemRef.current = data[diff.index];
+    }
+    prevDataRef.current = data;
+  }
+  return [diffItemRef.current];
+}
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImNvbXBvbmVudHMvVmlydHVhbExpc3Qvc3JjL2NvbXBvbmVudHMvVmlydHVhbExpc3QvaG9va3MvdXNlRGlmZkl0ZW0udHMiXSwibmFtZXMiOlsiUmVhY3QiLCJmaW5kTGlzdERpZmZJbmRleCIsInVzZURpZmZJdGVtIiwiZGF0YSIsImdldEtleSIsIm9uRGlmZiIsInByZXZEYXRhUmVmIiwidXNlUmVmIiwiZGlmZkl0ZW1SZWYiLCJjdXJyZW50IiwiZGlmZiIsImluZGV4IiwidW5kZWZpbmVkIl0sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUtBLEtBQUssTUFBTSxPQUFPO0FBQzlCLFNBQVNDLGlCQUFpQixRQUFRLHdCQUF3QjtBQUcxRCxlQUFjLFNBQVVDLFdBQVdBLENBQ2pDQyxJQUFTLEVBQ1RDLE1BQWlCLEVBQ2pCQyxNQUFvQyxFQUFBO0VBRXBDLElBQU1DLFdBQVcsR0FBR04sS0FBSyxDQUFDTyxNQUFNLENBQUNKLElBQUksQ0FBQztFQUN0QyxJQUFNSyxXQUFXLEdBQUdSLEtBQUssQ0FBQ08sTUFBTSxDQUFXLElBQUksQ0FBQztFQUVoRCxJQUFJRCxXQUFXLENBQUNHLE9BQU8sS0FBS04sSUFBSSxFQUFFO0lBQ2hDLElBQU1PLElBQUksR0FBR1QsaUJBQWlCLENBQUNLLFdBQVcsQ0FBQ0csT0FBTyxJQUFJLEVBQUUsRUFBRU4sSUFBSSxJQUFJLEVBQUUsRUFBRUMsTUFBTSxDQUFDO0lBQzdFLElBQUksQ0FBQU0sSUFBSSxLQUFBLElBQUEsSUFBSkEsSUFBSSxLQUFBLEtBQUEsQ0FBQSxHQUFBLEtBQUEsQ0FBQSxHQUFKQSxJQUFJLENBQUVDLEtBQUssTUFBS0MsU0FBUyxFQUFFO01BQzdCUCxNQUFNLEtBQUEsSUFBQSxJQUFOQSxNQUFNLEtBQUEsS0FBQSxDQUFBLEdBQUEsS0FBQSxDQUFBLEdBQU5BLE1BQU0sQ0FBR0ssSUFBSSxDQUFDQyxLQUFLLENBQUM7TUFDcEJILFdBQVcsQ0FBQ0MsT0FBTyxHQUFHTixJQUFJLENBQUNPLElBQUksQ0FBQ0MsS0FBSyxDQUFDO0lBQ3hDO0lBQ0FMLFdBQVcsQ0FBQ0csT0FBTyxHQUFHTixJQUFJO0VBQzVCO0VBRUEsT0FBTyxDQUFDSyxXQUFXLENBQUNDLE9BQU8sQ0FBQztBQUM5QiIsImZpbGUiOiJjb21wb25lbnRzL1ZpcnR1YWxMaXN0L2hvb2tzL3VzZURpZmZJdGVtLmpzIiwic291cmNlc0NvbnRlbnQiOltudWxsXSwic291cmNlUm9vdCI6Ii4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3NyYyJ9

package/es/components/VirtualList/hooks/useFrameWheel.d.ts

@@ -0,0 +1,10 @@
+interface FireFoxDOMMouseScrollEvent {
+    detail: number;
+    preventDefault: VoidFunction;
+}
+export default function useFrameWheel(inVirtual: boolean, isScrollAtTop: boolean, isScrollAtBottom: boolean, isScrollAtLeft: boolean, isScrollAtRight: boolean, horizontalScroll: boolean, 
+/***
+ * Return `true` when you need to prevent default event
+ */
+onWheelDelta: (offset: number, horizontal: boolean) => void): [(e: WheelEvent) => void, (e: FireFoxDOMMouseScrollEvent) => void];
+export {};

package/es/components/VirtualList/hooks/useFrameWheel.js

@@ -0,0 +1,85 @@
+import raf from '../utils/raf';
+import { useRef } from 'react';
+import isFF from '../utils/isFirefox';
+import useOriginScroll from './useOriginScroll';
+export default function useFrameWheel(inVirtual, isScrollAtTop, isScrollAtBottom, isScrollAtLeft, isScrollAtRight, horizontalScroll,
+/***
+ * Return `true` when you need to prevent default event
+ */
+onWheelDelta) {
+  var offsetRef = useRef(0);
+  var nextFrameRef = useRef(null);
+  // Firefox patch
+  var wheelValueRef = useRef(null);
+  var isMouseScrollRef = useRef(false);
+  // Scroll status sync
+  var originScroll = useOriginScroll(isScrollAtTop, isScrollAtBottom, isScrollAtLeft, isScrollAtRight);
+  function onWheelY(e, deltaY) {
+    raf.cancel(nextFrameRef.current);
+    // Do nothing when scroll at the edge, Skip check when is in scroll
+    if (originScroll(false, deltaY)) return;
+    // Skip if nest List has handled this event
+    var event = e;
+    if (!event._virtualHandled) {
+      event._virtualHandled = true;
+    } else {
+      return;
+    }
+    offsetRef.current += deltaY;
+    wheelValueRef.current = deltaY;
+    // Proxy of scroll events
+    if (!isFF) {
+      event.preventDefault();
+    }
+    nextFrameRef.current = raf(function () {
+      // Patch a multiple for Firefox to fix wheel number too small
+      var patchMultiple = isMouseScrollRef.current ? 10 : 1;
+      onWheelDelta(offsetRef.current * patchMultiple, false);
+      offsetRef.current = 0;
+    });
+  }
+  function onWheelX(event, deltaX) {
+    onWheelDelta(deltaX, true);
+    if (!isFF) {
+      event.preventDefault();
+    }
+  }
+  // Check for which direction does wheel do. `sx` means `shift + wheel`
+  var wheelDirectionRef = useRef(null);
+  var wheelDirectionCleanRef = useRef(null);
+  function onWheel(event) {
+    if (!inVirtual) return;
+    // Wait for 2 frame to clean direction
+    raf.cancel(wheelDirectionCleanRef.current);
+    wheelDirectionCleanRef.current = raf(function () {
+      wheelDirectionRef.current = null;
+    }, 2);
+    var deltaX = event.deltaX,
+      deltaY = event.deltaY,
+      shiftKey = event.shiftKey;
+    var mergedDeltaX = deltaX;
+    var mergedDeltaY = deltaY;
+    if (wheelDirectionRef.current === 'sx' || !wheelDirectionRef.current && (shiftKey || false) && deltaY && !deltaX) {
+      mergedDeltaX = deltaY;
+      mergedDeltaY = 0;
+      wheelDirectionRef.current = 'sx';
+    }
+    var absX = Math.abs(mergedDeltaX);
+    var absY = Math.abs(mergedDeltaY);
+    if (wheelDirectionRef.current === null) {
+      wheelDirectionRef.current = horizontalScroll && absX > absY ? 'x' : 'y';
+    }
+    if (wheelDirectionRef.current === 'y') {
+      onWheelY(event, mergedDeltaY);
+    } else {
+      onWheelX(event, mergedDeltaX);
+    }
+  }
+  // A patch for firefox
+  function onFireFoxScroll(event) {
+    if (!inVirtual) return;
+    isMouseScrollRef.current = event.detail === wheelValueRef.current;
+  }
+  return [onWheel, onFireFoxScroll];
+}
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["components/VirtualList/src/components/VirtualList/hooks/useFrameWheel.ts","components/VirtualList/hooks/useFrameWheel.js"],"names":["raf","useRef","isFF","useOriginScroll","useFrameWheel","inVirtual","isScrollAtTop","isScrollAtBottom","isScrollAtLeft","isScrollAtRight","horizontalScroll","onWheelDelta","offsetRef","nextFrameRef","wheelValueRef","isMouseScrollRef","originScroll","onWheelY","e","deltaY","cancel","current","event","_virtualHandled","preventDefault","patchMultiple","onWheelX","deltaX","wheelDirectionRef","wheelDirectionCleanRef","onWheel","shiftKey","mergedDeltaX","mergedDeltaY","absX","Math","abs","absY","onFireFoxScroll","detail"],"mappings":"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","file":"components/VirtualList/hooks/useFrameWheel.js","sourcesContent":[null,"import raf from '../utils/raf';\nimport { useRef } from 'react';\nimport isFF from '../utils/isFirefox';\nimport useOriginScroll from './useOriginScroll';\nexport default function useFrameWheel(inVirtual, isScrollAtTop, isScrollAtBottom, isScrollAtLeft, isScrollAtRight, horizontalScroll, \n/***\n * Return `true` when you need to prevent default event\n */\nonWheelDelta) {\n    const offsetRef = useRef(0);\n    const nextFrameRef = useRef(null);\n    // Firefox patch\n    const wheelValueRef = useRef(null);\n    const isMouseScrollRef = useRef(false);\n    // Scroll status sync\n    const originScroll = useOriginScroll(isScrollAtTop, isScrollAtBottom, isScrollAtLeft, isScrollAtRight);\n    function onWheelY(e, deltaY) {\n        raf.cancel(nextFrameRef.current);\n        // Do nothing when scroll at the edge, Skip check when is in scroll\n        if (originScroll(false, deltaY))\n            return;\n        // Skip if nest List has handled this event\n        const event = e;\n        if (!event._virtualHandled) {\n            event._virtualHandled = true;\n        }\n        else {\n            return;\n        }\n        offsetRef.current += deltaY;\n        wheelValueRef.current = deltaY;\n        // Proxy of scroll events\n        if (!isFF) {\n            event.preventDefault();\n        }\n        nextFrameRef.current = raf(() => {\n            // Patch a multiple for Firefox to fix wheel number too small\n            const patchMultiple = isMouseScrollRef.current ? 10 : 1;\n            onWheelDelta(offsetRef.current * patchMultiple, false);\n            offsetRef.current = 0;\n        });\n    }\n    function onWheelX(event, deltaX) {\n        onWheelDelta(deltaX, true);\n        if (!isFF) {\n            event.preventDefault();\n        }\n    }\n    // Check for which direction does wheel do. `sx` means `shift + wheel`\n    const wheelDirectionRef = useRef(null);\n    const wheelDirectionCleanRef = useRef(null);\n    function onWheel(event) {\n        if (!inVirtual)\n            return;\n        // Wait for 2 frame to clean direction\n        raf.cancel(wheelDirectionCleanRef.current);\n        wheelDirectionCleanRef.current = raf(() => {\n            wheelDirectionRef.current = null;\n        }, 2);\n        const { deltaX, deltaY, shiftKey } = event;\n        let mergedDeltaX = deltaX;\n        let mergedDeltaY = deltaY;\n        if (wheelDirectionRef.current === 'sx' ||\n            (!wheelDirectionRef.current && (shiftKey || false) && deltaY && !deltaX)) {\n            mergedDeltaX = deltaY;\n            mergedDeltaY = 0;\n            wheelDirectionRef.current = 'sx';\n        }\n        const absX = Math.abs(mergedDeltaX);\n        const absY = Math.abs(mergedDeltaY);\n        if (wheelDirectionRef.current === null) {\n            wheelDirectionRef.current = horizontalScroll && absX > absY ? 'x' : 'y';\n        }\n        if (wheelDirectionRef.current === 'y') {\n            onWheelY(event, mergedDeltaY);\n        }\n        else {\n            onWheelX(event, mergedDeltaX);\n        }\n    }\n    // A patch for firefox\n    function onFireFoxScroll(event) {\n        if (!inVirtual)\n            return;\n        isMouseScrollRef.current = event.detail === wheelValueRef.current;\n    }\n    return [onWheel, onFireFoxScroll];\n}"],"sourceRoot":"../../../../../../../../../../src"}

package/es/components/VirtualList/hooks/useGetSize.d.ts

@@ -0,0 +1,7 @@
+import type CacheMap from '../utils/CacheMap';
+import type { GetKey, GetSize } from '../interface';
+/**
+ * Size info need loop query for the `heights` which will has the perf issue.
+ * Let cache result for each render phase.
+ */
+export declare function useGetSize<T>(mergedData: T[], getKey: GetKey<T>, heights: CacheMap, itemHeight: number): GetSize;

package/es/components/VirtualList/hooks/useGetSize.js

@@ -0,0 +1,47 @@
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import * as React from 'react';
+/**
+ * Size info need loop query for the `heights` which will has the perf issue.
+ * Let cache result for each render phase.
+ */
+export function useGetSize(mergedData, getKey, heights, itemHeight) {
+  var _React$useMemo = React.useMemo(function () {
+      return [new Map(), []];
+    }, [mergedData, heights.id, itemHeight]),
+    _React$useMemo2 = _slicedToArray(_React$useMemo, 2),
+    key2Index = _React$useMemo2[0],
+    bottomList = _React$useMemo2[1];
+  var getSize = function getSize(startKey) {
+    var endKey = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : startKey;
+    var _a;
+    // Get from cache first
+    var startIndex = key2Index.get(startKey);
+    var endIndex = key2Index.get(endKey);
+    // Loop to fill the cache
+    if (startIndex === undefined || endIndex === undefined) {
+      var dataLen = mergedData.length;
+      for (var i = bottomList.length; i < dataLen; i += 1) {
+        var item = mergedData[i];
+        var key = getKey(item);
+        key2Index.set(key, i);
+        var cacheHeight = (_a = heights.get(key)) !== null && _a !== void 0 ? _a : itemHeight;
+        bottomList[i] = (bottomList[i - 1] || 0) + cacheHeight;
+        if (key === startKey) {
+          startIndex = i;
+        }
+        if (key === endKey) {
+          endIndex = i;
+        }
+        if (startIndex !== undefined && endIndex !== undefined) {
+          break;
+        }
+      }
+    }
+    return {
+      top: bottomList[startIndex - 1] || 0,
+      bottom: bottomList[endIndex]
+    };
+  };
+  return getSize;
+}
+//# sourceMappingURL=data:application/json;charset=utf8;base64,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

package/es/components/VirtualList/hooks/useHeights.d.ts

@@ -0,0 +1,8 @@
+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): [
+    setInstanceRef: (item: T, instance: HTMLElement) => void,
+    collectHeight: (sync?: boolean) => void,
+    cacheMap: CacheMap,
+    updatedMark: number
+];

package/es/components/VirtualList/hooks/useHeights.js

@@ -0,0 +1,96 @@
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import * as React from 'react';
+import { useEffect, useRef } from 'react';
+import CacheMap from '../utils/CacheMap';
+function parseNumber(value) {
+  var num = parseFloat(value);
+  return isNaN(num) ? 0 : num;
+}
+export default function useHeights(getKey, onItemAdd, onItemRemove) {
+  var _React$useState = React.useState(0),
+    _React$useState2 = _slicedToArray(_React$useState, 2),
+    updatedMark = _React$useState2[0],
+    setUpdatedMark = _React$useState2[1];
+  var instanceRef = useRef(new Map());
+  var heightsRef = useRef(new CacheMap());
+  var marginCacheRef = useRef(new Map());
+  var promiseIdRef = useRef(0);
+  function cancelRaf() {
+    promiseIdRef.current += 1;
+  }
+  function collectHeight() {
+    var sync = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+    cancelRaf();
+    var doCollect = function doCollect() {
+      var changed = false;
+      instanceRef.current.forEach(function (element, key) {
+        if (element && element.offsetParent) {
+          var offsetHeight = element.offsetHeight;
+          // Only call getComputedStyle when offsetHeight changes or no margin cache exists
+          var marginTop;
+          var marginBottom;
+          var cachedMargin = marginCacheRef.current.get(key);
+          var prevHeight = heightsRef.current.get(key);
+          if (!cachedMargin || prevHeight !== undefined && Math.abs(prevHeight - offsetHeight - (cachedMargin.marginTop + cachedMargin.marginBottom)) > 1) {
+            var style = getComputedStyle(element);
+            marginTop = parseNumber(style.marginTop);
+            marginBottom = parseNumber(style.marginBottom);
+            marginCacheRef.current.set(key, {
+              marginTop: marginTop,
+              marginBottom: marginBottom
+            });
+          } else {
+            marginTop = cachedMargin.marginTop;
+            marginBottom = cachedMargin.marginBottom;
+          }
+          var totalHeight = offsetHeight + marginTop + marginBottom;
+          if (heightsRef.current.get(key) !== totalHeight) {
+            heightsRef.current.set(key, totalHeight);
+            changed = true;
+          }
+        }
+      });
+      // Always trigger update mark to tell parent that should re-calculate heights when resized
+      if (changed) {
+        setUpdatedMark(function (c) {
+          return c + 1;
+        });
+      }
+    };
+    if (sync) {
+      doCollect();
+    } else {
+      promiseIdRef.current += 1;
+      var id = promiseIdRef.current;
+      Promise.resolve().then(function () {
+        if (id === promiseIdRef.current) {
+          doCollect();
+        }
+      });
+    }
+  }
+  function setInstanceRef(item, instance) {
+    var key = getKey(item);
+    var origin = instanceRef.current.get(key);
+    if (instance) {
+      instanceRef.current.set(key, instance);
+      collectHeight();
+    } else {
+      instanceRef.current["delete"](key);
+      marginCacheRef.current["delete"](key);
+    }
+    // Instance changed
+    if (!origin !== !instance) {
+      if (instance) {
+        onItemAdd === null || onItemAdd === void 0 ? void 0 : onItemAdd(item);
+      } else {
+        onItemRemove === null || onItemRemove === void 0 ? void 0 : onItemRemove(item);
+      }
+    }
+  }
+  useEffect(function () {
+    return cancelRaf;
+  }, []);
+  return [setInstanceRef, collectHeight, heightsRef.current, updatedMark];
+}
+//# sourceMappingURL=data:application/json;charset=utf8;base64,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

package/es/components/VirtualList/hooks/useMobileTouchMove.d.ts

@@ -0,0 +1,2 @@
+import type * as React from 'react';
+export default function useMobileTouchMove(inVirtual: boolean, listRef: React.RefObject<HTMLDivElement | null>, callback: (isHorizontal: boolean, offset: number, smoothOffset: boolean, e?: TouchEvent) => boolean): void;

package/es/components/VirtualList/hooks/useMobileTouchMove.js

@@ -0,0 +1,85 @@
+import { useLayoutEffect } from '@1money/hooks';
+import { useRef } from 'react';
+var SMOOTH_PTG = 14 / 15;
+export default function useMobileTouchMove(inVirtual, listRef, callback) {
+  var touchedRef = useRef(false);
+  var touchXRef = useRef(0);
+  var touchYRef = useRef(0);
+  var elementRef = useRef(null);
+  // Smooth scroll
+  var intervalRef = useRef(null);
+  var cleanUpEvents;
+  var onTouchMove = function onTouchMove(e) {
+    if (touchedRef.current) {
+      var currentX = Math.ceil(e.touches[0].pageX);
+      var currentY = Math.ceil(e.touches[0].pageY);
+      var offsetX = touchXRef.current - currentX;
+      var offsetY = touchYRef.current - currentY;
+      var isHorizontal = Math.abs(offsetX) > Math.abs(offsetY);
+      if (isHorizontal) {
+        touchXRef.current = currentX;
+      } else {
+        touchYRef.current = currentY;
+      }
+      var scrollHandled = callback(isHorizontal, isHorizontal ? offsetX : offsetY, false, e);
+      if (scrollHandled) {
+        e.preventDefault();
+      }
+      // Smooth interval
+      clearInterval(intervalRef.current);
+      if (scrollHandled) {
+        intervalRef.current = setInterval(function () {
+          if (isHorizontal) {
+            offsetX *= SMOOTH_PTG;
+          } else {
+            offsetY *= SMOOTH_PTG;
+          }
+          var offset = Math.floor(isHorizontal ? offsetX : offsetY);
+          if (!callback(isHorizontal, offset, true) || Math.abs(offset) <= 0.1) {
+            clearInterval(intervalRef.current);
+          }
+        }, 16);
+      }
+    }
+  };
+  var onTouchEnd = function onTouchEnd() {
+    touchedRef.current = false;
+    cleanUpEvents();
+  };
+  var onTouchStart = function onTouchStart(e) {
+    cleanUpEvents();
+    if (e.touches.length === 1 && !touchedRef.current) {
+      touchedRef.current = true;
+      touchXRef.current = Math.ceil(e.touches[0].pageX);
+      touchYRef.current = Math.ceil(e.touches[0].pageY);
+      elementRef.current = e.target;
+      elementRef.current.addEventListener('touchmove', onTouchMove, {
+        passive: false
+      });
+      elementRef.current.addEventListener('touchend', onTouchEnd, {
+        passive: true
+      });
+    }
+  };
+  cleanUpEvents = function cleanUpEvents() {
+    if (elementRef.current) {
+      elementRef.current.removeEventListener('touchmove', onTouchMove);
+      elementRef.current.removeEventListener('touchend', onTouchEnd);
+    }
+  };
+  useLayoutEffect(function () {
+    var _a;
+    if (inVirtual) {
+      (_a = listRef.current) === null || _a === void 0 ? void 0 : _a.addEventListener('touchstart', onTouchStart, {
+        passive: true
+      });
+    }
+    return function () {
+      var _a;
+      (_a = listRef.current) === null || _a === void 0 ? void 0 : _a.removeEventListener('touchstart', onTouchStart);
+      cleanUpEvents();
+      clearInterval(intervalRef.current);
+    };
+  }, [inVirtual]);
+}
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["components/VirtualList/src/components/VirtualList/hooks/useMobileTouchMove.ts","components/VirtualList/hooks/useMobileTouchMove.js"],"names":["useLayoutEffect","useRef","SMOOTH_PTG","useMobileTouchMove","inVirtual","listRef","callback","touchedRef","touchXRef","touchYRef","elementRef","intervalRef","cleanUpEvents","onTouchMove","e","current","currentX","Math","ceil","touches","pageX","currentY","pageY","offsetX","offsetY","isHorizontal","abs","scrollHandled","preventDefault","clearInterval","setInterval","offset","floor","onTouchEnd","onTouchStart","length","target","addEventListener","passive","removeEventListener","_a"],"mappings":"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","file":"components/VirtualList/hooks/useMobileTouchMove.js","sourcesContent":[null,"import { useLayoutEffect } from '@1money/hooks';\nimport { useRef } from 'react';\nconst SMOOTH_PTG = 14 / 15;\nexport default function useMobileTouchMove(inVirtual, listRef, callback) {\n    const touchedRef = useRef(false);\n    const touchXRef = useRef(0);\n    const touchYRef = useRef(0);\n    const elementRef = useRef(null);\n    // Smooth scroll\n    const intervalRef = useRef(null);\n    let cleanUpEvents;\n    const onTouchMove = (e) => {\n        if (touchedRef.current) {\n            const currentX = Math.ceil(e.touches[0].pageX);\n            const currentY = Math.ceil(e.touches[0].pageY);\n            let offsetX = touchXRef.current - currentX;\n            let offsetY = touchYRef.current - currentY;\n            const isHorizontal = Math.abs(offsetX) > Math.abs(offsetY);\n            if (isHorizontal) {\n                touchXRef.current = currentX;\n            }\n            else {\n                touchYRef.current = currentY;\n            }\n            const scrollHandled = callback(isHorizontal, isHorizontal ? offsetX : offsetY, false, e);\n            if (scrollHandled) {\n                e.preventDefault();\n            }\n            // Smooth interval\n            clearInterval(intervalRef.current);\n            if (scrollHandled) {\n                intervalRef.current = setInterval(() => {\n                    if (isHorizontal) {\n                        offsetX *= SMOOTH_PTG;\n                    }\n                    else {\n                        offsetY *= SMOOTH_PTG;\n                    }\n                    const offset = Math.floor(isHorizontal ? offsetX : offsetY);\n                    if (!callback(isHorizontal, offset, true) || Math.abs(offset) <= 0.1) {\n                        clearInterval(intervalRef.current);\n                    }\n                }, 16);\n            }\n        }\n    };\n    const onTouchEnd = () => {\n        touchedRef.current = false;\n        cleanUpEvents();\n    };\n    const onTouchStart = (e) => {\n        cleanUpEvents();\n        if (e.touches.length === 1 && !touchedRef.current) {\n            touchedRef.current = true;\n            touchXRef.current = Math.ceil(e.touches[0].pageX);\n            touchYRef.current = Math.ceil(e.touches[0].pageY);\n            elementRef.current = e.target;\n            elementRef.current.addEventListener('touchmove', onTouchMove, { passive: false });\n            elementRef.current.addEventListener('touchend', onTouchEnd, { passive: true });\n        }\n    };\n    cleanUpEvents = () => {\n        if (elementRef.current) {\n            elementRef.current.removeEventListener('touchmove', onTouchMove);\n            elementRef.current.removeEventListener('touchend', onTouchEnd);\n        }\n    };\n    useLayoutEffect(() => {\n        var _a;\n        if (inVirtual) {\n            (_a = listRef.current) === null || _a === void 0 ? void 0 : _a.addEventListener('touchstart', onTouchStart, { passive: true });\n        }\n        return () => {\n            var _a;\n            (_a = listRef.current) === null || _a === void 0 ? void 0 : _a.removeEventListener('touchstart', onTouchStart);\n            cleanUpEvents();\n            clearInterval(intervalRef.current);\n        };\n    }, [inVirtual]);\n}"],"sourceRoot":"../../../../../../../../../../src"}

package/es/components/VirtualList/hooks/useOriginScroll.d.ts

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

package/es/components/VirtualList/hooks/useOriginScroll.js

@@ -0,0 +1,44 @@
+import { useRef } from 'react';
+export default (function (isScrollAtTop, isScrollAtBottom, isScrollAtLeft, isScrollAtRight) {
+  // Do lock for a wheel when scrolling
+  var lockRef = useRef(false);
+  var lockTimeoutRef = useRef(null);
+  function lockScroll() {
+    clearTimeout(lockTimeoutRef.current);
+    lockRef.current = true;
+    lockTimeoutRef.current = setTimeout(function () {
+      lockRef.current = false;
+    }, 50);
+  }
+  // Pass to ref since global add is in closure
+  var scrollPingRef = useRef({
+    top: isScrollAtTop,
+    bottom: isScrollAtBottom,
+    left: isScrollAtLeft,
+    right: isScrollAtRight
+  });
+  scrollPingRef.current.top = isScrollAtTop;
+  scrollPingRef.current.bottom = isScrollAtBottom;
+  scrollPingRef.current.left = isScrollAtLeft;
+  scrollPingRef.current.right = isScrollAtRight;
+  return function (isHorizontal, delta) {
+    var smoothOffset = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+    var originScroll = isHorizontal ?
+    // Pass origin wheel when on the left
+    delta < 0 && scrollPingRef.current.left ||
+    // Pass origin wheel when on the right
+    delta > 0 && scrollPingRef.current.right // Pass origin wheel when on the top
+    : delta < 0 && scrollPingRef.current.top ||
+    // Pass origin wheel when on the bottom
+    delta > 0 && scrollPingRef.current.bottom;
+    if (smoothOffset && originScroll) {
+      // No need lock anymore when it's smooth offset from touchMove interval
+      clearTimeout(lockTimeoutRef.current);
+      lockRef.current = false;
+    } else if (!originScroll || lockRef.current) {
+      lockScroll();
+    }
+    return !lockRef.current && originScroll;
+  };
+});
+//# sourceMappingURL=data:application/json;charset=utf8;base64,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

package/es/components/VirtualList/hooks/useScrollDrag.d.ts

@@ -0,0 +1,3 @@
+import * as React from 'react';
+export declare function getPageXY(e: React.MouseEvent | React.TouchEvent | MouseEvent | TouchEvent, horizontal: boolean): number;
+export default function useScrollDrag(inVirtual: boolean, componentRef: React.RefObject<HTMLElement | null>, onScrollOffset: (offset: number) => void): void;

package/es/components/VirtualList/hooks/useScrollDrag.js

@@ -0,0 +1,76 @@
+import raf from '../utils/raf';
+import * as React from 'react';
+function smoothScrollOffset(offset) {
+  return Math.floor(Math.pow(offset, 0.5));
+}
+export function getPageXY(e, horizontal) {
+  var obj = 'touches' in e ? e.touches[0] : e;
+  return obj[horizontal ? 'pageX' : 'pageY'] - window[horizontal ? 'scrollX' : 'scrollY'];
+}
+export default function useScrollDrag(inVirtual, componentRef, onScrollOffset) {
+  React.useEffect(function () {
+    var ele = componentRef.current;
+    if (inVirtual && ele) {
+      var mouseDownLock = false;
+      var rafId;
+      var offset;
+      var stopScroll = function stopScroll() {
+        raf.cancel(rafId);
+      };
+      var _continueScroll = function continueScroll() {
+        stopScroll();
+        rafId = raf(function () {
+          onScrollOffset(offset);
+          _continueScroll();
+        });
+      };
+      var clearDragState = function clearDragState() {
+        mouseDownLock = false;
+        stopScroll();
+      };
+      var onMouseDown = function onMouseDown(e) {
+        // Skip if element set draggable
+        if (e.target.draggable || e.button !== 0) {
+          return;
+        }
+        // Skip if nest List has handled this event
+        var event = e;
+        if (!event._virtualHandled) {
+          event._virtualHandled = true;
+          mouseDownLock = true;
+        }
+      };
+      var onMouseMove = function onMouseMove(e) {
+        if (mouseDownLock) {
+          var mouseY = getPageXY(e, false);
+          var _ele$getBoundingClien = ele.getBoundingClientRect(),
+            top = _ele$getBoundingClien.top,
+            bottom = _ele$getBoundingClien.bottom;
+          if (mouseY <= top) {
+            var diff = top - mouseY;
+            offset = -smoothScrollOffset(diff);
+            _continueScroll();
+          } else if (mouseY >= bottom) {
+            var _diff = mouseY - bottom;
+            offset = smoothScrollOffset(_diff);
+            _continueScroll();
+          } else {
+            stopScroll();
+          }
+        }
+      };
+      ele.addEventListener('mousedown', onMouseDown);
+      ele.ownerDocument.addEventListener('mouseup', clearDragState);
+      ele.ownerDocument.addEventListener('mousemove', onMouseMove);
+      ele.ownerDocument.addEventListener('dragend', clearDragState);
+      return function () {
+        ele.removeEventListener('mousedown', onMouseDown);
+        ele.ownerDocument.removeEventListener('mouseup', clearDragState);
+        ele.ownerDocument.removeEventListener('mousemove', onMouseMove);
+        ele.ownerDocument.removeEventListener('dragend', clearDragState);
+        stopScroll();
+      };
+    }
+  }, [inVirtual]);
+}
+//# sourceMappingURL=data:application/json;charset=utf8;base64,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

package/es/components/VirtualList/hooks/useScrollTo.d.ts

@@ -0,0 +1,18 @@
+import * as React from 'react';
+import type { GetKey } from '../interface';
+import type CacheMap from '../utils/CacheMap';
+export type ScrollAlign = 'top' | 'bottom' | 'auto';
+export type ScrollPos = {
+    left?: number;
+    top?: number;
+};
+export type ScrollTarget = {
+    index: number;
+    align?: ScrollAlign;
+    offset?: number;
+} | {
+    key: React.Key;
+    align?: ScrollAlign;
+    offset?: number;
+};
+export default function useScrollTo<T>(containerRef: React.RefObject<HTMLDivElement | null>, data: T[], heights: CacheMap, itemHeight: number, getKey: GetKey<T>, collectHeight: () => void, syncScrollTop: (newTop: number) => void, triggerFlash: () => void): (arg: number | ScrollTarget) => void;