@souscheflabs/reanimated-flashlist 0.5.0 → 0.5.1

package/lib/AnimatedFlashList.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AnimatedFlashList.d.ts","sourceRoot":"","sources":["../src/AnimatedFlashList.tsx"],"names":[],"mappings":"AAAA,OAAO,KASN,MAAM,OAAO,CAAC;AA2Bf,OAAO,KAAK,EACV,gBAAgB,EAChB,sBAAsB,EACtB,oBAAoB,EAErB,MAAM,SAAS,CAAC;AA65BjB,eAAO,MAAM,iBAAiB,EAAyC,CACrE,CAAC,SAAS,gBAAgB,EAE1B,KAAK,EAAE,sBAAsB,CAAC,CAAC,CAAC,GAAG;IACjC,GAAG,CAAC,EAAE,KAAK,CAAC,YAAY,CAAC,oBAAoB,CAAC,CAAC;CAChD,KACE,KAAK,CAAC,YAAY,GAAG,IAAI,CAAC"}
+{"version":3,"file":"AnimatedFlashList.d.ts","sourceRoot":"","sources":["../src/AnimatedFlashList.tsx"],"names":[],"mappings":"AAAA,OAAO,KASN,MAAM,OAAO,CAAC;AA2Bf,OAAO,KAAK,EACV,gBAAgB,EAChB,sBAAsB,EACtB,oBAAoB,EAErB,MAAM,SAAS,CAAC;AA85BjB,eAAO,MAAM,iBAAiB,EAAyC,CACrE,CAAC,SAAS,gBAAgB,EAE1B,KAAK,EAAE,sBAAsB,CAAC,CAAC,CAAC,GAAG;IACjC,GAAG,CAAC,EAAE,KAAK,CAAC,YAAY,CAAC,oBAAoB,CAAC,CAAC;CAChD,KACE,KAAK,CAAC,YAAY,GAAG,IAAI,CAAC"}

package/lib/AnimatedFlashList.js

@@ -525,6 +525,7 @@ function AnimatedFlashListInner(props, ref) {
 }
 const containerStyle = {
     flex: 1,
+    overflow: 'hidden',
 };
 // Forward ref with generic support
 exports.AnimatedFlashList = (0, react_1.forwardRef)(AnimatedFlashListInner);

package/lib/hooks/drag/useDragGesture.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useDragGesture.d.ts","sourceRoot":"","sources":["../../../src/hooks/drag/useDragGesture.ts"],"names":[],"mappings":"AA+BA,OAAO,KAAK,EACV,oBAAoB,EACpB,uBAAuB,EACvB,oBAAoB,EACrB,MAAM,aAAa,CAAC;AAErB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,cAAc,CAC5B,MAAM,EAAE,oBAAoB,EAC5B,SAAS,EAAE,uBAAuB,GACjC,oBAAoB,CA+atB"}
+{"version":3,"file":"useDragGesture.d.ts","sourceRoot":"","sources":["../../../src/hooks/drag/useDragGesture.ts"],"names":[],"mappings":"AA+BA,OAAO,KAAK,EACV,oBAAoB,EACpB,uBAAuB,EACvB,oBAAoB,EACrB,MAAM,aAAa,CAAC;AAErB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,cAAc,CAC5B,MAAM,EAAE,oBAAoB,EAC5B,SAAS,EAAE,uBAAuB,GACjC,oBAAoB,CA8atB"}

package/lib/hooks/drag/useDragGesture.js

@@ -188,9 +188,9 @@ function useDragGesture(config, callbacks) {
             lastSignificantY.value = event.translationY;
         }
         // Track hovered index
