@legendapp/list 2.0.0-beta.3 → 2.0.0-beta.5

package/index.mjs

@@ -672,30 +672,33 @@ function useThrottleDebounce(mode) {
       timeoutRef.current = null;
     }
   };
-  const execute = useCallback((callback, delay, ...args) => {
-    {
-      const now = Date.now();
-      lastArgsRef.current = args;
-      if (now - lastCallTimeRef.current >= delay) {
-        lastCallTimeRef.current = now;
-        callback(...args);
-        clearTimeoutRef();
-      } else {
-        clearTimeoutRef();
-        timeoutRef.current = setTimeout(
-          () => {
-            if (lastArgsRef.current) {
-              lastCallTimeRef.current = Date.now();
-              callback(...lastArgsRef.current);
-              timeoutRef.current = null;
-              lastArgsRef.current = null;
-            }
-          },
-          delay - (now - lastCallTimeRef.current)
-        );
+  const execute = useCallback(
+    (callback, delay, ...args) => {
+      {
+        const now = Date.now();
+        lastArgsRef.current = args;
+        if (now - lastCallTimeRef.current >= delay) {
+          lastCallTimeRef.current = now;
+          callback(...args);
+          clearTimeoutRef();
+        } else {
+          clearTimeoutRef();
+          timeoutRef.current = setTimeout(
+            () => {
+              if (lastArgsRef.current) {
+                lastCallTimeRef.current = Date.now();
+                callback(...lastArgsRef.current);
+                timeoutRef.current = null;
+                lastArgsRef.current = null;
+              }
+            },
+            delay - (now - lastCallTimeRef.current)
+          );
+        }
       }
-    }
-  }, [mode]);
+    },
+    [mode]
+  );
   return execute;
 }
 
@@ -891,7 +894,7 @@ function calculateOffsetForIndex(ctx, state, index) {
 }
 
 // src/utils/getItemSize.ts
