react-native-nitro-list 0.1.1 → 0.1.2

package/src/__tests__/windowing/findVisibleIndexRange.test.ts

@@ -1,55 +0,0 @@
-import { findVisibleIndexRange } from '../../windowing/findVisibleIndexRange'
-
-describe('findVisibleIndexRange', () => {
-  /**
-   * Layouts:
-   * index 0 → y: 0–50
-   * index 1 → y: 50–100
-   * index 2 → y: 100–150
-   * ...
-   */
-  const layouts = Array.from({ length: 10 }, (_, i) => ({
-    x: 0,
-    y: i * 50,
-    width: 100,
-    height: 50,
-  }))
-
-  it('returns empty array when layouts are empty', () => {
-    const result = findVisibleIndexRange([], { offsetY: 0, height: 300 }, 100)
-
-    expect(result).toEqual([])
-  })
-  it('returns correct visible indices without buffer', () => {
-    const result = findVisibleIndexRange(
-      layouts,
-      { offsetY: 100, height: 150 },
-      0
-    )
-
-    /**
-     * Viewport: 100–250 (inclusive)
-     * Items that intersect this window:
-     * indices 1–5
-     */
-    expect(result).toEqual([1, 2, 3, 4, 5])
-  })
-
-  it('extends window using bufferPx (inclusive boundaries)', () => {
-    const result = findVisibleIndexRange(
-      layouts,
-      { offsetY: 100, height: 100 },
-      100
-    )
-
-    /**
-     * Viewport:      100–200
-     * Buffer:        ±100
-     * Effective win: 0–300 (inclusive)
-     *
-     * index 6 starts at y = 300 → included by design
-     * This matches FlashList / RecyclerView behavior
-     */
-    expect(result).toEqual([0, 1, 2, 3, 4, 5, 6])
-  })
-})

package/src/cell/StableKey.ts

@@ -1,6 +0,0 @@
-export function getStableKey(
-  slotKey: string,
-  index: number
-): string {
-  return `${slotKey}:${index}`
-}

package/src/hooks/useCellRenderer.ts

@@ -1,86 +0,0 @@
-import { useEffect, useMemo, useRef, useState } from 'react'
-import type { Cell } from '../cell/Cell'
-import { CellRecycler } from '../cell/CellRecycler'
-import { findVisibleIndexRange } from '../windowing/findVisibleIndexRange'
-import type { LayoutRectangle } from '../layout/LayoutRectangle'
-import type { ScrollMetrics } from '../windowing/ScrollMetrics'
-
-/**
- * 🔒 Stable empty references (module-level)
- * These MUST NOT be recreated per render.
- */
-const EMPTY_INDICES: readonly number[] = []
-
-/**
- * React bridge for CellRecycler.
- * FlashList equivalent: useCellRenderer
- *
- * Responsibilities:
- * - Translate scroll state → visible indices
- * - Ask recycler for physical cells
- * - Commit results with referential stability
- *
- * Responsibilities it does NOT have:
- * ❌ Layout mutation
- * ❌ Measurement
- * ❌ Rendering
- */
-export function useCellRenderer(
-  layouts: readonly LayoutRectangle[],
-  metrics: ScrollMetrics,
-  bufferPx: number,
-  getCellType: (index: number) => string
-): readonly Cell[] {
-  /**
-   * Recycler instance is stable across renders.
-   */
-  const recyclerRef = useRef<CellRecycler>(new CellRecycler())
-
-  /**
-   * Compute visible indices.
-   * PURE + TOTAL:
-   * - Never throws
-   * - Always returns the same reference when empty
-   */
-  const visibleIndices = useMemo(
-    () =>
-      layouts.length === 0
-        ? EMPTY_INDICES
-        : findVisibleIndexRange(
-            layouts,
-            metrics,
-            bufferPx
-          ),
-    [layouts, metrics.offsetY, metrics.height, bufferPx]
-  )
-
-  /**
-   * Physical cells to render.
-   */
-  const [cells, setCells] =
-    useState<readonly Cell[]>([])
-
-  /**
-   * Reconcile visible indices → physical cells.
-   *
-   * FlashList invariant:
-   * - Only update state if identity truly changed
-   * - Prevents pointless re-renders
-   */
-  useEffect(() => {
-    const next =
-      recyclerRef.current.reconcile(
-        visibleIndices,
-        getCellType
-      )
-
-    setCells(prev =>
-      prev.length === next.length &&
-      prev.every((c, i) => c === next[i])
-        ? prev
-        : next
-    )
-  }, [visibleIndices, getCellType])
-
-  return cells
-}

