@legendapp/list 2.0.0-next.2 → 2.0.0-next.21

package/keyboard-controller.d.mts

@@ -0,0 +1,148 @@
+import * as _legendapp_list from '@legendapp/list';
+import { LegendList as LegendList$1, LegendListRef } from '@legendapp/list';
+import * as react_native from 'react-native';
+import * as React from 'react';
+import { AnimatedLegendList } from '@legendapp/list/animated';
+import { AnimatedLegendList as AnimatedLegendList$1 } from '@legendapp/list/reanimated';
+
+declare const LegendList: <ItemT, ListT extends typeof LegendList$1 | typeof AnimatedLegendList | typeof AnimatedLegendList$1 = (<T>(props: Omit<Omit<react_native.ScrollViewProps, "scrollEventThrottle">, "contentOffset" | "contentInset" | "maintainVisibleContentPosition" | "stickyHeaderIndices" | "removeClippedSubviews" | "children"> & {
+    alignItemsAtEnd?: boolean;
+    columnWrapperStyle?: _legendapp_list.ColumnWrapperStyle;
+    data: readonly T[];
+    drawDistance?: number;
+    estimatedItemSize?: number;
+    estimatedListSize?: {
+        height: number;
+        width: number;
+    };
+    extraData?: any;
+    getEstimatedItemSize?: ((index: number, item: T, type: string | undefined) => number) | undefined;
+    initialContainerPoolRatio?: number | undefined;
+    initialScrollOffset?: number;
+    initialScrollIndex?: number | {
+        index: number;
+        viewOffset?: number | undefined;
+        viewPosition?: number | undefined;
+    };
+    ItemSeparatorComponent?: React.ComponentType<{
+        leadingItem: T;
+    }> | undefined;
+    keyExtractor?: ((item: T, index: number) => string) | undefined;
+    ListEmptyComponent?: React.ComponentType<any> | React.ReactElement | null | undefined;
+    ListFooterComponent?: React.ComponentType<any> | React.ReactElement | null | undefined;
+    ListFooterComponentStyle?: react_native.StyleProp<react_native.ViewStyle> | undefined;
+    ListHeaderComponent?: React.ComponentType<any> | React.ReactElement | null | undefined;
+    ListHeaderComponentStyle?: react_native.StyleProp<react_native.ViewStyle> | undefined;
+    maintainScrollAtEnd?: boolean | _legendapp_list.MaintainScrollAtEndOptions;
+    maintainScrollAtEndThreshold?: number;
+    maintainVisibleContentPosition?: boolean;
+    numColumns?: number;
+    onEndReached?: ((info: {
+        distanceFromEnd: number;
+    }) => void) | null | undefined;
+    onEndReachedThreshold?: number | null | undefined;
+    onItemSizeChanged?: ((info: {
+        size: number;
+        previous: number;
+        index: number;
+        itemKey: string;
+        itemData: T;
+    }) => void) | undefined;
+    onRefresh?: () => void;
+    onStartReached?: ((info: {
+        distanceFromStart: number;
+    }) => void) | null | undefined;
+    onStartReachedThreshold?: number | null | undefined;
+    onViewableItemsChanged?: _legendapp_list.OnViewableItemsChanged | undefined;
+    progressViewOffset?: number;
+    recycleItems?: boolean;
+    refScrollView?: React.Ref<react_native.ScrollView>;
+    refreshing?: boolean;
+    renderItem?: ((props: _legendapp_list.LegendListRenderItemProps<T, string | undefined>) => React.ReactNode) | React.ComponentType<_legendapp_list.LegendListRenderItemProps<T, string | undefined>> | undefined;
+    renderScrollComponent?: (props: react_native.ScrollViewProps) => React.ReactElement<react_native.ScrollViewProps>;
+    suggestEstimatedItemSize?: boolean;
+    viewabilityConfig?: _legendapp_list.ViewabilityConfig;
+    viewabilityConfigCallbackPairs?: _legendapp_list.ViewabilityConfigCallbackPairs | undefined;
+    waitForInitialLayout?: boolean;
+    onLoad?: (info: {
+        elapsedTimeInMs: number;
+    }) => void;
+    snapToIndices?: number[];
+    stickyIndices?: number[];
+    getItemType?: ((item: T, index: number) => string | undefined) | undefined;
+    getFixedItemSize?: ((index: number, item: T, type: string | undefined) => number) | undefined;
+    itemsAreEqual?: ((itemPrevious: T, item: T, index: number, data: readonly T[]) => boolean) | undefined;
+} & React.RefAttributes<LegendListRef>) => React.ReactNode) & {
+    displayName?: string;
+}>(props: Omit<Omit<react_native.ScrollViewProps, "scrollEventThrottle">, "contentOffset" | "contentInset" | "maintainVisibleContentPosition" | "stickyHeaderIndices" | "removeClippedSubviews" | "children"> & {
+    alignItemsAtEnd?: boolean;
+    columnWrapperStyle?: _legendapp_list.ColumnWrapperStyle;
+    data: readonly ItemT[];
+    drawDistance?: number;
+    estimatedItemSize?: number;
+    estimatedListSize?: {
+        height: number;
+        width: number;
+    };
+    extraData?: any;
+    getEstimatedItemSize?: ((index: number, item: ItemT, type: string | undefined) => number) | undefined;
+    initialContainerPoolRatio?: number | undefined;
+    initialScrollOffset?: number;
+    initialScrollIndex?: number | {
+        index: number;
+        viewOffset?: number | undefined;
+        viewPosition?: number | undefined;
+    };
+    ItemSeparatorComponent?: React.ComponentType<{
+        leadingItem: ItemT;
+    }> | undefined;
+    keyExtractor?: ((item: ItemT, index: number) => string) | undefined;
+    ListEmptyComponent?: React.ComponentType<any> | React.ReactElement | null | undefined;
+    ListFooterComponent?: React.ComponentType<any> | React.ReactElement | null | undefined;
+    ListFooterComponentStyle?: react_native.StyleProp<react_native.ViewStyle> | undefined;
+    ListHeaderComponent?: React.ComponentType<any> | React.ReactElement | null | undefined;
+    ListHeaderComponentStyle?: react_native.StyleProp<react_native.ViewStyle> | undefined;
+    maintainScrollAtEnd?: boolean | _legendapp_list.MaintainScrollAtEndOptions;
+    maintainScrollAtEndThreshold?: number;
+    maintainVisibleContentPosition?: boolean;
+    numColumns?: number;
+    onEndReached?: ((info: {
+        distanceFromEnd: number;
+    }) => void) | null | undefined;
+    onEndReachedThreshold?: number | null | undefined;
+    onItemSizeChanged?: ((info: {
+        size: number;
+        previous: number;
+        index: number;
+        itemKey: string;
+        itemData: ItemT;
+    }) => void) | undefined;
+    onRefresh?: () => void;
+    onStartReached?: ((info: {
+        distanceFromStart: number;
+    }) => void) | null | undefined;
+    onStartReachedThreshold?: number | null | undefined;
+    onViewableItemsChanged?: _legendapp_list.OnViewableItemsChanged | undefined;
+    progressViewOffset?: number;
+    recycleItems?: boolean;
+    refScrollView?: React.Ref<react_native.ScrollView>;
+    refreshing?: boolean;
+    renderItem?: ((props: _legendapp_list.LegendListRenderItemProps<ItemT, string | undefined>) => React.ReactNode) | React.ComponentType<_legendapp_list.LegendListRenderItemProps<ItemT, string | undefined>> | undefined;
+    renderScrollComponent?: (props: react_native.ScrollViewProps) => React.ReactElement<react_native.ScrollViewProps>;
+    suggestEstimatedItemSize?: boolean;
+    viewabilityConfig?: _legendapp_list.ViewabilityConfig;
+    viewabilityConfigCallbackPairs?: _legendapp_list.ViewabilityConfigCallbackPairs | undefined;
+    waitForInitialLayout?: boolean;
+    onLoad?: (info: {
+        elapsedTimeInMs: number;
+    }) => void;
+    snapToIndices?: number[];
+    stickyIndices?: number[];
+    getItemType?: ((item: ItemT, index: number) => string | undefined) | undefined;
+    getFixedItemSize?: ((index: number, item: ItemT, type: string | undefined) => number) | undefined;
+    itemsAreEqual?: ((itemPrevious: ItemT, item: ItemT, index: number, data: readonly ItemT[]) => boolean) | undefined;
+} & {
+    LegendList?: ListT;
+} & React.RefAttributes<LegendListRef>) => React.ReactNode;
+
+export { LegendList };