-function getItemSize(state, key, index, data, useAverageSize, defaultAverageSize, preferRenderedCache) {
+function getItemSize(state, key, index, data, useAverageSize) {
   var _a, _b;
   const {
     sizesKnown,
@@ -912,22 +915,17 @@ function getItemSize(state, key, index, data, useAverageSize, defaultAverageSize
       sizesKnown.set(key, size);
     }
   }
-  const renderedSize = sizes.get(key);
-  if (size === void 0 && preferRenderedCache && renderedSize !== void 0) {
-    return renderedSize;
-  }
-  if (size === void 0 && useAverageSize && !scrollingTo) {
-    if (itemType === "") {
-      size = defaultAverageSize;
-    } else {
-      const averageSizeForType = (_b = averageSizes[itemType]) == null ? void 0 : _b.avg;
-      if (averageSizeForType !== void 0) {
-        size = roundSize(averageSizeForType);
-      }
+  if (size === void 0 && useAverageSize && sizeKnown === void 0 && !scrollingTo) {
+    const averageSizeForType = (_b = averageSizes[itemType]) == null ? void 0 : _b.avg;
+    if (averageSizeForType !== void 0) {
+      size = roundSize(averageSizeForType);
     }
   }
-  if (size === void 0 && renderedSize !== void 0) {
-    return renderedSize;
+  if (size === void 0) {
+    size = sizes.get(key);
+    if (size !== void 0) {
+      return size;
+    }
   }
   if (size === void 0) {
     size = getEstimatedItemSize ? getEstimatedItemSize(index, data, itemType) : estimatedItemSize;
@@ -1154,44 +1152,6 @@ function addTotalSize(ctx, state, key, add) {
   }
 }
 
-// src/utils/getScrollVelocity.ts
-var getScrollVelocity = (state) => {
-  const { scrollHistory } = state;
-  let velocity = 0;
-  if (scrollHistory.length >= 1) {
-    const newest = scrollHistory[scrollHistory.length - 1];
-    let oldest;
-    let start = 0;
-    const now = Date.now();
-    for (let i = 0; i < scrollHistory.length - 1; i++) {
-      const entry = scrollHistory[i];
-      const nextEntry = scrollHistory[i + 1];
-      if (i > 0) {
-        const prevEntry = scrollHistory[i - 1];
-        const prevDirection = entry.scroll - prevEntry.scroll;
-        const currentDirection = nextEntry.scroll - entry.scroll;
-        if (prevDirection > 0 && currentDirection < 0 || prevDirection < 0 && currentDirection > 0) {
-          start = i;
-          break;
-        }
-      }
-    }
-    for (let i = start; i < scrollHistory.length - 1; i++) {
-      const entry = scrollHistory[i];
-      if (now - entry.time <= 1e3) {
-        oldest = entry;
-        break;
-      }
-    }
-    if (oldest && oldest !== newest) {
-      const scrollDiff = newest.scroll - oldest.scroll;
-      const timeDiff = newest.time - oldest.time;
-      velocity = timeDiff > 0 ? scrollDiff / timeDiff : 0;
-    }
-  }
-  return velocity;
-};
-
 // src/utils/updateSnapToOffsets.ts
 function updateSnapToOffsets(ctx, state) {
   const {
@@ -1208,14 +1168,12 @@ function updateSnapToOffsets(ctx, state) {
 }
 
 // src/core/updateAllPositions.ts
-function updateAllPositions(ctx, state, dataChanged) {
-  var _a, _b, _c, _d, _e;
+function updateAllPositions(ctx, state, dataChanged, startIndex = 0) {
+  var _a, _b, _c, _d, _e, _f;
   const {
-    averageSizes,
     columns,
     indexByKey,
     positions,
-    firstFullyOnScreenIndex,
     idCache,
     sizesKnown,
     props: { getEstimatedItemSize, snapToIndices, enableAverages }
@@ -1223,69 +1181,29 @@ function updateAllPositions(ctx, state, dataChanged) {
   const data = state.props.data;
   const numColumns = peek$(ctx, "numColumns");
   const indexByKeyForChecking = __DEV__ ? /* @__PURE__ */ new Map() : void 0;
-  const scrollVelocity = getScrollVelocity(state);
   const useAverageSize = enableAverages && !getEstimatedItemSize;
-  const itemType = "";
-  let averageSize = (_a = averageSizes[itemType]) == null ? void 0 : _a.avg;
-  if (averageSize !== void 0) {
-    averageSize = roundSize(averageSize);
-  }
-  const shouldUseBackwards = !dataChanged && scrollVelocity < 0 && firstFullyOnScreenIndex > 5 && firstFullyOnScreenIndex < data.length;
-  if (shouldUseBackwards && firstFullyOnScreenIndex !== void 0) {
-    const anchorId = getId(state, firstFullyOnScreenIndex);
-    const anchorPosition = positions.get(anchorId);
-    if (anchorPosition !== void 0) {
-      let currentRowTop2 = anchorPosition;
-      let maxSizeInRow2 = 0;
-      let bailout = false;
-      for (let i = firstFullyOnScreenIndex - 1; i >= 0; i--) {
-        const id = (_b = idCache.get(i)) != null ? _b : getId(state, i);
-        const size = (_c = sizesKnown.get(id)) != null ? _c : getItemSize(
-          state,
-          id,
-          i,
-          data[i],
-          useAverageSize,
-          averageSize,
-          /*preferRenderedCache*/
-          !!dataChanged
-        );
-        const itemColumn = columns.get(id);
-        maxSizeInRow2 = Math.max(maxSizeInRow2, size);
-        if (itemColumn === 1) {
-          currentRowTop2 -= maxSizeInRow2;
-          maxSizeInRow2 = 0;
-        }
-        if (currentRowTop2 < -2e3) {
-          bailout = true;
-          break;
-        }
-        positions.set(id, currentRowTop2);
-      }
-      if (!bailout) {
-        updateTotalSize(ctx, state);
-        return;
-      }
-    }
-  }
   let currentRowTop = 0;
   let column = 1;
   let maxSizeInRow = 0;
   const hasColumns = numColumns > 1;
+  if (startIndex > 0) {
+    const prevIndex = startIndex - 1;
+    const prevId = (_a = idCache.get(prevIndex)) != null ? _a : getId(state, prevIndex);
+    const prevPosition = (_b = positions.get(prevId)) != null ? _b : 0;
+    if (hasColumns) {
+      const prevColumn = (_c = columns.get(prevId)) != null ? _c : 1;
+      currentRowTop = prevPosition;
+      column = prevColumn % numColumns + 1;
+    } else {
+      const prevSize = (_d = sizesKnown.get(prevId)) != null ? _d : getItemSize(state, prevId, prevIndex, data[prevIndex], useAverageSize);
+      currentRowTop = prevPosition + prevSize;
+    }
+  }
   const needsIndexByKey = dataChanged || indexByKey.size === 0;
   const dataLength = data.length;
-  for (let i = 0; i < dataLength; i++) {
-    const id = (_d = idCache.get(i)) != null ? _d : getId(state, i);
-    const size = (_e = sizesKnown.get(id)) != null ? _e : getItemSize(
-      state,
-      id,
-      i,
-      data[i],
-      useAverageSize,
-      averageSize,
-      /*preferRenderedCache*/
-      !!dataChanged
-    );
+  for (let i = startIndex; i < dataLength; i++) {
+    const id = (_e = idCache.get(i)) != null ? _e : getId(state, i);
+    const size = (_f = sizesKnown.get(id)) != null ? _f : getItemSize(state, id, i, data[i], useAverageSize);
     if (__DEV__ && needsIndexByKey) {
       if (indexByKeyForChecking.has(id)) {
         console.error(
@@ -1648,6 +1566,44 @@ function comparatorByDistance(a, b) {
   return b.distance - a.distance;
 }
 
+// src/utils/getScrollVelocity.ts
+var getScrollVelocity = (state) => {
+  const { scrollHistory } = state;
+  let velocity = 0;
+  if (scrollHistory.length >= 1) {
+    const newest = scrollHistory[scrollHistory.length - 1];
+    let oldest;
+    let start = 0;
+    const now = Date.now();
+    for (let i = 0; i < scrollHistory.length - 1; i++) {
+      const entry = scrollHistory[i];
+      const nextEntry = scrollHistory[i + 1];
+      if (i > 0) {
+        const prevEntry = scrollHistory[i - 1];
+        const prevDirection = entry.scroll - prevEntry.scroll;
+        const currentDirection = nextEntry.scroll - entry.scroll;
+        if (prevDirection > 0 && currentDirection < 0 || prevDirection < 0 && currentDirection > 0) {
+          start = i;
+          break;
+        }
+      }
+    }
+    for (let i = start; i < scrollHistory.length - 1; i++) {
+      const entry = scrollHistory[i];
+      if (now - entry.time <= 1e3) {
+        oldest = entry;
+        break;
+      }
+    }
+    if (oldest && oldest !== newest) {
+      const scrollDiff = newest.scroll - oldest.scroll;
+      const timeDiff = newest.time - oldest.time;
+      velocity = timeDiff > 0 ? scrollDiff / timeDiff : 0;
+    }
+  }
+  return velocity;
+};
+
 // src/core/scrollToIndex.ts
 function scrollToIndex(ctx, state, { index, viewOffset = 0, animated = true, viewPosition }) {
   if (index >= state.props.data.length) {
@@ -1859,7 +1815,11 @@ function calculateItemsInView(ctx, state, params = {}) {
         idCache.clear();
         positions.clear();
       }
-      updateAllPositions(ctx, state, dataChanged);
+      const startIndex = dataChanged ? 0 : minIndexSizeChanged != null ? minIndexSizeChanged : 0;
+      updateAllPositions(ctx, state, dataChanged, startIndex);
+      if (minIndexSizeChanged !== void 0) {
+        state.minIndexSizeChanged = void 0;
+      }
       checkMVCP == null ? void 0 : checkMVCP();
     }
     const scrollExtra = 0;
@@ -1906,10 +1866,6 @@ function calculateItemsInView(ctx, state, params = {}) {
     let endNoBuffer = null;
     let endBuffered = null;
     let loopStart = startBufferedIdOrig ? indexByKey.get(startBufferedIdOrig) || 0 : 0;
-    if (minIndexSizeChanged !== void 0) {
-      loopStart = Math.min(minIndexSizeChanged, loopStart);
-      state.minIndexSizeChanged = void 0;
-    }
     for (let i = loopStart; i >= 0; i--) {
       const id = (_a = idCache.get(i)) != null ? _a : getId(state, i);
       const top = positions.get(id);
@@ -2128,10 +2084,30 @@ function doInitialAllocateContainers(ctx, state) {
   var _a;
   const {
     scrollLength,
-    props: { data, getEstimatedItemSize, getItemType, scrollBuffer, numColumns, estimatedItemSize }
+    props: {
+      data,
+      getEstimatedItemSize,
+      getFixedItemSize,
+      getItemType,
+      scrollBuffer,
+      numColumns,
+      estimatedItemSize
+    }
   } = state;
-  if (scrollLength > 0 && data.length > 0 && !peek$(ctx, "numContainers")) {
-    const averageItemSize = getEstimatedItemSize ? getEstimatedItemSize(0, data[0], getItemType ? (_a = getItemType(data[0], 0)) != null ? _a : "" : "") : estimatedItemSize;
+  const hasContainers = peek$(ctx, "numContainers");
+  if (scrollLength > 0 && data.length > 0 && !hasContainers) {
+    let averageItemSize;
+    const fn = getFixedItemSize || getEstimatedItemSize;
+    if (fn) {
+      let totalSize = 0;
+      const num = Math.min(20, data.length);
+      for (let i = 0; i < num; i++) {
+        totalSize += fn(0, data[0], getItemType ? (_a = getItemType(data[0], 0)) != null ? _a : "" : "");
+      }
+      averageItemSize = totalSize / num;
+    } else {
+      averageItemSize = estimatedItemSize;
+    }
     const numContainers = Math.ceil((scrollLength + scrollBuffer * 2) / averageItemSize * numColumns);
     for (let i = 0; i < numContainers; i++) {
       set$(ctx, `containerPosition${i}`, POSITION_OUT_OF_VIEW);
@@ -2139,13 +2115,13 @@ function doInitialAllocateContainers(ctx, state) {
     }
     set$(ctx, "numContainers", numContainers);
     set$(ctx, "numContainersPooled", numContainers * state.props.initialContainerPoolRatio);
-    if (!IsNewArchitecture) {
+    if (!IsNewArchitecture || state.lastLayout) {
       if (state.props.initialScroll) {
         requestAnimationFrame(() => {
-          calculateItemsInView(ctx, state);
+          calculateItemsInView(ctx, state, { dataChanged: true });
         });
       } else {
-        calculateItemsInView(ctx, state);
+        calculateItemsInView(ctx, state, { dataChanged: true });
       }
     }
     return true;
@@ -2217,35 +2193,37 @@ function handleLayout(ctx, state, layout, setCanRender) {
   const otherAxisSize = layout[state.props.horizontal ? "height" : "width"];
   const needsCalculate = !state.lastLayout || scrollLength > state.scrollLength || state.lastLayout.x !== layout.x || state.lastLayout.y !== layout.y;
   state.lastLayout = layout;
-  const didChange = scrollLength !== state.scrollLength;
   const prevOtherAxisSize = state.otherAxisSize;
-  state.scrollLength = scrollLength;
-  state.otherAxisSize = otherAxisSize;
-  state.lastBatchingAction = Date.now();
-  state.scrollForNextCalculateItemsInView = void 0;
-  doInitialAllocateContainers(ctx, state);
-  if (needsCalculate) {
-    calculateItemsInView(ctx, state, { doMVCP: true });
-  }
-  if (didChange || otherAxisSize !== prevOtherAxisSize) {
-    set$(ctx, "scrollSize", { height: layout.height, width: layout.width });
-  }
-  if (maintainScrollAtEnd === true || maintainScrollAtEnd.onLayout) {
-    doMaintainScrollAtEnd(ctx, state, false);
-  }
-  updateAlignItemsPaddingTop(ctx, state);
-  checkAtBottom(ctx, state);
-  checkAtTop(state);
-  if (state) {
-    state.needsOtherAxisSize = otherAxisSize - (state.props.stylePaddingTop || 0) < 10;
-  }
-  if (__DEV__ && scrollLength === 0) {
-    warnDevOnce(
-      "height0",
-      `List ${state.props.horizontal ? "width" : "height"} is 0. You may need to set a style or \`flex: \` for the list, because children are absolutely positioned.`
-    );
+  const didChange = scrollLength !== state.scrollLength || otherAxisSize !== prevOtherAxisSize;
+  if (didChange) {
+    state.scrollLength = scrollLength;
+    state.otherAxisSize = otherAxisSize;
+    state.lastBatchingAction = Date.now();
+    state.scrollForNextCalculateItemsInView = void 0;
+    doInitialAllocateContainers(ctx, state);
+    if (needsCalculate) {
+      calculateItemsInView(ctx, state, { doMVCP: true });
+    }
+    if (didChange || otherAxisSize !== prevOtherAxisSize) {
+      set$(ctx, "scrollSize", { height: layout.height, width: layout.width });
+    }
+    if (maintainScrollAtEnd === true || maintainScrollAtEnd.onLayout) {
+      doMaintainScrollAtEnd(ctx, state, false);
+    }
+    updateAlignItemsPaddingTop(ctx, state);
+    checkAtBottom(ctx, state);
+    checkAtTop(state);
+    if (state) {
+      state.needsOtherAxisSize = otherAxisSize - (state.props.stylePaddingTop || 0) < 10;
+    }
+    if (__DEV__ && scrollLength === 0) {
+      warnDevOnce(
+        "height0",
+        `List ${state.props.horizontal ? "width" : "height"} is 0. You may need to set a style or \`flex: \` for the list, because children are absolutely positioned.`
+      );
+    }
+    setCanRender(true);
   }
-  setCanRender(true);
 }
 
 // src/core/onScroll.ts
@@ -2279,7 +2257,8 @@ function updateScroll(ctx, state, newScroll) {
   state.lastBatchingAction = Date.now();
   const currentTime = Date.now();
   if (scrollingTo === void 0 && !(state.scrollHistory.length === 0 && newScroll === state.scroll)) {
-    state.scrollHistory.push({ scroll: newScroll, time: currentTime });
+    const adjust = state.scrollAdjustHandler.getAdjust();
+    state.scrollHistory.push({ scroll: newScroll - adjust, time: currentTime });
   }
   if (state.scrollHistory.length > 5) {
     state.scrollHistory.shift();
@@ -2315,13 +2294,19 @@ var ScrollAdjustHandler = class {
   setMounted() {
     this.mounted = true;
   }
+  getAdjust() {
+    return this.appliedAdjust;
+  }
 };
 
 // src/core/updateItemSize.ts
-function updateItemSizes(ctx, state, itemUpdates) {
-  var _a;
+function updateItemSize(ctx, state, itemKey, sizeObj) {
+  var _a, _b;
   const {
+    sizesKnown,
     props: {
+      getFixedItemSize,
+      getItemType,
       horizontal,
       maintainVisibleContentPosition,
       suggestEstimatedItemSize,
@@ -2331,47 +2316,60 @@ function updateItemSizes(ctx, state, itemUpdates) {
     }
   } = state;
   if (!data) return;
+  if (getFixedItemSize) {
+    const index2 = state.indexByKey.get(itemKey);
+    if (index2 === void 0) {
+      return;
+    }
+    const itemData = state.props.data[index2];
+    if (itemData === void 0) {
+      return;
+    }
+    const type = getItemType ? (_a = getItemType(itemData, index2)) != null ? _a : "" : "";
+    const size2 = getFixedItemSize(index2, itemData, type);
+    if (size2 !== void 0 && size2 === sizesKnown.get(itemKey)) {
+      return;
+    }
+  }
   const containersDidLayout = peek$(ctx, "containersDidLayout");
   let needsRecalculate = !containersDidLayout;
   let shouldMaintainScrollAtEnd = false;
   let minIndexSizeChanged;
   let maxOtherAxisSize = peek$(ctx, "otherAxisSize") || 0;
-  for (const { itemKey, sizeObj } of itemUpdates) {
-    const index = state.indexByKey.get(itemKey);
-    const prevSizeKnown = state.sizesKnown.get(itemKey);
-    const diff = updateOneItemSize(state, itemKey, sizeObj);
-    const size = Math.floor((horizontal ? sizeObj.width : sizeObj.height) * 8) / 8;
-    if (diff !== 0) {
-      minIndexSizeChanged = minIndexSizeChanged !== void 0 ? Math.min(minIndexSizeChanged, index) : index;
-      if (((_a = state.scrollingTo) == null ? void 0 : _a.viewPosition) && maintainVisibleContentPosition && index === state.scrollingTo.index && diff > 0) {
-        requestAdjust(ctx, state, diff * state.scrollingTo.viewPosition);
-      }
-      const { startBuffered, endBuffered } = state;
-      needsRecalculate || (needsRecalculate = index >= startBuffered && index <= endBuffered);
-      if (!needsRecalculate) {
-        const numContainers = ctx.values.get("numContainers");
-        for (let i = 0; i < numContainers; i++) {
-          if (peek$(ctx, `containerItemKey${i}`) === itemKey) {
-            needsRecalculate = true;
-            break;
-          }
+  const index = state.indexByKey.get(itemKey);
+  const prevSizeKnown = state.sizesKnown.get(itemKey);
+  const diff = updateOneItemSize(state, itemKey, sizeObj);
+  const size = Math.floor((horizontal ? sizeObj.width : sizeObj.height) * 8) / 8;
+  if (diff !== 0) {
+    minIndexSizeChanged = minIndexSizeChanged !== void 0 ? Math.min(minIndexSizeChanged, index) : index;
+    if (((_b = state.scrollingTo) == null ? void 0 : _b.viewPosition) && maintainVisibleContentPosition && index === state.scrollingTo.index && diff > 0) {
+      requestAdjust(ctx, state, diff * state.scrollingTo.viewPosition);
+    }
+    const { startBuffered, endBuffered } = state;
+    needsRecalculate || (needsRecalculate = index >= startBuffered && index <= endBuffered);
+    if (!needsRecalculate) {
+      const numContainers = ctx.values.get("numContainers");
+      for (let i = 0; i < numContainers; i++) {
+        if (peek$(ctx, `containerItemKey${i}`) === itemKey) {
+          needsRecalculate = true;
+          break;
         }
       }
-      if (state.needsOtherAxisSize) {
-        const otherAxisSize = horizontal ? sizeObj.height : sizeObj.width;
-        maxOtherAxisSize = Math.max(maxOtherAxisSize, otherAxisSize);
-      }
-      if (prevSizeKnown !== void 0 && Math.abs(prevSizeKnown - size) > 5) {
-        shouldMaintainScrollAtEnd = true;
-      }
-      onItemSizeChanged == null ? void 0 : onItemSizeChanged({
-        index,
-        itemData: state.props.data[index],
-        itemKey,
-        previous: size - diff,
-        size
-      });
     }
+    if (state.needsOtherAxisSize) {
+      const otherAxisSize = horizontal ? sizeObj.height : sizeObj.width;
+      maxOtherAxisSize = Math.max(maxOtherAxisSize, otherAxisSize);
+    }
+    if (prevSizeKnown !== void 0 && Math.abs(prevSizeKnown - size) > 5) {
+      shouldMaintainScrollAtEnd = true;
+    }
+    onItemSizeChanged == null ? void 0 : onItemSizeChanged({
+      index,
+      itemData: state.props.data[index],
+      itemKey,
+      previous: size - diff,
+      size
+    });
   }
   if (minIndexSizeChanged !== void 0) {
     state.minIndexSizeChanged = state.minIndexSizeChanged !== void 0 ? Math.min(state.minIndexSizeChanged, minIndexSizeChanged) : minIndexSizeChanged;
@@ -2404,45 +2402,6 @@ function updateItemSizes(ctx, state, itemUpdates) {
     }
   }
 }
-function updateItemSize(ctx, state, itemKey, sizeObj) {
-  var _a;
-  const {
-    queuedItemSizeUpdates,
-    queuedItemSizeUpdatesWaiting,
-    sizesKnown,
-    props: { getFixedItemSize, getItemType }
-  } = state;
-  if (getFixedItemSize) {
-    const index = state.indexByKey.get(itemKey);
-    if (index === void 0) {
-      return;
-    }
-    const itemData = state.props.data[index];
-    if (itemData === void 0) {
-      return;
-    }
-    const type = getItemType ? (_a = getItemType(itemData, index)) != null ? _a : "" : "";
-    const size = getFixedItemSize(index, itemData, type);
-    if (size !== void 0 && size === sizesKnown.get(itemKey)) {
-      return;
-    }
-  }
-  const containersDidLayout = peek$(ctx, "containersDidLayout");
-  const speed = getScrollVelocity(state);
-  if (!containersDidLayout || !queuedItemSizeUpdatesWaiting || Math.abs(speed) < 1) {
-    updateItemSizes(ctx, state, [{ itemKey, sizeObj }]);
-    if (containersDidLayout) {
-      state.queuedItemSizeUpdatesWaiting = true;
-      requestAnimationFrame(() => {
-        state.queuedItemSizeUpdatesWaiting = false;
-        updateItemSizes(ctx, state, queuedItemSizeUpdates);
-        queuedItemSizeUpdates.length = 0;
-      });
-    }
-  } else {
-    queuedItemSizeUpdates.push({ itemKey, sizeObj });
-  }
-}
 function updateOneItemSize(state, itemKey, sizeObj) {
   var _a;
   const {
@@ -2457,7 +2416,7 @@ function updateOneItemSize(state, itemKey, sizeObj) {
   const prevSize = getItemSize(state, itemKey, index, data);
   const size = Math.floor((horizontal ? sizeObj.width : sizeObj.height) * 8) / 8;
   sizesKnown.set(itemKey, size);
-  if (!getEstimatedItemSize && !getFixedItemSize) {
+  if (!getEstimatedItemSize && !getFixedItemSize && size > 0) {
     const itemType = getItemType ? (_a = getItemType(data[index], index)) != null ? _a : "" : "";
     let averages = averageSizes[itemType];
     if (!averages) {
@@ -2530,11 +2489,9 @@ function getRenderedItem(ctx, state, key) {
 }
 
 // src/utils/throttledOnScroll.ts
-function throttledOnScroll(originalHandler, scrollEventThrottle) {
+function useThrottledOnScroll(originalHandler, scrollEventThrottle) {
   const throttle = useThrottleDebounce("throttle");
-  return (event) => {
-    throttle(originalHandler, scrollEventThrottle, event);
-  };
+  return (event) => throttle(originalHandler, scrollEventThrottle, { nativeEvent: event.nativeEvent });
 }
 
 // src/utils/updateAveragesOnDataChange.ts
@@ -2703,11 +2660,9 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
       loadStartTime: Date.now(),
       minIndexSizeChanged: 0,
       nativeMarginTop: 0,
-      pendingAdjust: 0,
       positions: /* @__PURE__ */ new Map(),
       props: {},
       queuedCalculateItemsInView: 0,
-      queuedItemSizeUpdates: [],
       refScroller: void 0,
       scroll: 0,
       scrollAdjustHandler: new ScrollAdjustHandler(ctx),
@@ -2737,6 +2692,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
   const state = refState.current;
   const isFirst = !state.props.renderItem;
   const didDataChange = state.props.data !== dataProp;
+  const throttleScrollFn = scrollEventThrottle && onScrollProp ? useThrottledOnScroll(onScrollProp, scrollEventThrottle) : onScrollProp;
   state.props = {
     alignItemsAtEnd,
     data: dataProp,
@@ -2758,7 +2714,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     onEndReachedThreshold,
     onItemSizeChanged,
     onLoad,
-    onScroll: onScrollProp,
+    onScroll: throttleScrollFn,
     onStartReached,
     onStartReachedThreshold,
     recycleItems: !!recycleItems,
@@ -2865,7 +2821,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     }
   }, [snapToIndices]);
   useLayoutEffect(() => {
-    const didAllocateContainers = doInitialAllocateContainersCallback();
+    const didAllocateContainers = dataProp.length > 0 && doInitialAllocateContainersCallback();
     if (!didAllocateContainers) {
       checkResetContainers(
         /*isFirst*/
@@ -3016,8 +2972,8 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     }),
     []
   );
-  const animatedScrollHandler = useMemo(() => {
-    const onScrollFn = scrollEventThrottle && scrollEventThrottle > 0 ? throttledOnScroll(fns.onScroll, scrollEventThrottle) : fns.onScroll;
+  const onScrollHandler = useMemo(() => {
+    const onScrollFn = fns.onScroll;
     if (stickyIndices == null ? void 0 : stickyIndices.length) {
       const { animatedScrollY } = ctx;
       return Animated.event([{ nativeEvent: { contentOffset: { [horizontal ? "x" : "y"]: animatedScrollY } } }], {
@@ -3056,7 +3012,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
           onMomentumScrollEnd(event);
         }
       },
-      onScroll: animatedScrollHandler,
+      onScroll: onScrollHandler,
       recycleItems,
       refreshControl: refreshControl ? stylePaddingTopState > 0 ? React3.cloneElement(refreshControl, {
         progressViewOffset: (refreshControl.props.progressViewOffset || 0) + stylePaddingTopState