-        const itemHeight = measuredItemHeight.value > 0
-            ? measuredItemHeight.value
-            : dragConfig.itemHeight;
+        // Always use config.itemHeight - it includes margins which matches
+        // how FlashList positions items. See useDragShift.ts v40.9 comment.
+        const itemHeight = dragConfig.itemHeight;
         const scrollDelta = scrollOffset.value - dragStartScrollOffset.value;
         const effectiveTranslateY = event.translationY + scrollDelta;
         const hoverResult = (0, hoverCalculation_1.calculateHoverIndex)({
@@ -216,9 +216,8 @@ function useDragGesture(config, callbacks) {
         draggedScale.value = (0, react_native_reanimated_1.withSpring)(1, drag_1.SPRING_CONFIGS.DRAG_SCALE);
         const currentIdx = draggedIndex.value;
         const total = totalItems.value;
-        const itemHeight = measuredItemHeight.value > 0
-            ? measuredItemHeight.value
-            : dragConfig.itemHeight;
+        // Always use config.itemHeight for drop calculation to match FlashList positioning
+        const itemHeight = dragConfig.itemHeight;
         const prevHoveredIndex = hoveredIndex.value;
         // Use shared drop calculation utility
         const hoveredIndexAtEnd = prevHoveredIndex >= 0

package/lib/hooks/drag/useDragOverlay.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useDragOverlay.d.ts","sourceRoot":"","sources":["../../../src/hooks/drag/useDragOverlay.ts"],"names":[],"mappings":"AACA,OAAO,EAEL,KAAK,WAAW,EACjB,MAAM,yBAAyB,CAAC;AACjC,OAAO,KAAK,QAAQ,MAAM,yBAAyB,CAAC;AAGpD;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,oCAAoC;IACpC,YAAY,EAAE,WAAW,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;CAC1C;AAED;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,wCAAwC;IACxC,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC;;;;;;OAMG;IACH,sBAAsB,EAAE,CAAC,KAAK,EAAE,iBAAiB,KAAK,MAAM,CAAC;CAC9D;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,cAAc,CAC5B,MAAM,EAAE,oBAAoB,GAC3B,oBAAoB,CAmFtB"}
+{"version":3,"file":"useDragOverlay.d.ts","sourceRoot":"","sources":["../../../src/hooks/drag/useDragOverlay.ts"],"names":[],"mappings":"AACA,OAAO,EAEL,KAAK,WAAW,EACjB,MAAM,yBAAyB,CAAC;AACjC,OAAO,KAAK,QAAQ,MAAM,yBAAyB,CAAC;AAGpD;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,oCAAoC;IACpC,YAAY,EAAE,WAAW,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;CAC1C;AAED;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,wCAAwC;IACxC,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC;;;;;;OAMG;IACH,sBAAsB,EAAE,CAAC,KAAK,EAAE,iBAAiB,KAAK,MAAM,CAAC;CAC9D;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,cAAc,CAC5B,MAAM,EAAE,oBAAoB,GAC3B,oBAAoB,CA+FtB"}

package/lib/hooks/drag/useDragOverlay.js

@@ -23,7 +23,7 @@ const DragStateContext_1 = require("../../contexts/DragStateContext");
  */
 function useDragOverlay(config) {
     const { containerRef } = config;
-    const { overlayBaseX, overlayBaseY, overlayWidth, overlayHeight, overlayActive, overlayReady, overlayTouchOffset, overlayAbsoluteY, overlayContainerX, overlayContainerY, overlayContainerReady, dragContainerRef, } = (0, DragStateContext_1.useDragState)();
+    const { overlayBaseX, overlayBaseY, overlayWidth, overlayHeight, overlayActive, overlayReady, overlayTouchOffset, overlayAbsoluteY, overlayContainerX, overlayContainerY, overlayContainerReady, dragContainerRef, config: dragConfig, } = (0, DragStateContext_1.useDragState)();
     const measureAndSetupOverlay = (0, react_1.useCallback)((input) => {
         'worklet';
         const { absoluteY } = input;
@@ -61,6 +61,13 @@ function useDragOverlay(config) {
             overlayHeight.value = measured.height;
             overlayActive.value = true;
             overlayReady.value = true;
+            // DEV: Warn if itemHeight config is smaller than measured content
+            // This always indicates misconfiguration since config should include margins
+            if (__DEV__ && measured.height > dragConfig.itemHeight) {
+                console.warn(`[AnimatedFlashList] itemHeight (${dragConfig.itemHeight}px) is smaller than ` +
+                    `measured item content (${measured.height.toFixed(0)}px). ` +
+                    `Configure itemHeight to include margins/gaps for accurate drag positioning.`);
+            }
             return measured.height;
         }
         else {
@@ -82,6 +89,7 @@ function useDragOverlay(config) {
         overlayContainerY,
         overlayContainerReady,
         dragContainerRef,
+        dragConfig,
     ]);
     return { measureAndSetupOverlay };
 }

package/lib/hooks/drag/useDropCompensation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useDropCompensation.d.ts","sourceRoot":"","sources":["../../../src/hooks/drag/useDropCompensation.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,aAAa,CAAC;AAE7D;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,yBAAyB,GAAG,IAAI,CAgF3E"}
+{"version":3,"file":"useDropCompensation.d.ts","sourceRoot":"","sources":["../../../src/hooks/drag/useDropCompensation.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,aAAa,CAAC;AAE7D;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,yBAAyB,GAAG,IAAI,CA8E3E"}

package/lib/hooks/drag/useDropCompensation.js

@@ -57,9 +57,8 @@ function useDropCompensation(config) {
                 return;
             }
             // Outside active drag/drop, compensate for index change
-            const itemHeight = measuredItemHeight.value > 0
-                ? measuredItemHeight.value
-                : dragConfig.itemHeight;
+            // Always use config.itemHeight - matches FlashList positioning (includes margins)
+            const itemHeight = dragConfig.itemHeight;
             const indexDelta = index - prevIndex;
             const heightDelta = indexDelta * itemHeight;
             const compensatedY = translateY.value - heightDelta;

package/lib/index.d.ts

@@ -53,4 +53,26 @@ export { useDragGesture, useDragShift, useDragAnimatedStyle, useDropCompensation
 export { DEFAULT_DRAG_CONFIG, createDragConfig, DEFAULT_EXIT_ANIMATION, FAST_EXIT_ANIMATION, DEFAULT_ENTRY_ANIMATION, getExitAnimationConfig, createEntryAnimationConfig, standardEasing, } from './constants';
 export type { AnimatedListItem, AnimatedFlashListProps, AnimatedFlashListRef, AnimatedFlashListConfig, AnimatedRenderItemInfo, DragHandleProps, DragConfig, UseDragGestureConfig, UseDragGestureCallbacks, UseDragGestureResult, UseDragShiftConfig, UseDragShiftResult, UseDropCompensationConfig, UseDragAnimatedStyleResult, AnimationDirection, ExitAnimationPreset, ExitAnimationConfig, EntryAnimationConfig, PendingEntryAnimation, ExitAnimationTrigger, HapticFeedbackType, } from './types';
 export type { DragStateContextValue, ListAnimationContextValue, } from './contexts';
+/**
+ * Performance monitoring hooks and utilities.
+ * @internal These are intended for benchmarking and development purposes.
+ * Only available in __DEV__ mode for production builds.
+ *
+ * @example
+ * ```tsx
+ * import {
+ *   useFPSMonitor,
+ *   useRenderProfiler,
+ *   useMemoryMonitor,
+ * } from '@souscheflabs/reanimated-flashlist';
+ *
+ * // Use in development/benchmark builds only
+ * if (__DEV__) {
+ *   const fps = useFPSMonitor();
+ *   fps.start();
+ * }
+ * ```
+ */
+export { useFPSMonitor, useRenderProfiler, useMemoryMonitor, } from './performance';
+export type { FPSMetrics, RenderMetrics, MemoryMetrics, BenchmarkResult, BaselineData, ScenarioMetrics, ComparisonResult, ComparisonDetail, ComparisonThresholds, FPSMonitorConfig, MemoryMonitorConfig, BenchmarkScenario, } from './performance';
 //# sourceMappingURL=index.d.ts.map

package/lib/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAGH,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AACxD,OAAO,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAIhE,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAEnD;;;;;GAKG;AACH,OAAO,EACL,iBAAiB,EACjB,YAAY,EACZ,qBAAqB,EACrB,gBAAgB,EAChB,wBAAwB,GACzB,MAAM,YAAY,CAAC;AAEpB;;;;;;GAMG;AACH,OAAO,EAEL,cAAc,EACd,YAAY,EACZ,oBAAoB,EACpB,mBAAmB,EAEnB,oBAAoB,EACpB,qBAAqB,GACtB,MAAM,SAAS,CAAC;AAGjB,OAAO,EACL,mBAAmB,EACnB,gBAAgB,EAChB,sBAAsB,EACtB,mBAAmB,EACnB,uBAAuB,EACvB,sBAAsB,EACtB,0BAA0B,EAC1B,cAAc,GACf,MAAM,aAAa,CAAC;AAGrB,YAAY,EAEV,gBAAgB,EAChB,sBAAsB,EACtB,oBAAoB,EACpB,uBAAuB,EACvB,sBAAsB,EACtB,eAAe,EAEf,UAAU,EACV,oBAAoB,EACpB,uBAAuB,EACvB,oBAAoB,EACpB,kBAAkB,EAClB,kBAAkB,EAClB,yBAAyB,EACzB,0BAA0B,EAE1B,kBAAkB,EAClB,mBAAmB,EACnB,mBAAmB,EACnB,oBAAoB,EACpB,qBAAqB,EACrB,oBAAoB,EACpB,kBAAkB,GACnB,MAAM,SAAS,CAAC;AAGjB,YAAY,EACV,qBAAqB,EACrB,yBAAyB,GAC1B,MAAM,YAAY,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAGH,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AACxD,OAAO,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAIhE,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAEnD;;;;;GAKG;AACH,OAAO,EACL,iBAAiB,EACjB,YAAY,EACZ,qBAAqB,EACrB,gBAAgB,EAChB,wBAAwB,GACzB,MAAM,YAAY,CAAC;AAEpB;;;;;;GAMG;AACH,OAAO,EAEL,cAAc,EACd,YAAY,EACZ,oBAAoB,EACpB,mBAAmB,EAEnB,oBAAoB,EACpB,qBAAqB,GACtB,MAAM,SAAS,CAAC;AAGjB,OAAO,EACL,mBAAmB,EACnB,gBAAgB,EAChB,sBAAsB,EACtB,mBAAmB,EACnB,uBAAuB,EACvB,sBAAsB,EACtB,0BAA0B,EAC1B,cAAc,GACf,MAAM,aAAa,CAAC;AAGrB,YAAY,EAEV,gBAAgB,EAChB,sBAAsB,EACtB,oBAAoB,EACpB,uBAAuB,EACvB,sBAAsB,EACtB,eAAe,EAEf,UAAU,EACV,oBAAoB,EACpB,uBAAuB,EACvB,oBAAoB,EACpB,kBAAkB,EAClB,kBAAkB,EAClB,yBAAyB,EACzB,0BAA0B,EAE1B,kBAAkB,EAClB,mBAAmB,EACnB,mBAAmB,EACnB,oBAAoB,EACpB,qBAAqB,EACrB,oBAAoB,EACpB,kBAAkB,GACnB,MAAM,SAAS,CAAC;AAGjB,YAAY,EACV,qBAAqB,EACrB,yBAAyB,GAC1B,MAAM,YAAY,CAAC;AAEpB;;;;;;;;;;;;;;;;;;;GAmBG;AACH,OAAO,EACL,aAAa,EACb,iBAAiB,EACjB,gBAAgB,GACjB,MAAM,eAAe,CAAC;AAGvB,YAAY,EACV,UAAU,EACV,aAAa,EACb,aAAa,EACb,eAAe,EACf,YAAY,EACZ,eAAe,EACf,gBAAgB,EAChB,gBAAgB,EAChB,oBAAoB,EACpB,gBAAgB,EAChB,mBAAmB,EACnB,iBAAiB,GAClB,MAAM,eAAe,CAAC"}

package/lib/index.js

@@ -34,7 +34,7 @@
  * ```
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.standardEasing = exports.createEntryAnimationConfig = exports.getExitAnimationConfig = exports.DEFAULT_ENTRY_ANIMATION = exports.FAST_EXIT_ANIMATION = exports.DEFAULT_EXIT_ANIMATION = exports.createDragConfig = exports.DEFAULT_DRAG_CONFIG = exports.useListEntryAnimation = exports.useListExitAnimation = exports.useDropCompensation = exports.useDragAnimatedStyle = exports.useDragShift = exports.useDragGesture = exports.useListAnimationOptional = exports.useListAnimation = exports.ListAnimationProvider = exports.useDragState = exports.DragStateProvider = exports.useBenchmark = exports.AnimatedFlashListItem = exports.AnimatedFlashList = void 0;
+exports.useMemoryMonitor = exports.useRenderProfiler = exports.useFPSMonitor = exports.standardEasing = exports.createEntryAnimationConfig = exports.getExitAnimationConfig = exports.DEFAULT_ENTRY_ANIMATION = exports.FAST_EXIT_ANIMATION = exports.DEFAULT_EXIT_ANIMATION = exports.createDragConfig = exports.DEFAULT_DRAG_CONFIG = exports.useListEntryAnimation = exports.useListExitAnimation = exports.useDropCompensation = exports.useDragAnimatedStyle = exports.useDragShift = exports.useDragGesture = exports.useListAnimationOptional = exports.useListAnimation = exports.ListAnimationProvider = exports.useDragState = exports.DragStateProvider = exports.useBenchmark = exports.AnimatedFlashListItem = exports.AnimatedFlashList = void 0;
 // Main component
 var AnimatedFlashList_1 = require("./AnimatedFlashList");
 Object.defineProperty(exports, "AnimatedFlashList", { enumerable: true, get: function () { return AnimatedFlashList_1.AnimatedFlashList; } });
@@ -82,3 +82,27 @@ Object.defineProperty(exports, "DEFAULT_ENTRY_ANIMATION", { enumerable: true, ge
 Object.defineProperty(exports, "getExitAnimationConfig", { enumerable: true, get: function () { return constants_1.getExitAnimationConfig; } });
 Object.defineProperty(exports, "createEntryAnimationConfig", { enumerable: true, get: function () { return constants_1.createEntryAnimationConfig; } });
 Object.defineProperty(exports, "standardEasing", { enumerable: true, get: function () { return constants_1.standardEasing; } });
+/**
+ * Performance monitoring hooks and utilities.
+ * @internal These are intended for benchmarking and development purposes.
+ * Only available in __DEV__ mode for production builds.
+ *
+ * @example
+ * ```tsx
+ * import {
+ *   useFPSMonitor,
+ *   useRenderProfiler,
+ *   useMemoryMonitor,
+ * } from '@souscheflabs/reanimated-flashlist';
+ *
+ * // Use in development/benchmark builds only
+ * if (__DEV__) {
+ *   const fps = useFPSMonitor();
+ *   fps.start();
+ * }
+ * ```
+ */
+var performance_1 = require("./performance");
+Object.defineProperty(exports, "useFPSMonitor", { enumerable: true, get: function () { return performance_1.useFPSMonitor; } });
+Object.defineProperty(exports, "useRenderProfiler", { enumerable: true, get: function () { return performance_1.useRenderProfiler; } });
+Object.defineProperty(exports, "useMemoryMonitor", { enumerable: true, get: function () { return performance_1.useMemoryMonitor; } });

package/lib/performance/hooks/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Performance monitoring hooks
+ *
+ * These hooks provide real-time performance metrics for AnimatedFlashList.
+ * They are designed for development and benchmarking purposes.
+ */
+export { useFPSMonitor, type UseFPSMonitorResult } from './useFPSMonitor';
+export { useRenderProfiler, type UseRenderProfilerResult } from './useRenderProfiler';
+export { useMemoryMonitor, type UseMemoryMonitorResult } from './useMemoryMonitor';
+export { useBenchmarkComparison, type UseBenchmarkComparisonConfig, type UseBenchmarkComparisonResult, } from './useBenchmarkComparison';
+//# sourceMappingURL=index.d.ts.map

package/lib/performance/hooks/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/performance/hooks/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,aAAa,EAAE,KAAK,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AAC1E,OAAO,EAAE,iBAAiB,EAAE,KAAK,uBAAuB,EAAE,MAAM,qBAAqB,CAAC;AACtF,OAAO,EAAE,gBAAgB,EAAE,KAAK,sBAAsB,EAAE,MAAM,oBAAoB,CAAC;AACnF,OAAO,EACL,sBAAsB,EACtB,KAAK,4BAA4B,EACjC,KAAK,4BAA4B,GAClC,MAAM,0BAA0B,CAAC"}

package/lib/performance/hooks/index.js

@@ -0,0 +1,17 @@
+"use strict";
+/**
+ * Performance monitoring hooks
+ *
+ * These hooks provide real-time performance metrics for AnimatedFlashList.
+ * They are designed for development and benchmarking purposes.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useBenchmarkComparison = exports.useMemoryMonitor = exports.useRenderProfiler = exports.useFPSMonitor = void 0;
+var useFPSMonitor_1 = require("./useFPSMonitor");
+Object.defineProperty(exports, "useFPSMonitor", { enumerable: true, get: function () { return useFPSMonitor_1.useFPSMonitor; } });
+var useRenderProfiler_1 = require("./useRenderProfiler");
+Object.defineProperty(exports, "useRenderProfiler", { enumerable: true, get: function () { return useRenderProfiler_1.useRenderProfiler; } });
+var useMemoryMonitor_1 = require("./useMemoryMonitor");
+Object.defineProperty(exports, "useMemoryMonitor", { enumerable: true, get: function () { return useMemoryMonitor_1.useMemoryMonitor; } });
+var useBenchmarkComparison_1 = require("./useBenchmarkComparison");
+Object.defineProperty(exports, "useBenchmarkComparison", { enumerable: true, get: function () { return useBenchmarkComparison_1.useBenchmarkComparison; } });

package/lib/performance/hooks/useBenchmarkComparison.d.ts

@@ -0,0 +1,45 @@
+import { useFPSMonitor } from './useFPSMonitor';
+import { useRenderProfiler } from './useRenderProfiler';
+import { useMemoryMonitor } from './useMemoryMonitor';
+import type { BenchmarkResult, ScenarioMetrics, BaselineData, ComparisonResult, BenchmarkScenario } from '../types';
+export interface UseBenchmarkComparisonConfig {
+    /** Scenario being tested */
+    scenario: BenchmarkScenario | string;
+    /** Number of items in the list */
+    itemCount: number;
+    /** Baseline data for comparison (optional) */
+    baseline?: BaselineData | null;
+    /** Profiler ID for render tracking */
+    profilerId?: string;
+}
+export interface UseBenchmarkComparisonResult {
+    /** FPS monitor instance */
+    fpsMonitor: ReturnType<typeof useFPSMonitor>;
+    /** Render profiler instance */
+    renderProfiler: ReturnType<typeof useRenderProfiler>;
+    /** Memory monitor instance */
+    memoryMonitor: ReturnType<typeof useMemoryMonitor>;
+    /** Start all monitoring */
+    start: () => void;
+    /** Stop all monitoring */
+    stop: () => void;
+    /** Reset all metrics */
+    reset: () => void;
+    /** Get combined benchmark result */
+    getResult: () => BenchmarkResult;
+    /** Get metrics in ScenarioMetrics format */
+    getMetrics: () => ScenarioMetrics;
+    /** Compare with baseline (if provided) */
+    compareWithBaseline: () => ComparisonResult | null;
+    /** Compare with vanilla FlashList (if baseline contains comparison data) */
+    compareWithVanilla: () => ComparisonResult | null;
+    /** Get formatted markdown report */
+    getMarkdownReport: () => string | null;
+    /** Whether benchmark is currently running */
+    isRunning: boolean;
+}
+/**
+ * Hook that combines all performance monitors with baseline comparison
+ */
+export declare function useBenchmarkComparison(config: UseBenchmarkComparisonConfig): UseBenchmarkComparisonResult;
+//# sourceMappingURL=useBenchmarkComparison.d.ts.map

package/lib/performance/hooks/useBenchmarkComparison.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useBenchmarkComparison.d.ts","sourceRoot":"","sources":["../../../src/performance/hooks/useBenchmarkComparison.ts"],"names":[],"mappings":"AAwBA,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AACxD,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAGtD,OAAO,KAAK,EACV,eAAe,EACf,eAAe,EACf,YAAY,EACZ,gBAAgB,EAChB,iBAAiB,EAClB,MAAM,UAAU,CAAC;AAElB,MAAM,WAAW,4BAA4B;IAC3C,4BAA4B;IAC5B,QAAQ,EAAE,iBAAiB,GAAG,MAAM,CAAC;IACrC,kCAAkC;IAClC,SAAS,EAAE,MAAM,CAAC;IAClB,8CAA8C;IAC9C,QAAQ,CAAC,EAAE,YAAY,GAAG,IAAI,CAAC;IAC/B,sCAAsC;IACtC,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,4BAA4B;IAC3C,2BAA2B;IAC3B,UAAU,EAAE,UAAU,CAAC,OAAO,aAAa,CAAC,CAAC;IAC7C,+BAA+B;IAC/B,cAAc,EAAE,UAAU,CAAC,OAAO,iBAAiB,CAAC,CAAC;IACrD,8BAA8B;IAC9B,aAAa,EAAE,UAAU,CAAC,OAAO,gBAAgB,CAAC,CAAC;IACnD,2BAA2B;IAC3B,KAAK,EAAE,MAAM,IAAI,CAAC;IAClB,0BAA0B;IAC1B,IAAI,EAAE,MAAM,IAAI,CAAC;IACjB,wBAAwB;IACxB,KAAK,EAAE,MAAM,IAAI,CAAC;IAClB,oCAAoC;IACpC,SAAS,EAAE,MAAM,eAAe,CAAC;IACjC,4CAA4C;IAC5C,UAAU,EAAE,MAAM,eAAe,CAAC;IAClC,0CAA0C;IAC1C,mBAAmB,EAAE,MAAM,gBAAgB,GAAG,IAAI,CAAC;IACnD,4EAA4E;IAC5E,kBAAkB,EAAE,MAAM,gBAAgB,GAAG,IAAI,CAAC;IAClD,oCAAoC;IACpC,iBAAiB,EAAE,MAAM,MAAM,GAAG,IAAI,CAAC;IACvC,6CAA6C;IAC7C,SAAS,EAAE,OAAO,CAAC;CACpB;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,4BAA4B,GACnC,4BAA4B,CA2I9B"}

package/lib/performance/hooks/useBenchmarkComparison.js

@@ -0,0 +1,155 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useBenchmarkComparison = useBenchmarkComparison;
+/**
+ * Combined benchmark comparison hook
+ *
+ * Composes FPS, Memory, and Render monitoring into a single hook
+ * with baseline comparison capabilities.
+ *
+ * @example
+ * ```tsx
+ * const benchmark = useBenchmarkComparison({
+ *   scenario: 'scroll',
+ *   itemCount: 100,
+ *   baseline: loadedBaselineData,
+ * });
+ *
+ * // Start benchmarking
+ * benchmark.start();
+ *
+ * // After test completes
+ * benchmark.stop();
+ * const result = benchmark.getResult();
+ * const comparison = benchmark.compareWithBaseline();
+ * ```
+ */
+const react_1 = require("react");
+const useFPSMonitor_1 = require("./useFPSMonitor");
+const useRenderProfiler_1 = require("./useRenderProfiler");
+const useMemoryMonitor_1 = require("./useMemoryMonitor");
+const compareResults_1 = require("../utils/compareResults");
+const loadBaseline_1 = require("../utils/loadBaseline");
+/**
+ * Hook that combines all performance monitors with baseline comparison
+ */
+function useBenchmarkComparison(config) {
+    const { scenario, itemCount, baseline, profilerId = 'benchmark' } = config;
+    // Initialize individual monitors
+    const fpsMonitor = (0, useFPSMonitor_1.useFPSMonitor)();
+    const renderProfiler = (0, useRenderProfiler_1.useRenderProfiler)(profilerId);
+    const memoryMonitor = (0, useMemoryMonitor_1.useMemoryMonitor)();
+    // Track benchmark timing
+    const startTimeRef = (0, react_1.useRef)(0);
+    const isRunningRef = (0, react_1.useRef)(false);
+    // Start all monitors
+    const start = (0, react_1.useCallback)(() => {
+        if (isRunningRef.current)
+            return;
+        isRunningRef.current = true;
+        startTimeRef.current = Date.now();
+        fpsMonitor.start();
+        memoryMonitor.start();
+        // Render profiler starts automatically when Profiler component mounts
+    }, [fpsMonitor, memoryMonitor]);
+    // Stop all monitors
+    const stop = (0, react_1.useCallback)(() => {
+        if (!isRunningRef.current)
+            return;
+        isRunningRef.current = false;
+        fpsMonitor.stop();
+        memoryMonitor.stop();
+    }, [fpsMonitor, memoryMonitor]);
+    // Reset all monitors
+    const reset = (0, react_1.useCallback)(() => {
+        fpsMonitor.reset();
+        renderProfiler.reset();
+        memoryMonitor.reset();
+        startTimeRef.current = 0;
+    }, [fpsMonitor, renderProfiler, memoryMonitor]);
+    // Get metrics in ScenarioMetrics format
+    const getMetrics = (0, react_1.useCallback)(() => {
+        const fps = fpsMonitor.getSnapshot();
+        const render = renderProfiler.getSnapshot();
+        const memory = memoryMonitor.getSnapshot();
+        return {
+            uiFPS: {
+                avg: fps.avg,
+                min: fps.min,
+                max: fps.max,
+                jankPercentage: fps.jankPercentage,
+            },
+            memory: {
+                peakMB: memory.peakHeapMB,
+                deltaMB: memory.heapDeltaMB,
+            },
+            render: {
+                avgRenderTime: render.avgRenderTime,
+                maxRenderTime: render.maxRenderTime,
+                slowRenders: render.slowRenders,
+            },
+        };
+    }, [fpsMonitor, renderProfiler, memoryMonitor]);
+    // Get combined benchmark result
+    const getResult = (0, react_1.useCallback)(() => {
+        const fps = fpsMonitor.getSnapshot();
+        const render = renderProfiler.getSnapshot();
+        const memory = memoryMonitor.getSnapshot();
+        const durationMs = startTimeRef.current > 0 ? Date.now() - startTimeRef.current : 0;
+        return {
+            scenario,
+            itemCount,
+            durationMs,
+            timestamp: Date.now(),
+            uiFPS: fps,
+            render,
+            memory,
+        };
+    }, [scenario, itemCount, fpsMonitor, renderProfiler, memoryMonitor]);
+    // Compare with baseline
+    const compareWithBaselineFn = (0, react_1.useCallback)(() => {
+        if (!baseline) {
+            return null;
+        }
+        const baselineMetrics = (0, loadBaseline_1.getBaselineMetrics)(baseline, scenario, itemCount);
+        if (!baselineMetrics) {
+            return null;
+        }
+        const currentMetrics = getMetrics();
+        return (0, compareResults_1.compareWithBaseline)(currentMetrics, baselineMetrics);
+    }, [baseline, scenario, itemCount, getMetrics]);
+    // Compare with vanilla FlashList
+    const compareWithVanillaFn = (0, react_1.useCallback)(() => {
+        if (!baseline) {
+            return null;
+        }
+        const vanillaMetrics = (0, loadBaseline_1.getVanillaMetrics)(baseline, scenario, itemCount);
+        if (!vanillaMetrics) {
+            return null;
+        }
+        const currentMetrics = getMetrics();
+        return (0, compareResults_1.compareWithBaseline)(currentMetrics, vanillaMetrics);
+    }, [baseline, scenario, itemCount, getMetrics]);
+    // Get formatted markdown report
+    const getMarkdownReport = (0, react_1.useCallback)(() => {
+        const comparison = compareWithBaselineFn();
+        if (!comparison) {
+            return null;
+        }
+        return (0, compareResults_1.formatComparisonAsMarkdown)(comparison, scenario, itemCount);
+    }, [compareWithBaselineFn, scenario, itemCount]);
+    return {
+        fpsMonitor,
+        renderProfiler,
+        memoryMonitor,
+        start,
+        stop,
+        reset,
+        getResult,
+        getMetrics,
+        compareWithBaseline: compareWithBaselineFn,
+        compareWithVanilla: compareWithVanillaFn,
+        getMarkdownReport,
+        isRunning: isRunningRef.current,
+    };
+}

package/lib/performance/hooks/useFPSMonitor.d.ts

@@ -0,0 +1,27 @@
+import { useSharedValue } from 'react-native-reanimated';
+import type { FPSMetrics, FPSMonitorConfig } from '../types';
+export interface UseFPSMonitorResult {
+    /** SharedValue containing current FPS metrics (for UI thread access) */
+    metrics: ReturnType<typeof useSharedValue<FPSMetrics>>;
+    /** Start FPS monitoring */
+    start: () => void;
+    /** Stop FPS monitoring */
+    stop: () => void;
+    /** Reset all metrics */
+    reset: () => void;
+    /** Get a snapshot of current metrics (JS thread) */
+    getSnapshot: () => FPSMetrics;
+    /** Whether monitoring is currently active */
+    isActive: boolean;
+}
+/**
+ * Hook for monitoring FPS on both UI and JS threads
+ *
+ * Uses:
+ * - useFrameCallback for UI thread FPS (Reanimated pattern)
+ * - requestAnimationFrame for JS thread FPS
+ *
+ * @param config - Optional configuration for thresholds and buffer size
+ */
+export declare function useFPSMonitor(config?: Partial<FPSMonitorConfig>): UseFPSMonitorResult;
+//# sourceMappingURL=useFPSMonitor.d.ts.map

package/lib/performance/hooks/useFPSMonitor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useFPSMonitor.d.ts","sourceRoot":"","sources":["../../../src/performance/hooks/useFPSMonitor.ts"],"names":[],"mappings":"AAuBA,OAAO,EAAE,cAAc,EAAoB,MAAM,yBAAyB,CAAC;AAC3E,OAAO,KAAK,EAAE,UAAU,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAuD7D,MAAM,WAAW,mBAAmB;IAClC,wEAAwE;IACxE,OAAO,EAAE,UAAU,CAAC,OAAO,cAAc,CAAC,UAAU,CAAC,CAAC,CAAC;IACvD,2BAA2B;IAC3B,KAAK,EAAE,MAAM,IAAI,CAAC;IAClB,0BAA0B;IAC1B,IAAI,EAAE,MAAM,IAAI,CAAC;IACjB,wBAAwB;IACxB,KAAK,EAAE,MAAM,IAAI,CAAC;IAClB,oDAAoD;IACpD,WAAW,EAAE,MAAM,UAAU,CAAC;IAC9B,6CAA6C;IAC7C,QAAQ,EAAE,OAAO,CAAC;CACnB;AAED;;;;;;;;GAQG;AACH,wBAAgB,aAAa,CAC3B,MAAM,GAAE,OAAO,CAAC,gBAAgB,CAAM,GACrC,mBAAmB,CAyLrB"}