package/keyboard-controller.d.ts

@@ -0,0 +1,148 @@
+import * as _legendapp_list from '@legendapp/list';
+import { LegendList as LegendList$1, LegendListRef } from '@legendapp/list';
+import * as react_native from 'react-native';
+import * as React from 'react';
+import { AnimatedLegendList } from '@legendapp/list/animated';
+import { AnimatedLegendList as AnimatedLegendList$1 } from '@legendapp/list/reanimated';
+
+declare const LegendList: <ItemT, ListT extends typeof LegendList$1 | typeof AnimatedLegendList | typeof AnimatedLegendList$1 = (<T>(props: Omit<Omit<react_native.ScrollViewProps, "scrollEventThrottle">, "contentOffset" | "contentInset" | "maintainVisibleContentPosition" | "stickyHeaderIndices" | "removeClippedSubviews" | "children"> & {
+    alignItemsAtEnd?: boolean;
+    columnWrapperStyle?: _legendapp_list.ColumnWrapperStyle;
+    data: readonly T[];
+    drawDistance?: number;
+    estimatedItemSize?: number;
+    estimatedListSize?: {
+        height: number;
+        width: number;
+    };
+    extraData?: any;
+    getEstimatedItemSize?: ((index: number, item: T, type: string | undefined) => number) | undefined;
+    initialContainerPoolRatio?: number | undefined;
+    initialScrollOffset?: number;
+    initialScrollIndex?: number | {
+        index: number;
+        viewOffset?: number | undefined;
+        viewPosition?: number | undefined;
+    };
+    ItemSeparatorComponent?: React.ComponentType<{
+        leadingItem: T;
+    }> | undefined;
+    keyExtractor?: ((item: T, index: number) => string) | undefined;
+    ListEmptyComponent?: React.ComponentType<any> | React.ReactElement | null | undefined;
+    ListFooterComponent?: React.ComponentType<any> | React.ReactElement | null | undefined;
+    ListFooterComponentStyle?: react_native.StyleProp<react_native.ViewStyle> | undefined;
+    ListHeaderComponent?: React.ComponentType<any> | React.ReactElement | null | undefined;
+    ListHeaderComponentStyle?: react_native.StyleProp<react_native.ViewStyle> | undefined;
+    maintainScrollAtEnd?: boolean | _legendapp_list.MaintainScrollAtEndOptions;
+    maintainScrollAtEndThreshold?: number;
+    maintainVisibleContentPosition?: boolean;
+    numColumns?: number;
+    onEndReached?: ((info: {
+        distanceFromEnd: number;
+    }) => void) | null | undefined;
+    onEndReachedThreshold?: number | null | undefined;
+    onItemSizeChanged?: ((info: {
+        size: number;
+        previous: number;
+        index: number;
+        itemKey: string;
+        itemData: T;
+    }) => void) | undefined;
+    onRefresh?: () => void;
+    onStartReached?: ((info: {
+        distanceFromStart: number;
+    }) => void) | null | undefined;
+    onStartReachedThreshold?: number | null | undefined;
+    onViewableItemsChanged?: _legendapp_list.OnViewableItemsChanged | undefined;
+    progressViewOffset?: number;
+    recycleItems?: boolean;
+    refScrollView?: React.Ref<react_native.ScrollView>;
+    refreshing?: boolean;
+    renderItem?: ((props: _legendapp_list.LegendListRenderItemProps<T, string | undefined>) => React.ReactNode) | React.ComponentType<_legendapp_list.LegendListRenderItemProps<T, string | undefined>> | undefined;
+    renderScrollComponent?: (props: react_native.ScrollViewProps) => React.ReactElement<react_native.ScrollViewProps>;
+    suggestEstimatedItemSize?: boolean;
+    viewabilityConfig?: _legendapp_list.ViewabilityConfig;
+    viewabilityConfigCallbackPairs?: _legendapp_list.ViewabilityConfigCallbackPairs | undefined;
+    waitForInitialLayout?: boolean;
+    onLoad?: (info: {
+        elapsedTimeInMs: number;
+    }) => void;
+    snapToIndices?: number[];
+    stickyIndices?: number[];
+    getItemType?: ((item: T, index: number) => string | undefined) | undefined;
+    getFixedItemSize?: ((index: number, item: T, type: string | undefined) => number) | undefined;
+    itemsAreEqual?: ((itemPrevious: T, item: T, index: number, data: readonly T[]) => boolean) | undefined;
+} & React.RefAttributes<LegendListRef>) => React.ReactNode) & {
+    displayName?: string;
+}>(props: Omit<Omit<react_native.ScrollViewProps, "scrollEventThrottle">, "contentOffset" | "contentInset" | "maintainVisibleContentPosition" | "stickyHeaderIndices" | "removeClippedSubviews" | "children"> & {
+    alignItemsAtEnd?: boolean;
+    columnWrapperStyle?: _legendapp_list.ColumnWrapperStyle;
+    data: readonly ItemT[];
+    drawDistance?: number;
+    estimatedItemSize?: number;
+    estimatedListSize?: {
+        height: number;
+        width: number;
+    };
+    extraData?: any;
+    getEstimatedItemSize?: ((index: number, item: ItemT, type: string | undefined) => number) | undefined;
+    initialContainerPoolRatio?: number | undefined;
+    initialScrollOffset?: number;
+    initialScrollIndex?: number | {
+        index: number;
+        viewOffset?: number | undefined;
+        viewPosition?: number | undefined;
+    };
+    ItemSeparatorComponent?: React.ComponentType<{
+        leadingItem: ItemT;
+    }> | undefined;
+    keyExtractor?: ((item: ItemT, index: number) => string) | undefined;
+    ListEmptyComponent?: React.ComponentType<any> | React.ReactElement | null | undefined;
+    ListFooterComponent?: React.ComponentType<any> | React.ReactElement | null | undefined;
+    ListFooterComponentStyle?: react_native.StyleProp<react_native.ViewStyle> | undefined;
+    ListHeaderComponent?: React.ComponentType<any> | React.ReactElement | null | undefined;
+    ListHeaderComponentStyle?: react_native.StyleProp<react_native.ViewStyle> | undefined;
+    maintainScrollAtEnd?: boolean | _legendapp_list.MaintainScrollAtEndOptions;
+    maintainScrollAtEndThreshold?: number;
+    maintainVisibleContentPosition?: boolean;
+    numColumns?: number;
+    onEndReached?: ((info: {
+        distanceFromEnd: number;
+    }) => void) | null | undefined;
+    onEndReachedThreshold?: number | null | undefined;
+    onItemSizeChanged?: ((info: {
+        size: number;
+        previous: number;
+        index: number;
+        itemKey: string;
+        itemData: ItemT;
+    }) => void) | undefined;
+    onRefresh?: () => void;
+    onStartReached?: ((info: {
+        distanceFromStart: number;
+    }) => void) | null | undefined;
+    onStartReachedThreshold?: number | null | undefined;
+    onViewableItemsChanged?: _legendapp_list.OnViewableItemsChanged | undefined;
+    progressViewOffset?: number;
+    recycleItems?: boolean;
+    refScrollView?: React.Ref<react_native.ScrollView>;
+    refreshing?: boolean;
+    renderItem?: ((props: _legendapp_list.LegendListRenderItemProps<ItemT, string | undefined>) => React.ReactNode) | React.ComponentType<_legendapp_list.LegendListRenderItemProps<ItemT, string | undefined>> | undefined;
+    renderScrollComponent?: (props: react_native.ScrollViewProps) => React.ReactElement<react_native.ScrollViewProps>;
+    suggestEstimatedItemSize?: boolean;
+    viewabilityConfig?: _legendapp_list.ViewabilityConfig;
+    viewabilityConfigCallbackPairs?: _legendapp_list.ViewabilityConfigCallbackPairs | undefined;
+    waitForInitialLayout?: boolean;
+    onLoad?: (info: {
+        elapsedTimeInMs: number;
+    }) => void;
+    snapToIndices?: number[];
+    stickyIndices?: number[];
+    getItemType?: ((item: ItemT, index: number) => string | undefined) | undefined;
+    getFixedItemSize?: ((index: number, item: ItemT, type: string | undefined) => number) | undefined;
+    itemsAreEqual?: ((itemPrevious: ItemT, item: ItemT, index: number, data: readonly ItemT[]) => boolean) | undefined;
+} & {
+    LegendList?: ListT;
+} & React.RefAttributes<LegendListRef>) => React.ReactNode;
+
+export { LegendList };

