@legendapp/list 3.0.0-beta.2 → 3.0.0-beta.21

package/keyboard.mjs

@@ -1,87 +1,291 @@
 import * as React from 'react';
-import { forwardRef } from 'react';
-import { Platform } from 'react-native';
+import { forwardRef, useRef, useCallback } from 'react';
+import { StyleSheet, Platform } from 'react-native';
 import { useKeyboardHandler } from 'react-native-keyboard-controller';
-import { useAnimatedRef, useSharedValue, useAnimatedScrollHandler, runOnJS, scrollTo, useAnimatedProps, useAnimatedStyle } from 'react-native-reanimated';
+import { useAnimatedRef, useSharedValue, useAnimatedScrollHandler, runOnJS, runOnUI, useAnimatedProps, useAnimatedStyle } from 'react-native-reanimated';
 import { AnimatedLegendList } from '@legendapp/list/reanimated';
 
 // src/integrations/keyboard.tsx
+
+// src/constants-platform.ts
+var IsNewArchitecture = true;
+
+// src/utils/helpers.ts
+function isFunction(obj) {
+  return typeof obj === "function";
+}
+
+// src/hooks/useCombinedRef.ts
+var useCombinedRef = (...refs) => {
+  const callback = useCallback((element) => {
+    for (const ref of refs) {
+      if (!ref) {
+        continue;
+      }
+      if (isFunction(ref)) {
+        ref(element);
+      } else {
+        ref.current = element;
+      }
+    }
+  }, refs);
+  return callback;
+};
+
+// src/integrations/keyboard.tsx
+var clampProgress = (progress) => {
+  "worklet";
+  return Math.min(1, Math.max(0, progress));
+};
+var calculateKeyboardInset = (height, safeAreaInsetBottom, isNewArchitecture) => {
+  "worklet";
+  return Math.max(0, height - safeAreaInsetBottom) ;
+};
+var calculateEndPaddingInset = (keyboardHeight, alignItemsAtEndPadding) => {
+  "worklet";
+  return Math.min(keyboardHeight, alignItemsAtEndPadding);
+};
+var calculateTopInset = (safeAreaInsetTop, isNewArchitecture, extraTopInset) => {
+  "worklet";
+  return (isNewArchitecture ? 0 : safeAreaInsetTop * 2) + extraTopInset;
+};
+var calculateKeyboardTargetOffset = (startOffset, keyboardHeight, isOpening, progress) => {
+  "worklet";
+  const normalizedProgress = isOpening ? progress : 1 - progress;
+  const delta = (isOpening ? keyboardHeight : -keyboardHeight) * normalizedProgress;
+  return Math.max(0, startOffset + delta);
+};
 var KeyboardAvoidingLegendList = forwardRef(function KeyboardAvoidingLegendList2(props, forwardedRef) {
   const {
     contentInset: contentInsetProp,
     horizontal,
+    onMetricsChange: onMetricsChangeProp,
     onScroll: onScrollProp,
-    scrollEventThrottle,
-    safeAreaInsetBottom = 0,
+    safeAreaInsets = { bottom: 0, top: 0 },
+    style: styleProp,
     ...rest
   } = props;
-  const resolvedScrollEventThrottle = scrollEventThrottle != null ? scrollEventThrottle : 16;
+  const styleFlattened = StyleSheet.flatten(styleProp);
+  const refLegendList = useRef(null);
+  const combinedRef = useCombinedRef(forwardedRef, refLegendList);
+  const isIos = Platform.OS === "ios";
+  const isAndroid = Platform.OS === "android";
   const scrollViewRef = useAnimatedRef();
   const scrollOffsetY = useSharedValue(0);
+  const animatedOffsetY = useSharedValue(null);
   const scrollOffsetAtKeyboardStart = useSharedValue(0);
-  const keyboardInset = useSharedValue(0);
+  const mode = useSharedValue("idle");
+  const keyboardInset = useSharedValue({ bottom: 0, top: 0 });
+  const keyboardHeight = useSharedValue(0);
+  const alignItemsAtEndPadding = useSharedValue(0);
+  const isOpening = useSharedValue(false);
+  const didInteractive = useSharedValue(false);
+  const { top: safeAreaInsetTop, bottom: safeAreaInsetBottom } = safeAreaInsets;
+  const isKeyboardOpen = useSharedValue(false);
   const scrollHandler = useAnimatedScrollHandler(
     (event) => {
-      scrollOffsetY.value = event.contentOffset[horizontal ? "x" : "y"];
+      scrollOffsetY.set(event.contentOffset[horizontal ? "x" : "y"]);
       if (onScrollProp) {
         runOnJS(onScrollProp)(event);
       }
     },
     [onScrollProp, horizontal]
   );
+  const setScrollProcessingEnabled = useCallback(
+    (enabled) => {
+      var _a;
+      return (_a = refLegendList.current) == null ? void 0 : _a.setScrollProcessingEnabled(enabled);
+    },
+    [refLegendList]
+  );
+  const handleMetricsChange = useCallback(
+    (metrics) => {
+      const nextPadding = metrics.alignItemsAtEndPadding || 0;
+      alignItemsAtEndPadding.set(nextPadding);
+      if (!horizontal) {
+        runOnUI((padding, safeInsetTop, isNewArchitecture) => {
+          "worklet";
+          if (!isKeyboardOpen.get()) {
+            return;
+          }
+          const vKeyboardHeight = keyboardHeight.get();
+          const vTopInset = calculateEndPaddingInset(vKeyboardHeight, padding);
+          const topInset = calculateTopInset(safeInsetTop, isNewArchitecture, vTopInset);
+          keyboardInset.set({
+            bottom: keyboardInset.get().bottom,
+            top: topInset
+          });
+        })(nextPadding, safeAreaInsetTop, IsNewArchitecture);
+      }
+      onMetricsChangeProp == null ? void 0 : onMetricsChangeProp(metrics);
+    },
+    [
+      alignItemsAtEndPadding,
+      horizontal,
+      isKeyboardOpen,
+      keyboardHeight,
+      keyboardInset,
+      onMetricsChangeProp,
+      safeAreaInsetTop
+    ]
+  );
   useKeyboardHandler(
     // biome-ignore assist/source/useSortedKeys: prefer start/move/end
     {
-      onStart: () => {
+      onStart: (event) => {
+        "worklet";
+        mode.set("running");
+        const progress = clampProgress(event.progress);
+        if (isKeyboardOpen.get() && progress >= 1 && event.height > 0) {
+          return;
+        }
+        if (!didInteractive.get()) {
+          if (event.height > 0) {
+            keyboardHeight.set(event.height - safeAreaInsetBottom);
+          }
+          isOpening.set(progress > 0);
+          scrollOffsetAtKeyboardStart.set(scrollOffsetY.get());
+          animatedOffsetY.set(scrollOffsetY.get());
+          runOnJS(setScrollProcessingEnabled)(false);
+        }
+      },
+      onInteractive: (event) => {
         "worklet";
-        scrollOffsetAtKeyboardStart.value = scrollOffsetY.value;
+        if (mode.get() !== "running") {
+          runOnJS(setScrollProcessingEnabled)(false);
+        }
+        mode.set("running");
+        if (!didInteractive.get()) {
+          if (!isAndroid && !IsNewArchitecture) {
+            keyboardInset.set({
+              bottom: keyboardInset.get().bottom,
+              // Legacy iOS uses a doubled top inset to keep content below the status bar.
+              top: calculateTopInset(safeAreaInsetTop, IsNewArchitecture, 0)
+            });
+          }
+          didInteractive.set(true);
+        }
+        if (isAndroid && !horizontal) {
+          const newInset = calculateKeyboardInset(event.height, safeAreaInsetBottom);
+          keyboardInset.set({ bottom: newInset, top: safeAreaInsetTop * 2 });
+        }
       },
       onMove: (event) => {
         "worklet";
-        const targetOffset = scrollOffsetAtKeyboardStart.value + event.height;
-        scrollOffsetY.value = targetOffset;
-        scrollTo(scrollViewRef, 0, targetOffset, false);
-        if (!horizontal) {
-          keyboardInset.value = Math.max(0, event.height - safeAreaInsetBottom);
+        if (!didInteractive.get()) {
+          const progress = clampProgress(event.progress);
+          const vIsOpening = isOpening.get();
+          const vKeyboardHeight = keyboardHeight.get();
+          const vAlignItemsPadding = alignItemsAtEndPadding.get();
+          const vTopInset = calculateEndPaddingInset(vKeyboardHeight, vAlignItemsPadding);
+          const targetOffset = calculateKeyboardTargetOffset(
+            scrollOffsetAtKeyboardStart.get(),
+            vKeyboardHeight,
+            vIsOpening,
+            progress
+          );
+          scrollOffsetY.set(targetOffset);
+          animatedOffsetY.set(targetOffset);
+          if (!horizontal) {
+            const newInset = calculateKeyboardInset(event.height, safeAreaInsetBottom);
+            const topInset = calculateTopInset(
+              safeAreaInsetTop,
+              IsNewArchitecture,
+              vIsOpening ? vTopInset : 0
+            );
+            keyboardInset.set({
+              bottom: newInset,
+              // Add top padding only while opening to keep end-aligned items visible.
+              top: topInset
+            });
+          }
         }
       },
       onEnd: (event) => {
         "worklet";
-        const targetOffset = scrollOffsetAtKeyboardStart.value + event.height;
-        scrollOffsetY.value = targetOffset;
-        scrollTo(scrollViewRef, 0, targetOffset, false);
-        if (!horizontal) {
-          keyboardInset.value = Math.max(0, event.height - safeAreaInsetBottom);
+        const wasInteractive = didInteractive.get();
+        const vMode = mode.get();
+        mode.set("idle");
+        if (vMode === "running") {
+          const progress = clampProgress(event.progress);
+          const vKeyboardHeight = keyboardHeight.get();
+          const vAlignItemsPadding = alignItemsAtEndPadding.get();
+          const vTopInset = calculateEndPaddingInset(vKeyboardHeight, vAlignItemsPadding);
+          const vIsOpening = isOpening.get();
+          if (!wasInteractive) {
+            const targetOffset = calculateKeyboardTargetOffset(
+              scrollOffsetAtKeyboardStart.get(),
+              vKeyboardHeight,
+              vIsOpening,
+              progress
+            );
+            scrollOffsetY.set(targetOffset);
+            animatedOffsetY.set(targetOffset);
+          }
+          runOnJS(setScrollProcessingEnabled)(true);
+          didInteractive.set(false);
+          isKeyboardOpen.set(event.height > 0);
+          if (!horizontal) {
+            const newInset = calculateKeyboardInset(event.height, safeAreaInsetBottom);
+            const topInset = calculateTopInset(
+              safeAreaInsetTop,
+              IsNewArchitecture,
+              event.height > 0 ? vTopInset : 0
+            );
+            keyboardInset.set({
+              bottom: newInset,
+              // Preserve end-aligned padding only while the keyboard is visible.
+              top: topInset
+            });
+            if (newInset <= 0) {
+              animatedOffsetY.set(scrollOffsetY.get());
+            }
+          }
         }
       }
     },
     [scrollViewRef, safeAreaInsetBottom]
   );
-  const animatedProps = Platform.OS === "ios" ? useAnimatedProps(() => {
+  const animatedProps = useAnimatedProps(() => {
     "worklet";
     var _a, _b, _c, _d;
-    return {
+    const vAnimatedOffsetY = animatedOffsetY.get();
+    const baseProps = {
+      contentOffset: vAnimatedOffsetY === null ? void 0 : {
+        x: 0,
+        y: vAnimatedOffsetY
+      }
+    };
+    const { top: keyboardInsetTop, bottom: keyboardInsetBottom } = keyboardInset.get();
+    return isIos ? Object.assign(baseProps, {
       contentInset: {
-        bottom: ((_a = contentInsetProp == null ? void 0 : contentInsetProp.bottom) != null ? _a : 0) + (horizontal ? 0 : keyboardInset.value),
+        bottom: ((_a = contentInsetProp == null ? void 0 : contentInsetProp.bottom) != null ? _a : 0) + (horizontal ? 0 : keyboardInsetBottom),
         left: (_b = contentInsetProp == null ? void 0 : contentInsetProp.left) != null ? _b : 0,
         right: (_c = contentInsetProp == null ? void 0 : contentInsetProp.right) != null ? _c : 0,
-        top: (_d = contentInsetProp == null ? void 0 : contentInsetProp.top) != null ? _d : 0
+        top: ((_d = contentInsetProp == null ? void 0 : contentInsetProp.top) != null ? _d : 0) - keyboardInsetTop
       }
-    };
-  }) : void 0;
-  const style = Platform.OS !== "ios" ? useAnimatedStyle(() => ({
-    marginBottom: keyboardInset.value
-  })) : void 0;
+    }) : baseProps;
+  });
+  const style = isAndroid ? useAnimatedStyle(
+    () => {
+      var _a;
+      return {
+        ...styleFlattened || {},
+        marginBottom: (_a = keyboardInset.get().bottom) != null ? _a : 0
+      };
+    },
+    [styleProp, keyboardInset]
+  ) : void 0;
   return /* @__PURE__ */ React.createElement(
     AnimatedLegendList,
     {
       ...rest,
       animatedProps,
       keyboardDismissMode: "interactive",
+      onMetricsChange: handleMetricsChange,
       onScroll: scrollHandler,
-      ref: forwardedRef,
+      ref: combinedRef,
       refScrollView: scrollViewRef,
-      scrollEventThrottle: resolvedScrollEventThrottle,
       scrollIndicatorInsets: { bottom: 0, top: 0 },
       style
     }

package/keyboard.native.d.mts

@@ -0,0 +1,16 @@
+import * as React from 'react';
+import { Insets } from 'react-native';
+import { ReanimatedScrollEvent } from 'react-native-reanimated/lib/typescript/hook/commonTypes';
+import { LegendListRef } from '@legendapp/list';
+import { AnimatedLegendListProps } from '@legendapp/list/reanimated';
+
+declare const KeyboardAvoidingLegendList: <ItemT>(props: Omit<AnimatedLegendListProps<ItemT>, "onScroll" | "contentInset"> & {
+    onScroll?: (event: ReanimatedScrollEvent) => void;
+    contentInset?: Insets | undefined;
+    safeAreaInsets?: {
+        top: number;
+        bottom: number;
+    };
+} & React.RefAttributes<LegendListRef>) => React.ReactNode;
+
+export { KeyboardAvoidingLegendList, KeyboardAvoidingLegendList as LegendList };

package/keyboard.native.d.ts

@@ -0,0 +1,16 @@
+import * as React from 'react';
+import { Insets } from 'react-native';
+import { ReanimatedScrollEvent } from 'react-native-reanimated/lib/typescript/hook/commonTypes';
+import { LegendListRef } from '@legendapp/list';
+import { AnimatedLegendListProps } from '@legendapp/list/reanimated';
+
+declare const KeyboardAvoidingLegendList: <ItemT>(props: Omit<AnimatedLegendListProps<ItemT>, "onScroll" | "contentInset"> & {
+    onScroll?: (event: ReanimatedScrollEvent) => void;
+    contentInset?: Insets | undefined;
+    safeAreaInsets?: {
+        top: number;
+        bottom: number;
+    };
+} & React.RefAttributes<LegendListRef>) => React.ReactNode;
+
+export { KeyboardAvoidingLegendList, KeyboardAvoidingLegendList as LegendList };

package/keyboard.native.js

@@ -0,0 +1,318 @@
+'use strict';
+
+var React = require('react');
+var reactNative = require('react-native');
+var reactNativeKeyboardController = require('react-native-keyboard-controller');
+var reactNativeReanimated = require('react-native-reanimated');
+var reanimated = require('@legendapp/list/reanimated');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var React__namespace = /*#__PURE__*/_interopNamespace(React);
+
+// src/integrations/keyboard.tsx
+
+// src/constants-platform.native.ts
+var f = global.nativeFabricUIManager;
+var IsNewArchitecture = f !== void 0 && f != null;
+
+// src/utils/helpers.ts
+function isFunction(obj) {
+  return typeof obj === "function";
+}
+
+// src/hooks/useCombinedRef.ts
+var useCombinedRef = (...refs) => {
+  const callback = React.useCallback((element) => {
+    for (const ref of refs) {
+      if (!ref) {
+        continue;
+      }
+      if (isFunction(ref)) {
+        ref(element);
+      } else {
+        ref.current = element;
+      }
+    }
+  }, refs);
+  return callback;
+};
+
+// src/integrations/keyboard.tsx
+var clampProgress = (progress) => {
+  "worklet";
+  return Math.min(1, Math.max(0, progress));
+};
+var calculateKeyboardInset = (height, safeAreaInsetBottom, isNewArchitecture) => {
+  "worklet";
+  return isNewArchitecture ? Math.max(0, height - safeAreaInsetBottom) : Math.max(isNewArchitecture ? 0 : -safeAreaInsetBottom, height - safeAreaInsetBottom * 2);
+};
+var calculateEndPaddingInset = (keyboardHeight, alignItemsAtEndPadding) => {
+  "worklet";
+  return Math.min(keyboardHeight, alignItemsAtEndPadding);
+};
+var calculateTopInset = (safeAreaInsetTop, isNewArchitecture, extraTopInset) => {
+  "worklet";
+  return (isNewArchitecture ? 0 : safeAreaInsetTop * 2) + extraTopInset;
+};
+var calculateKeyboardTargetOffset = (startOffset, keyboardHeight, isOpening, progress) => {
+  "worklet";
+  const normalizedProgress = isOpening ? progress : 1 - progress;
+  const delta = (isOpening ? keyboardHeight : -keyboardHeight) * normalizedProgress;
+  return Math.max(0, startOffset + delta);
+};
+var KeyboardAvoidingLegendList = React.forwardRef(function KeyboardAvoidingLegendList2(props, forwardedRef) {
+  const {
+    contentInset: contentInsetProp,
+    horizontal,
+    onMetricsChange: onMetricsChangeProp,
+    onScroll: onScrollProp,
+    safeAreaInsets = { bottom: 0, top: 0 },
+    style: styleProp,
+    ...rest
+  } = props;
+  const styleFlattened = reactNative.StyleSheet.flatten(styleProp);
+  const refLegendList = React.useRef(null);
+  const combinedRef = useCombinedRef(forwardedRef, refLegendList);
+  const isIos = reactNative.Platform.OS === "ios";
+  const isAndroid = reactNative.Platform.OS === "android";
+  const scrollViewRef = reactNativeReanimated.useAnimatedRef();
+  const scrollOffsetY = reactNativeReanimated.useSharedValue(0);
+  const animatedOffsetY = reactNativeReanimated.useSharedValue(null);
+  const scrollOffsetAtKeyboardStart = reactNativeReanimated.useSharedValue(0);
+  const mode = reactNativeReanimated.useSharedValue("idle");
+  const keyboardInset = reactNativeReanimated.useSharedValue({ bottom: 0, top: 0 });
+  const keyboardHeight = reactNativeReanimated.useSharedValue(0);
+  const alignItemsAtEndPadding = reactNativeReanimated.useSharedValue(0);
+  const isOpening = reactNativeReanimated.useSharedValue(false);
+  const didInteractive = reactNativeReanimated.useSharedValue(false);
+  const { top: safeAreaInsetTop, bottom: safeAreaInsetBottom } = safeAreaInsets;
+  const isKeyboardOpen = reactNativeReanimated.useSharedValue(false);
+  const scrollHandler = reactNativeReanimated.useAnimatedScrollHandler(
+    (event) => {
+      scrollOffsetY.set(event.contentOffset[horizontal ? "x" : "y"]);
+      if (onScrollProp) {
+        reactNativeReanimated.runOnJS(onScrollProp)(event);
+      }
+    },
+    [onScrollProp, horizontal]
+  );
+  const setScrollProcessingEnabled = React.useCallback(
+    (enabled) => {
+      var _a;
+      return (_a = refLegendList.current) == null ? void 0 : _a.setScrollProcessingEnabled(enabled);
+    },
+    [refLegendList]
+  );
+  const handleMetricsChange = React.useCallback(
+    (metrics) => {
+      const nextPadding = metrics.alignItemsAtEndPadding || 0;
+      alignItemsAtEndPadding.set(nextPadding);
+      if (!horizontal) {
+        reactNativeReanimated.runOnUI((padding, safeInsetTop, isNewArchitecture) => {
+          "worklet";
+          if (!isKeyboardOpen.get()) {
+            return;
+          }
+          const vKeyboardHeight = keyboardHeight.get();
+          const vTopInset = calculateEndPaddingInset(vKeyboardHeight, padding);
+          const topInset = calculateTopInset(safeInsetTop, isNewArchitecture, vTopInset);
+          keyboardInset.set({
+            bottom: keyboardInset.get().bottom,
+            top: topInset
+          });
+        })(nextPadding, safeAreaInsetTop, IsNewArchitecture);
+      }
+      onMetricsChangeProp == null ? void 0 : onMetricsChangeProp(metrics);
+    },
+    [
+      alignItemsAtEndPadding,
+      horizontal,
+      isKeyboardOpen,
+      keyboardHeight,
+      keyboardInset,
+      onMetricsChangeProp,
+      safeAreaInsetTop
+    ]
+  );
+  reactNativeKeyboardController.useKeyboardHandler(
+    // biome-ignore assist/source/useSortedKeys: prefer start/move/end
+    {
+      onStart: (event) => {
+        "worklet";
+        mode.set("running");
+        const progress = clampProgress(event.progress);
+        if (isKeyboardOpen.get() && progress >= 1 && event.height > 0) {
+          return;
+        }
+        if (!didInteractive.get()) {
+          if (event.height > 0) {
+            keyboardHeight.set(event.height - safeAreaInsetBottom);
+          }
+          isOpening.set(progress > 0);
+          scrollOffsetAtKeyboardStart.set(scrollOffsetY.get());
+          animatedOffsetY.set(scrollOffsetY.get());
+          reactNativeReanimated.runOnJS(setScrollProcessingEnabled)(false);
+        }
+      },
+      onInteractive: (event) => {
+        "worklet";
+        if (mode.get() !== "running") {
+          reactNativeReanimated.runOnJS(setScrollProcessingEnabled)(false);
+        }
+        mode.set("running");
+        if (!didInteractive.get()) {
+          if (!isAndroid && !IsNewArchitecture) {
+            keyboardInset.set({
+              bottom: keyboardInset.get().bottom,
+              // Legacy iOS uses a doubled top inset to keep content below the status bar.
+              top: calculateTopInset(safeAreaInsetTop, IsNewArchitecture, 0)
+            });
+          }
+          didInteractive.set(true);
+        }
+        if (isAndroid && !horizontal) {
+          const newInset = calculateKeyboardInset(event.height, safeAreaInsetBottom, IsNewArchitecture);
+          keyboardInset.set({ bottom: newInset, top: safeAreaInsetTop * 2 });
+        }
+      },
+      onMove: (event) => {
+        "worklet";
+        if (!didInteractive.get()) {
+          const progress = clampProgress(event.progress);
+          const vIsOpening = isOpening.get();
+          const vKeyboardHeight = keyboardHeight.get();
+          const vAlignItemsPadding = alignItemsAtEndPadding.get();
+          const vTopInset = calculateEndPaddingInset(vKeyboardHeight, vAlignItemsPadding);
+          const targetOffset = calculateKeyboardTargetOffset(
+            scrollOffsetAtKeyboardStart.get(),
+            vKeyboardHeight,
+            vIsOpening,
+            progress
+          );
+          scrollOffsetY.set(targetOffset);
+          animatedOffsetY.set(targetOffset);
+          if (!horizontal) {
+            const newInset = calculateKeyboardInset(event.height, safeAreaInsetBottom, IsNewArchitecture);
+            const topInset = calculateTopInset(
+              safeAreaInsetTop,
+              IsNewArchitecture,
+              vIsOpening ? vTopInset : 0
+            );
+            keyboardInset.set({
+              bottom: newInset,
+              // Add top padding only while opening to keep end-aligned items visible.
+              top: topInset
+            });
+          }
+        }
+      },
+      onEnd: (event) => {
+        "worklet";
+        const wasInteractive = didInteractive.get();
+        const vMode = mode.get();
+        mode.set("idle");
+        if (vMode === "running") {
+          const progress = clampProgress(event.progress);
+          const vKeyboardHeight = keyboardHeight.get();
+          const vAlignItemsPadding = alignItemsAtEndPadding.get();
+          const vTopInset = calculateEndPaddingInset(vKeyboardHeight, vAlignItemsPadding);
+          const vIsOpening = isOpening.get();
+          if (!wasInteractive) {
+            const targetOffset = calculateKeyboardTargetOffset(
+              scrollOffsetAtKeyboardStart.get(),
+              vKeyboardHeight,
+              vIsOpening,
+              progress
+            );
+            scrollOffsetY.set(targetOffset);
+            animatedOffsetY.set(targetOffset);
+          }
+          reactNativeReanimated.runOnJS(setScrollProcessingEnabled)(true);
+          didInteractive.set(false);
+          isKeyboardOpen.set(event.height > 0);
+          if (!horizontal) {
+            const newInset = calculateKeyboardInset(event.height, safeAreaInsetBottom, IsNewArchitecture);
+            const topInset = calculateTopInset(
+              safeAreaInsetTop,
+              IsNewArchitecture,
+              event.height > 0 ? vTopInset : 0
+            );
+            keyboardInset.set({
+              bottom: newInset,
+              // Preserve end-aligned padding only while the keyboard is visible.
+              top: topInset
+            });
+            if (newInset <= 0) {
+              animatedOffsetY.set(scrollOffsetY.get());
+            }
+          }
+        }
+      }
+    },
+    [scrollViewRef, safeAreaInsetBottom]
+  );
+  const animatedProps = reactNativeReanimated.useAnimatedProps(() => {
+    "worklet";
+    var _a, _b, _c, _d;
+    const vAnimatedOffsetY = animatedOffsetY.get();
+    const baseProps = {
+      contentOffset: vAnimatedOffsetY === null ? void 0 : {
+        x: 0,
+        y: vAnimatedOffsetY
+      }
+    };
+    const { top: keyboardInsetTop, bottom: keyboardInsetBottom } = keyboardInset.get();
+    return isIos ? Object.assign(baseProps, {
+      contentInset: {
+        bottom: ((_a = contentInsetProp == null ? void 0 : contentInsetProp.bottom) != null ? _a : 0) + (horizontal ? 0 : keyboardInsetBottom),
+        left: (_b = contentInsetProp == null ? void 0 : contentInsetProp.left) != null ? _b : 0,
+        right: (_c = contentInsetProp == null ? void 0 : contentInsetProp.right) != null ? _c : 0,
+        top: ((_d = contentInsetProp == null ? void 0 : contentInsetProp.top) != null ? _d : 0) - keyboardInsetTop
+      }
+    }) : baseProps;
+  });
+  const style = isAndroid ? reactNativeReanimated.useAnimatedStyle(
+    () => {
+      var _a;
+      return {
+        ...styleFlattened || {},
+        marginBottom: (_a = keyboardInset.get().bottom) != null ? _a : 0
+      };
+    },
+    [styleProp, keyboardInset]
+  ) : void 0;
+  return /* @__PURE__ */ React__namespace.createElement(
+    reanimated.AnimatedLegendList,
+    {
+      ...rest,
+      animatedProps,
+      keyboardDismissMode: "interactive",
+      onMetricsChange: handleMetricsChange,
+      onScroll: scrollHandler,
+      ref: combinedRef,
+      refScrollView: scrollViewRef,
+      scrollIndicatorInsets: { bottom: 0, top: 0 },
+      style
+    }
+  );
+});
+
+exports.KeyboardAvoidingLegendList = KeyboardAvoidingLegendList;
+exports.LegendList = KeyboardAvoidingLegendList;