package/src/hooks/useStableCallback.ts

@@ -1,13 +0,0 @@
-import { useRef, useCallback } from 'react'
-
-export function useStableCallback<T extends (...args: never[]) => unknown>(
-  fn: T
-): T {
-  const ref = useRef(fn)
-  ref.current = fn
-
-  return useCallback(
-    ((...args: never[]) => ref.current(...args)) as T,
-    []
-  )
-}

package/src/layout/EstimatedLayoutProvider.ts

@@ -1,35 +0,0 @@
-import type { LayoutProvider } from './LayoutProvider'
-import type { LayoutRectangle } from './LayoutRectangle'
-
-/**
- * Layout provider using estimated item heights.
- * Used before real measurements are available.
- */
-export class EstimatedLayoutProvider implements LayoutProvider {
-  private readonly itemCount: number
-  private readonly itemHeight: number
-  private readonly width: number
-
-  constructor(
-    itemCount: number,
-    itemHeight: number,
-    width: number
-  ) {
-    this.itemCount = itemCount
-    this.itemHeight = itemHeight
-    this.width = width
-  }
-
-  getItemCount(): number {
-    return this.itemCount
-  }
-
-  getLayout(index: number): LayoutRectangle {
-    return {
-      x: 0,
-      y: index * this.itemHeight,
-      width: this.width,
-      height: this.itemHeight,
-    }
-  }
-}

package/src/layout/LayoutEngine.ts

@@ -1,21 +0,0 @@
-import type { LayoutProvider } from './LayoutProvider'
-import type { LayoutRectangle } from './LayoutRectangle'
-
-/**
- * Resolves layouts eagerly into a contiguous array.
- * Pure, deterministic, and reusable.
- *
- * FlashList equivalent: internal layout resolver.
- */
-export function computeLayouts(
-  provider: LayoutProvider
-): readonly LayoutRectangle[] {
-  const count = provider.getItemCount()
-  const layouts: LayoutRectangle[] = new Array(count)
-
-  for (let i = 0; i < count; i++) {
-    layouts[i] = provider.getLayout(i)
-  }
-
-  return layouts
-}

package/src/layout/LayoutProvider.ts

@@ -1,17 +0,0 @@
-import type { LayoutRectangle } from './LayoutRectangle'
-
-/**
- * Provides layout information for items.
- * FlashList equivalent: LayoutProvider
- */
-export interface LayoutProvider {
-  /**
-   * Total number of items
-   */
-  getItemCount(): number
-
-  /**
-   * Layout rectangle for a given index
-   */
-  getLayout(index: number): LayoutRectangle
-}

package/src/layout/LayoutRectangle.ts

@@ -1,10 +0,0 @@
-/**
- * Immutable layout rectangle for a single item.
- * Equivalent to FlashList's Layout.
- */
-export interface LayoutRectangle {
-  readonly x: number
-  readonly y: number
-  readonly width: number
-  readonly height: number
-}

package/src/viewability/ViewabilityHelper.ts