package/{dist/keyboard-controller.js → keyboard-controller.js}

@@ -1,10 +1,10 @@
 'use strict';
 
-var list = require('@legendapp/list');
 var React = require('react');
 var reactNative = require('react-native');
 var reactNativeKeyboardController = require('react-native-keyboard-controller');
 var reactNativeReanimated = require('react-native-reanimated');
+var list = require('@legendapp/list');
 
 function _interopNamespace(e) {
   if (e && e.__esModule) return e;
@@ -26,7 +26,7 @@ function _interopNamespace(e) {
 
 var React__namespace = /*#__PURE__*/_interopNamespace(React);
 
-// src/keyboard-controller.tsx
+// src/integrations/keyboard-controller.tsx
 var typedForwardRef = React.forwardRef;
 var LegendList = typedForwardRef(function LegendList2(props, forwardedRef) {
   const {
@@ -59,8 +59,8 @@ var LegendList = typedForwardRef(function LegendList2(props, forwardedRef) {
       {
         ...rest,
         contentContainerStyle,
-        scrollIndicatorInsets,
-        ref: forwardedRef
+        ref: forwardedRef,
+        scrollIndicatorInsets
       }
     )
   );

package/{dist/keyboard-controller.mjs → keyboard-controller.mjs}

@@ -1,11 +1,11 @@
-import { LegendList as LegendList$1 } from '@legendapp/list';
 import * as React from 'react';
 import { useState, forwardRef } from 'react';
 import { StyleSheet } from 'react-native';
 import { useKeyboardHandler } from 'react-native-keyboard-controller';
 import { runOnJS } from 'react-native-reanimated';
+import { LegendList as LegendList$1 } from '@legendapp/list';
 
-// src/keyboard-controller.tsx
+// src/integrations/keyboard-controller.tsx
 var typedForwardRef = forwardRef;
 var LegendList = typedForwardRef(function LegendList2(props, forwardedRef) {
   const {
@@ -38,8 +38,8 @@ var LegendList = typedForwardRef(function LegendList2(props, forwardedRef) {
       {
         ...rest,
         contentContainerStyle,
-        scrollIndicatorInsets,
-        ref: forwardedRef
+        ref: forwardedRef,
+        scrollIndicatorInsets
       }
     )
   );

package/package.json

@@ -1,89 +1,35 @@
 {
-    "name": "@legendapp/list",
-    "version": "2.0.0-next.2",
-    "description": "Legend List is a drop-in replacement for FlatList with much better performance and supporting dynamically sized items.",
-    "sideEffects": false,
-    "private": false,
-    "main": "./index.js",
-    "module": "./index.mjs",
-    "types": "./index.d.ts",
-    "files": [
-        "**"
-    ],
-    "exports": {
-        "./package.json": "./package.json",
-        ".": {
-            "types": "./index.d.ts",
-            "import": "./index.mjs",
-            "require": "./index.js"
-        },
-        "./animated": {
-            "types": "./animated.d.ts",
-            "import": "./animated.mjs",
-            "require": "./animated.js"
-        },
-        "./reanimated": {
-            "types": "./reanimated.d.ts",
-            "import": "./reanimated.mjs",
-            "require": "./reanimated.js"
-        },
-        "./keyboard-controller": {
-            "types": "./keyboard-controller.d.ts",
-            "import": "./keyboard-controller.mjs",
-            "require": "./keyboard-controller.js"
-        }
-    },
-    "engines": {
-        "node": ">=16.6.0",
-        "npm": ">=8.11.0"
-    },
-    "scripts": {
-        "build": "tsup && bun run posttsup.ts",
-        "publish": "bun run build && cd dist && npm publish",
-        "publish:next": "bun run build && cd dist && npm publish --tag next",
-        "publish:beta": "bun run build && cd dist && npm publish --tag beta",
-        "lint": "bunx biome check ./src && bunx biome format ./src && bun run lint:example",
-        "lint:example": "bunx biome check ./example/app && bunx biome format ./example/app",
-        "lint:fix": "bunx biome lint --write ./src && bunx biome format --write ./src && bunx biome check --write ./src && bun run lint:fix:example",
-        "lint:fix:example": "bunx biome lint --write ./example/app && bunx biome format --write ./example/app && bunx biome check --write ./example/app"
-    },
-    "peerDependencies": {
-        "react": "*",
-        "react-native": "*"
-    },
-    "devDependencies": {
-        "@biomejs/biome": "^1.9.4",
-        "@types/bun": "^1.1.13",
-        "@types/react": "^18.3.12",
-        "@types/use-sync-external-store": "^1.5.0",
-        "react": "^18.3.1",
-        "react-native": "^0.76.2",
-        "react-native-keyboard-controller": "^1.17.0",
-        "react-native-reanimated": "^3.16.6",
-        "tsup": "^8.3.5",
-        "typescript": "^5.8.3"
-    },
-    "author": "Legend <contact@legendapp.com> (https://github.com/LegendApp)",
-    "keywords": [
-        "react",
-        "react-native",
-        "list"
-    ],
-    "repository": "github:LegendApp/legend-list",
-    "license": "MIT",
-    "bugs": {
-        "url": "https://github.com/LegendApp/legend-list/issues"
-    },
-    "homepage": "https://github.com/LegendApp/legend-list#readme",
-    "publishConfig": {
-        "registry": "https://registry.npmjs.org/"
-    },
-    "commitlint": {
-        "extends": [
-            "@commitlint/config-conventional"
-        ]
-    },
-    "dependencies": {
-        "use-sync-external-store": "^1.5.0"
-    }
-}
+  "name": "@legendapp/list",
+  "version": "2.0.0-next.21",
+  "description": "Legend List is a drop-in replacement for FlatList with much better performance and supporting dynamically sized items.",
+  "sideEffects": false,
+  "private": false,
+  "main": "./index.js",
+  "module": "./index.mjs",
+  "types": "./index.d.ts",
+  "files": [
+    "**"
+  ],
+  "peerDependencies": {
+    "react": "*",
+    "react-native": "*"
+  },
+  "author": "Legend <contact@legendapp.com> (https://github.com/LegendApp)",
+  "keywords": [
+    "react",
+    "react-native",
+    "list"
+  ],
+  "repository": "github:LegendApp/legend-list",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/LegendApp/legend-list/issues"
+  },
+  "homepage": "https://github.com/LegendApp/legend-list#readme",
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/"
+  },
+  "dependencies": {
+    "use-sync-external-store": "^1.5.0"
+  }
+}

package/{dist/reanimated.d.mts → reanimated.d.mts}

@@ -1,8 +1,8 @@
-import { LegendListPropsBase, LegendListRef } from '@legendapp/list';
 import React__default, { ComponentProps } from 'react';
 import Animated from 'react-native-reanimated';
+import { LegendListPropsBase, LegendListRef } from '@legendapp/list';
 
-type KeysToOmit = "getEstimatedItemSize" | "keyExtractor" | "animatedProps" | "renderItem" | "onItemSizeChanged" | "ItemSeparatorComponent";
+type KeysToOmit = "getEstimatedItemSize" | "getFixedItemSize" | "getItemType" | "keyExtractor" | "animatedProps" | "renderItem" | "onItemSizeChanged" | "itemsAreEqual" | "ItemSeparatorComponent";
 type PropsBase<ItemT> = LegendListPropsBase<ItemT, ComponentProps<typeof Animated.ScrollView>>;
 interface AnimatedLegendListPropsBase<ItemT> extends Omit<PropsBase<ItemT>, KeysToOmit> {
     refScrollView?: React__default.Ref<Animated.ScrollView>;

package/{dist/reanimated.d.ts → reanimated.d.ts}

@@ -1,8 +1,8 @@
-import { LegendListPropsBase, LegendListRef } from '@legendapp/list';
 import React__default, { ComponentProps } from 'react';
 import Animated from 'react-native-reanimated';
+import { LegendListPropsBase, LegendListRef } from '@legendapp/list';
 
-type KeysToOmit = "getEstimatedItemSize" | "keyExtractor" | "animatedProps" | "renderItem" | "onItemSizeChanged" | "ItemSeparatorComponent";
+type KeysToOmit = "getEstimatedItemSize" | "getFixedItemSize" | "getItemType" | "keyExtractor" | "animatedProps" | "renderItem" | "onItemSizeChanged" | "itemsAreEqual" | "ItemSeparatorComponent";
 type PropsBase<ItemT> = LegendListPropsBase<ItemT, ComponentProps<typeof Animated.ScrollView>>;
 interface AnimatedLegendListPropsBase<ItemT> extends Omit<PropsBase<ItemT>, KeysToOmit> {
     refScrollView?: React__default.Ref<Animated.ScrollView>;

package/reanimated.js

@@ -0,0 +1,60 @@
+'use strict';
+
+var React = require('react');
+var Animated = require('react-native-reanimated');
+var list = require('@legendapp/list');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var React__default = /*#__PURE__*/_interopDefault(React);
+var Animated__default = /*#__PURE__*/_interopDefault(Animated);
+
+// src/integrations/reanimated.tsx
+
+// 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/reanimated.tsx
+var typedMemo = React.memo;
+var LegendListForwardedRef = typedMemo(
+  React__default.default.forwardRef(function LegendListForwardedRef2(props, ref) {
+    const { refLegendList, ...rest } = props;
+    const refFn = React.useCallback(
+      (r) => {
+        refLegendList(r);
+      },
+      [refLegendList]
+    );
+    return /* @__PURE__ */ React__default.default.createElement(list.LegendList, { ref: refFn, refScrollView: ref, ...rest });
+  })
+);
+var AnimatedLegendListComponent = Animated__default.default.createAnimatedComponent(LegendListForwardedRef);
+var AnimatedLegendList = typedMemo(
+  React__default.default.forwardRef(function AnimatedLegendList2(props, ref) {
+    const { refScrollView, ...rest } = props;
+    const refLegendList = React__default.default.useRef(null);
+    const combinedRef = useCombinedRef(refLegendList, ref);
+    return /* @__PURE__ */ React__default.default.createElement(AnimatedLegendListComponent, { ref: refScrollView, refLegendList: combinedRef, ...rest });
+  })
+);
+
+exports.AnimatedLegendList = AnimatedLegendList;

package/reanimated.mjs

@@ -0,0 +1,53 @@
+import React, { useCallback, memo } from 'react';
+import Animated from 'react-native-reanimated';
+import { LegendList } from '@legendapp/list';
+
+// src/integrations/reanimated.tsx
+
+// 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/reanimated.tsx
+var typedMemo = memo;
+var LegendListForwardedRef = typedMemo(
+  React.forwardRef(function LegendListForwardedRef2(props, ref) {
+    const { refLegendList, ...rest } = props;
+    const refFn = useCallback(
+      (r) => {
+        refLegendList(r);
+      },
+      [refLegendList]
+    );
+    return /* @__PURE__ */ React.createElement(LegendList, { ref: refFn, refScrollView: ref, ...rest });
+  })
+);
+var AnimatedLegendListComponent = Animated.createAnimatedComponent(LegendListForwardedRef);
+var AnimatedLegendList = typedMemo(
+  React.forwardRef(function AnimatedLegendList2(props, ref) {
+    const { refScrollView, ...rest } = props;
+    const refLegendList = React.useRef(null);
+    const combinedRef = useCombinedRef(refLegendList, ref);
+    return /* @__PURE__ */ React.createElement(AnimatedLegendListComponent, { ref: refScrollView, refLegendList: combinedRef, ...rest });
+  })
+);
+
+export { AnimatedLegendList };

package/.claude/settings.local.json

@@ -1,8 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "Bash(bun run:*)"
-    ],
-    "deny": []
-  }
-}