@@ -1,130 +0,0 @@
-import type { LayoutRectangle } from '../layout/LayoutRectangle'
-import type { ScrollMetrics } from '../windowing/ScrollMetrics'
-
-/**
- * Public token describing viewability state of an item.
- * Mirrors FlashList's ViewToken concept.
- */
-export type ViewToken = {
-  index: number
-  isViewable: boolean
-}
-
-/**
- * Configuration for viewability calculations.
- */
-export type ViewabilityConfig = {
-  /**
-   * Percentage (0–100) of item height that must be visible
-   * for the item to be considered "viewable".
-   */
-  itemVisiblePercentThreshold?: number
-}
-
-/**
- * ViewabilityHelper
- *
- * Pure observer:
- * - Does NOT affect layout
- * - Does NOT affect recycling
- * - Computes visibility based on layout + scroll metrics
- *
- * This class is intentionally stateful (lastVisible)
- * to compute "changed" items efficiently.
- */
-export class ViewabilityHelper {
-  /** Previously visible indices */
-  private lastVisible = new Set<number>()
-
-  constructor(
-    private readonly config: ViewabilityConfig = {}
-  ) {}
-
-  /**
-   * Computes which items are viewable and which changed
-   * since the last invocation.
-   *
-   * IMPORTANT:
-   * - This method should be called AFTER windowing,
-   *   not on the full dataset.
-   */
-  computeViewableItems(
-    layouts: readonly LayoutRectangle[],
-    metrics: ScrollMetrics
-  ): {
-    viewableItems: ViewToken[]
-    changed: ViewToken[]
-  } {
-    const visibleNow = new Set<number>()
-    const viewableItems: ViewToken[] = []
-    const changed: ViewToken[] = []
-
-    const viewportTop = metrics.offsetY
-    const viewportBottom = viewportTop + metrics.height
-
-    // Normalize threshold into [0, 1]
-    const threshold =
-      (this.config.itemVisiblePercentThreshold ?? 0) / 100
-
-    /**
-     * NOTE:
-     * We intentionally iterate layouts sequentially,
-     * but EXIT EARLY when items are completely below viewport.
-     *
-     * This keeps complexity near O(visibleItems),
-     * not O(totalItems).
-     */
-    for (let i = 0; i < layouts.length; i++) {
-      const layout = layouts[i]!
-
-      // If item is completely below viewport, stop
-      if (layout.y > viewportBottom) {
-        break
-      }
-
-      const itemTop = layout.y
-      const itemBottom = layout.y + layout.height
-
-      // If item is completely above viewport, skip
-      if (itemBottom < viewportTop) {
-        continue
-      }
-
-      // Compute visible intersection
-      const visibleTop = Math.max(itemTop, viewportTop)
-      const visibleBottom = Math.min(itemBottom, viewportBottom)
-
-      const visibleHeight = Math.max(0, visibleBottom - visibleTop)
-
-      // Guard against zero-height items
-      const itemHeight =
-        layout.height > 0 ? layout.height : 1
-
-      const visibleRatio = visibleHeight / itemHeight
-
-      if (visibleRatio >= threshold) {
-        visibleNow.add(i)
-        viewableItems.push({ index: i, isViewable: true })
-
-        // Newly visible
-        if (!this.lastVisible.has(i)) {
-          changed.push({ index: i, isViewable: true })
-        }
-      }
-    }
-
-    /**
-     * Items that were visible before but not anymore
-     */
-    for (const index of this.lastVisible) {
-      if (!visibleNow.has(index)) {
-        changed.push({ index, isViewable: false })
-      }
-    }
-
-    // Update snapshot
-    this.lastVisible = visibleNow
-
-    return { viewableItems, changed }
-  }
-}

package/src/windowing/findVisibleIndexRange.ts

@@ -1,60 +0,0 @@
-import type { LayoutRectangle } from '../layout/LayoutRectangle'
-import type { ScrollMetrics } from './ScrollMetrics'
-
-/**
- * Computes the contiguous range of item indices
- * intersecting the viewport expanded by bufferPx.
- *
- * PURE function. No allocations besides output.
- * FlashList-style windowing.
- */
-export function findVisibleIndexRange(
-  layouts: readonly LayoutRectangle[],
-  metrics: ScrollMetrics,
-  bufferPx: number
-): readonly number[] {
-  const count = layouts.length
-
-  // 🔒 CRITICAL GUARDS (FlashList-style)
-  if (
-    count === 0 ||
-    metrics.height <= 0 ||
-    bufferPx < 0
-  ) {
-    return []
-  }
-
-  const windowStart =
-    Math.max(0, metrics.offsetY - bufferPx)
-
-  const windowEnd =
-    metrics.offsetY + metrics.height + bufferPx
-
-  // Binary search for first intersecting item
-  let low = 0
-  let high = count - 1
-  let firstVisible = count
-
-  while (low <= high) {
-    const mid = (low + high) >> 1
-    const rect = layouts[mid]!
-
-    if (rect.y + rect.height >= windowStart) {
-      firstVisible = mid
-      high = mid - 1
-    } else {
-      low = mid + 1
-    }
-  }
-
-  // Linear scan forward
-  const visible: number[] = []
-
-  for (let i = firstVisible; i < count; i++) {
-    const rect = layouts[i]!
-    if (rect.y > windowEnd) break
-    visible.push(i)
-  }
-
-  return visible
-}