@expo/ui 58.0.5 → 58.0.6

package/ios/DataListForEachView.swift

@@ -0,0 +1,255 @@
+// Copyright 2026-present 650 Industries. All rights reserved.
+
+import ExpoModulesCore
+import SwiftUI
+
+final class DataListForEachProps: UIBaseViewProps {
+  @Field var itemKeys: [String] = []
+  @Field var revision: Int = 0
+  @Field var estimatedItemSize: Double = 64
+  @Field var deleteEnabled: Bool = false
+  @Field var moveEnabled: Bool = false
+  var onDelete = EventDispatcher()
+  var onMove = EventDispatcher()
+  var onWindowChange = EventDispatcher()
+}
+
+final class DataListForEachItemProps: ExpoSwiftUI.ViewProps {
+  @Field var itemKey: String = ""
+  @Field var index: Int = 0
+  @Field var revision: Int = 0
+}
+
+struct DataListForEachItemView: ExpoSwiftUI.View {
+  @ObservedObject var props: DataListForEachItemProps
+
+  init(props: DataListForEachItemProps) {
+    self.props = props
+  }
+
+  var body: some View {
+    Children()
+  }
+}
+
+final class DataListForEachPoolProps: ExpoSwiftUI.ViewProps {}
+
+// Holds the recycled slots, so mounting a slot never republishes the list's own props.
+struct DataListForEachPoolView: ExpoSwiftUI.View {
+  @ObservedObject var props: DataListForEachPoolProps
+
+  init(props: DataListForEachPoolProps) {
+    self.props = props
+  }
+
+  var body: some View {
+    EmptyView()
+  }
+}
+
+struct DataListForEachView: ExpoSwiftUI.View {
+  @ObservedObject var props: DataListForEachProps
+  @StateObject private var window = DataListForEachWindow()
+
+  init(props: DataListForEachProps) {
+    self.props = props
+  }
+
+  var body: some View {
+    let revision = props.revision
+    let pool = (props.children ?? []).lazy.compactMap { ($0.childView as? DataListForEachPoolView)?.props }.first
+    if let pool {
+      ForEach(Array(props.itemKeys.enumerated()), id: \.element) { index, key in
+        DataListForEachRow(itemKey: key, index: index, listProps: props, poolProps: pool, window: window)
+          .tag(AnyHashable(key))
+      }
+      .onDelete(perform: props.deleteEnabled ? { offsets in
+        props.onDelete(["indices": Array(offsets), "revision": revision])
+      } : nil)
+      .onMove(perform: props.moveEnabled ? { sources, destination in
+        props.onMove(["sourceIndices": Array(sources), "destination": destination, "revision": revision])
+      } : nil)
+    }
+  }
+}
+
+private struct DataListForEachRow: View {
+  let itemKey: String
+  let index: Int
+  @ObservedObject var listProps: DataListForEachProps
+  @ObservedObject var poolProps: DataListForEachPoolProps
+  let window: DataListForEachWindow
+  @State private var appeared = false
+  @State private var visibilityID = UUID()
+
+  // Slots are the pool's children; JS assigns item `index` to slot `index % count`.
+  // Reading them here, not in the parent, keeps the row current when the slot count changes.
+  private var slot: DataListForEachItemView? {
+    guard let slots = poolProps.children, !slots.isEmpty else {
+      return nil
+    }
+    return slots[index % slots.count].childView as? DataListForEachItemView
+  }
+
+  var body: some View {
+    VStack(alignment: .leading, spacing: 0) {
+      if let slot {
+        DataListForEachSlotContent(
+          props: slot.props,
+          itemKey: itemKey,
+          index: index,
+          revision: listProps.revision,
+          estimatedHeight: CGFloat(listProps.estimatedItemSize),
+          window: window
+        )
+      } else {
+        Color.clear
+          .frame(height: window.height(for: itemKey, fallback: listProps.estimatedItemSize))
+          .accessibilityHidden(true)
+      }
+    }
+    .frame(maxWidth: .infinity, alignment: .leading)
+    .onAppear {
+      appeared = true
+      window.appear(itemKey, index: index, token: visibilityID, props: listProps)
+    }
+    .onChange(of: listProps.revision) { _ in
+      window.reset(listProps)
+      if appeared { window.appear(itemKey, index: index, token: visibilityID, props: listProps) }
+    }
+    .onGeometryChange(for: CGFloat.self, of: { $0.size.width }, action: { width in
+      window.updateWidth(width)
+    })
+    .onDisappear {
+      appeared = false
+      window.disappear(itemKey, token: visibilityID)
+    }
+  }
+}
+
+private struct DataListForEachSlotContent: View {
+  @ObservedObject var props: DataListForEachItemProps
+  let itemKey: String
+  let index: Int
+  let revision: Int
+  let estimatedHeight: CGFloat
+  let window: DataListForEachWindow
+  // we use this state so swiftui re-layouts when the slot is reused for a different item
+  @State private var showsContent = false
+
+  private var matches: Bool {
+    props.itemKey == itemKey && props.index == index && props.revision == revision
+  }
+
+  var body: some View {
+    Group {
+      if showsContent {
+        DataListForEachItemView(props: props)
+          .id(itemKey)
+          .onGeometryChange(for: CGFloat.self, of: { $0.size.height }, action: { height in
+            window.measure(height, for: itemKey, revision: revision)
+          })
+      } else {
+        // Hide the previous item while JS updates this slot.
+        Color.clear
+          .frame(height: window.height(for: itemKey, fallback: Double(estimatedHeight)))
+          .accessibilityHidden(true)
+      }
+    }
+    .onAppear { showsContent = matches }
+    .onChange(of: matches) { showsContent = $0 }
+  }
+}
+
+// Tracks rows without triggering view updates and batches window requests to JS.
+private final class DataListForEachWindow: ObservableObject {
+  private weak var props: DataListForEachProps?
+  private var appeared: [String: Int] = [:]
+  private var visibilityTokens: [String: UUID] = [:]
+  private var heights: [String: CGFloat] = [:]
+  private var width: CGFloat = 0
+  private var revision = -1
+  private var pending: DispatchWorkItem?
+  private var lastSent: [Int] = []
+
+  deinit {
+    pending?.cancel()
+  }
+
+  func reset(_ props: DataListForEachProps) {
+    self.props = props
+    guard revision != props.revision else {
+      return
+    }
+    revision = props.revision
+    heights.removeAll()
+    let positions = Dictionary(uniqueKeysWithValues: props.itemKeys.enumerated().map { ($0.element, $0.offset) })
+    appeared = positions.filter { appeared[$0.key] != nil }
+    visibilityTokens = visibilityTokens.filter { positions[$0.key] != nil }
+    lastSent = []
+    schedule()
+  }
+
+  func updateWidth(_ newWidth: CGFloat) {
+    if width != newWidth {
+      if width > 0 {
+        heights.removeAll()
+      }
+      width = newWidth
+    }
+  }
+
+  func appear(_ key: String, index: Int, token: UUID, props: DataListForEachProps) {
+    reset(props)
+    guard props.itemKeys.indices.contains(index), props.itemKeys[index] == key else {
+      return
+    }
+    appeared[key] = index
+    visibilityTokens[key] = token
+    schedule()
+  }
+
+  func disappear(_ key: String, token: UUID) {
+    // Ignore callbacks from a row that has been replaced.
+    guard visibilityTokens[key] == token else {
+      return
+    }
+    appeared.removeValue(forKey: key)
+    visibilityTokens.removeValue(forKey: key)
+    if appeared.isEmpty { lastSent = [] }
+    schedule()
+  }
+
+  func height(for key: String, fallback: Double) -> CGFloat {
+    heights[key] ?? CGFloat(fallback)
+  }
+
+  func measure(_ height: CGFloat, for key: String, revision: Int) {
+    guard revision == self.revision, height.isFinite, height > 0 else {
+      return
+    }
+    heights[key] = height
+  }
+
+  private func schedule() {
+    guard pending == nil else {
+      return
+    }
+    let work = DispatchWorkItem { [weak self] in
+      guard let self else { return }
+      self.pending = nil
+      guard let props = self.props,
+        let first = self.appeared.values.min(), let last = self.appeared.values.max() else {
+        return
+      }
+      let event = [first, last, self.revision]
+      guard event != self.lastSent else {
+        return
+      }
+      self.lastSent = event
+      props.onWindowChange(["first": first, "last": last, "revision": self.revision])
+    }
+    pending = work
+    DispatchQueue.main.async(execute: work)
+  }
+}

package/ios/ExpoUIModule.swift

@@ -170,6 +170,9 @@ public final class ExpoUIModule: Module {
     ExpoUIView(ImageView.self)
     ExpoUIView(LabelView.self)
     ExpoUIView(ListView.self)
+    ExpoUIView(DataListForEachView.self)
+    View(DataListForEachItemView.self)
+    View(DataListForEachPoolView.self)
     ExpoUIView(ListForEachView.self)
 
     ExpoUIView(PickerView.self)

package/ios/ListForEachView.swift

@@ -4,6 +4,8 @@ import ExpoModulesCore
 import SwiftUI
 
 final class ListForEachProps: UIBaseViewProps {
+  @Field var deleteEnabled: Bool = false
+  @Field var moveEnabled: Bool = false
   var onDelete = EventDispatcher()
   var onMove = EventDispatcher()
 }
@@ -16,9 +18,16 @@ struct ListForEachView: ExpoSwiftUI.View {
   }
 
   var body: some View {
-    Children()
-      .onDelete(perform: handleDelete)
-      .onMove(perform: handleMove)
+    ForEach(props.children ?? [], id: \.childIdentity) { child in
+      if let item = child.childView as? DataListForEachItemView {
+        item.tag(AnyHashable(item.props.itemKey))
+      } else {
+        let view: any View = child.childView
+        AnyView(view)
+      }
+    }
+    .onDelete(perform: props.deleteEnabled ? handleDelete : nil)
+    .onMove(perform: props.moveEnabled ? handleMove : nil)
   }
 
   func handleDelete(at offsets: IndexSet) {

package/local-maven-repo/expo/modules/ui/expo.modules.ui/{58.0.5/expo.modules.ui-58.0.5.module → 58.0.6/expo.modules.ui-58.0.6.module}

@@ -3,7 +3,7 @@
   "component": {
     "group": "expo.modules.ui",
     "module": "expo.modules.ui",
-    "version": "58.0.5",
+    "version": "58.0.6",
     "attributes": {
       "org.gradle.status": "release"
     }
@@ -24,8 +24,8 @@
       },
       "files": [
         {
-          "name": "expo.modules.ui-58.0.5.aar",
-          "url": "expo.modules.ui-58.0.5.aar",
+          "name": "expo.modules.ui-58.0.6.aar",
+          "url": "expo.modules.ui-58.0.6.aar",
           "size": 1792968,
           "sha512": "ddcedbdcc0e95db83f0657a68090572e6d7c7fb9233e796ea875d86e9782c619560ef0e98316cdf6642abbed4b42eb43b5e8264be55130f47e473adbc0f77c11",
           "sha256": "9b228fbd60d559e9dfebe894e1846a8c7ce3c72e5c91936b4382c97295e9b072",
@@ -141,8 +141,8 @@
       ],
       "files": [
         {
-          "name": "expo.modules.ui-58.0.5.aar",
-          "url": "expo.modules.ui-58.0.5.aar",
+          "name": "expo.modules.ui-58.0.6.aar",
+          "url": "expo.modules.ui-58.0.6.aar",
           "size": 1792968,
           "sha512": "ddcedbdcc0e95db83f0657a68090572e6d7c7fb9233e796ea875d86e9782c619560ef0e98316cdf6642abbed4b42eb43b5e8264be55130f47e473adbc0f77c11",
           "sha256": "9b228fbd60d559e9dfebe894e1846a8c7ce3c72e5c91936b4382c97295e9b072",
@@ -161,8 +161,8 @@
       },
       "files": [
         {
-          "name": "expo.modules.ui-58.0.5-sources.jar",
-          "url": "expo.modules.ui-58.0.5-sources.jar",
+          "name": "expo.modules.ui-58.0.6-sources.jar",
+          "url": "expo.modules.ui-58.0.6-sources.jar",
           "size": 106293,
           "sha512": "5a6dc466f00aa1d74a9e1df2c4a06f3bf9c00b9eebe03e54e1ae68db446806f3f47f98e4a1d04bd90db6683459dd11785d22499d9cef48dd979293f8a88104d3",
           "sha256": "d4e08c526d892c05d1ab6e42bd451df874e4da5cc58c18080ad730fc0ae59dfa",

package/local-maven-repo/expo/modules/ui/expo.modules.ui/58.0.6/expo.modules.ui-58.0.6.module.md5

@@ -0,0 +1 @@
+7e592a224a0fc4b1d3190d5e0453dca4

package/local-maven-repo/expo/modules/ui/expo.modules.ui/58.0.6/expo.modules.ui-58.0.6.module.sha1

@@ -0,0 +1 @@
+351d8fdc59045d3033183991bc4a41010bbdf928

package/local-maven-repo/expo/modules/ui/expo.modules.ui/58.0.6/expo.modules.ui-58.0.6.module.sha256

@@ -0,0 +1 @@
+67875636aba690f3ed01c1885a8f5dd5c72824b9028ed012d77016a5c5bfef85

package/local-maven-repo/expo/modules/ui/expo.modules.ui/58.0.6/expo.modules.ui-58.0.6.module.sha512

@@ -0,0 +1 @@
+b7469559d94d21ec59ac3c32700d5c1651d2384574457e83c5f11eea0d6e947dd0ae5b68209f09056c30a0493e561c3a1dd74ea51cd3ec0435e8887603646187

package/local-maven-repo/expo/modules/ui/expo.modules.ui/{58.0.5/expo.modules.ui-58.0.5.pom → 58.0.6/expo.modules.ui-58.0.6.pom}

@@ -9,7 +9,7 @@
   <modelVersion>4.0.0</modelVersion>
   <groupId>expo.modules.ui</groupId>
   <artifactId>expo.modules.ui</artifactId>
-  <version>58.0.5</version>
+  <version>58.0.6</version>
   <packaging>aar</packaging>
   <name>expo.modules.ui</name>
   <url>https://github.com/expo/expo</url>

package/local-maven-repo/expo/modules/ui/expo.modules.ui/58.0.6/expo.modules.ui-58.0.6.pom.md5

@@ -0,0 +1 @@
+5c827bb51c32599862e86feff95a8e6d

package/local-maven-repo/expo/modules/ui/expo.modules.ui/58.0.6/expo.modules.ui-58.0.6.pom.sha1

@@ -0,0 +1 @@
+df98a93ccb93778ea5f6d701bf92e3caf1565000

package/local-maven-repo/expo/modules/ui/expo.modules.ui/58.0.6/expo.modules.ui-58.0.6.pom.sha256

@@ -0,0 +1 @@
+3b1a0a5386bc7a66e1e3097896cf2e63f8faccfa982ad72fc4d9f81dd6d7b9b7

package/local-maven-repo/expo/modules/ui/expo.modules.ui/58.0.6/expo.modules.ui-58.0.6.pom.sha512

@@ -0,0 +1 @@
+d66ff20ada5d5bcd01c7ca0506db62ecc07e8eae9113f3e174b776efa9588663ef4bb7ea2761fba9c7ae518b3732c4185a7aee70d4a64e6fb0fcd579abdb5d94

package/local-maven-repo/expo/modules/ui/expo.modules.ui/maven-metadata.xml

@@ -3,11 +3,11 @@
   <groupId>expo.modules.ui</groupId>
   <artifactId>expo.modules.ui</artifactId>
   <versioning>
-    <latest>58.0.5</latest>
-    <release>58.0.5</release>
+    <latest>58.0.6</latest>
+    <release>58.0.6</release>
     <versions>
-      <version>58.0.5</version>
+      <version>58.0.6</version>
     </versions>
-    <lastUpdated>20260922160135</lastUpdated>
+    <lastUpdated>20260923154017</lastUpdated>
   </versioning>
 </metadata>

package/local-maven-repo/expo/modules/ui/expo.modules.ui/maven-metadata.xml.md5

@@ -1 +1 @@
-c4131ab7d3611c2ad7222519c1ac6dbc
+96559b0eabb8170769333ad05cdcfafe

package/local-maven-repo/expo/modules/ui/expo.modules.ui/maven-metadata.xml.sha1

@@ -1 +1 @@
-40d27ef259a3a4594d9eb687a6acf1489c4d23a9
+9b146187e50f805cfcdce4249b9d56e1e1fdf9d6

package/local-maven-repo/expo/modules/ui/expo.modules.ui/maven-metadata.xml.sha256

@@ -1 +1 @@
-be1b14600c8809450004a609ef15392fa45790d99c199668b2fdbeeb38072cdf
+89c63e4e2a7fce899cd9101093d5c1105c62feffaea5ec288e6a39e5b8739446

package/local-maven-repo/expo/modules/ui/expo.modules.ui/maven-metadata.xml.sha512

@@ -1 +1 @@
-aa2b01073faddd2b62d7984ff6ff1637f53cdc23fb83803f432a6fc824ad2a88349638c7ab718dd0961d11ff3e7e0a7ee92ceea63c880257947348b3501c39fa
+50a66b6bfe1bbcedd9157651a817cac9309fb48c2a649c274b5a34e625370c8cd487af0235f5801320779f19049a619e06bcb71e69df646a129d06bfb0041c27

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@expo/ui",
-  "version": "58.0.5",
+  "version": "58.0.6",
   "description": "A collection of UI components",
   "keywords": [
     "Jetpack Compose",
@@ -171,7 +171,7 @@
       "optional": true
     }
   },
-  "gitHead": "add8cbf49f477cfd2283ae05af35b4713a773c55",
+  "gitHead": "8aeb4368d396d2d71a2fc8c652c4d1d4d53ed858",
   "scripts": {
     "precompile-ios": "et prebuild-package-for-publish",
     "build": "pnpm run build:lib && pnpm run build:plugin",

package/src/swift-ui/List/DataListForEach.tsx

@@ -0,0 +1,249 @@
+import { requireNativeView } from 'expo';
+import { memo, useLayoutEffect, useMemo, useRef, useState, type ReactElement } from 'react';
+
+import { type ViewEvent } from '../../types';
+import { createViewModifierEventListener } from '../modifiers/utils';
+import { type CommonViewModifierProps } from '../types';
+import { getSlotIndices, getWindow } from './window';
+
+export interface ListForEachProps<ItemT> extends CommonViewModifierProps {
+  /** Called with deleted indices from this group's `data` array. */
+  onDelete?: (indices: number[]) => void;
+  /**
+   * Called with the source indices and the destination index. The destination index counts
+   * positions before the moved items are removed, so it can equal `data.length`.
+   */
+  onMove?: (sourceIndices: number[], destination: number) => void;
+  /** Items to display. Replace the array when updating data. */
+  data: readonly ItemT[];
+  /** Returns a stable, unique string key, also used for `List` selection. */
+  keyExtractor: (item: ItemT, index: number) => string;
+  /**
+   * Renders a row. When `recycling` is `true`, wrap it in `useCallback`, or every row
+   * re-renders on each parent render.
+   * Recycled rows are reused for other items, so their local state (`useState`) carries over.
+   * Reset it when the item changes, or keep the state outside the row.
+   */
+  children: (info: { item: ItemT; index: number }) => ReactElement;
+  /**
+   * Renders only the rows near the visible range and reuses them while scrolling. Set to `false` to
+   * render every row at once. Set it once; changing it remounts the rows.
+   * @default true
+   */
+  recycling?: boolean;
+  /**
+   * Extra rows to prepare on each side of the visible rows. Must be a non-negative integer.
+   * Ignored when `recycling` is `false`.
+   * @default 10
+   */
+  overscanCount?: number;
+  /**
+   * Placeholder height in points, excluding `List` insets, until a row is measured.
+   * Must be positive. Measurements reset when `data` or width changes.
+   * Ignored when `recycling` is `false`.
+   * @default 64
+   */
+  estimatedItemSize?: number;
+}
+
+type WindowEvent = { first: number; last: number; revision: number };
+type NativeProps = CommonViewModifierProps &
+  ViewEvent<'onWindowChange', WindowEvent> &
+  ViewEvent<'onDelete', { indices: number[]; revision: number }> &
+  ViewEvent<'onMove', { sourceIndices: number[]; destination: number; revision: number }> & {
+    deleteEnabled: boolean;
+    moveEnabled: boolean;
+    itemKeys: string[];
+    revision: number;
+    estimatedItemSize: number;
+    children: ReactElement;
+  };
+type SlotProps = {
+  itemKey: string;
+  index: number;
+  revision: number;
+  children: ReactElement;
+};
+
+const NativeList = requireNativeView<NativeProps>('ExpoUI', 'DataListForEachView');
+export const NativeSlot = requireNativeView<SlotProps>('ExpoUI', 'DataListForEachItemView');
+const NativePool = requireNativeView<{ children: ReactElement[] }>(
+  'ExpoUI',
+  'DataListForEachPoolView'
+);
+
+// Skip unchanged rows when the window moves.
+const RecycledRow = memo(function RecycledRow<ItemT>({
+  item,
+  index,
+  itemKey,
+  revision,
+  renderItem,
+}: SlotPropsWithoutChildren & {
+  item: ItemT;
+  renderItem: ListForEachProps<ItemT>['children'];
+}) {
+  return (
+    <NativeSlot itemKey={itemKey} index={index} revision={revision}>
+      {renderItem({ item, index })}
+    </NativeSlot>
+  );
+}) as <ItemT>(
+  props: SlotPropsWithoutChildren & {
+    item: ItemT;
+    renderItem: ListForEachProps<ItemT>['children'];
+  }
+) => ReactElement;
+type SlotPropsWithoutChildren = Omit<SlotProps, 'children'>;
+
+export function useItemKeys<ItemT>(
+  data: readonly ItemT[],
+  keyExtractor: ListForEachProps<ItemT>['keyExtractor']
+): string[] {
+  const keyExtractorRef = useRef(keyExtractor);
+  keyExtractorRef.current = keyExtractor;
+  return useMemo(() => {
+    const keys = data.map((item, index) => keyExtractorRef.current(item, index));
+    if (keys.some((key) => typeof key !== 'string') || new Set(keys).size !== keys.length) {
+      throw new Error('List.ForEach keyExtractor must return a unique string for every item.');
+    }
+    return keys;
+  }, [data]);
+}
+
+/**
+ * Renders a window of recycled rows inside List or Section.
+ * Rows show placeholders while JS prepares content. Native keys still cover the full data set.
+ * @platform ios
+ */
+export function DataListForEach<ItemT>({
+  data,
+  keyExtractor,
+  children: renderItem,
+  overscanCount = 10,
+  estimatedItemSize = 64,
+  modifiers,
+  onDelete,
+  onMove,
+  ...props
+}: ListForEachProps<ItemT>) {
+  if (!Number.isSafeInteger(overscanCount) || overscanCount < 0) {
+    throw new Error('List.ForEach overscanCount must be a non-negative integer.');
+  }
+  if (!Number.isFinite(estimatedItemSize) || estimatedItemSize <= 0) {
+    throw new Error('List.ForEach estimatedItemSize must be a positive finite number.');
+  }
+  const itemKeys = useItemKeys(data, keyExtractor);
+  const [state, setState] = useState({
+    keys: itemKeys,
+    first: 0,
+    last: 0,
+    revision: 0,
+    capacity: 0,
+    overscanCount,
+  });
+  let current = state;
+  if (state.keys !== itemKeys) {
+    const previousKey = state.keys[state.first];
+    const anchor = previousKey === undefined ? 0 : Math.max(0, itemKeys.indexOf(previousKey));
+    current = {
+      ...state,
+      keys: itemKeys,
+      first: Math.min(anchor, Math.max(0, data.length - 1)),
+      last: Math.min(anchor + state.last - state.first, Math.max(0, data.length - 1)),
+      revision: state.revision + 1,
+    };
+  }
+  if (current.overscanCount !== overscanCount) {
+    current = { ...current, overscanCount, capacity: 0 };
+  }
+  if (current !== state) setState(current);
+  const { start, capacity } = getWindow(
+    data.length,
+    current.first,
+    current.last,
+    overscanCount,
+    current.capacity
+  );
+  const committedRevision = useRef(current.revision);
+  useLayoutEffect(() => {
+    committedRevision.current = current.revision;
+  }, [current.revision]);
+  const indices = getSlotIndices(start, capacity);
+
+  return (
+    <NativeList
+      {...props}
+      modifiers={modifiers}
+      {...(modifiers ? createViewModifierEventListener(modifiers) : undefined)}
+      deleteEnabled={!!onDelete}
+      moveEnabled={!!onMove}
+      onDelete={
+        onDelete
+          ? ({ nativeEvent }) => {
+              if (nativeEvent.revision === committedRevision.current) onDelete(nativeEvent.indices);
+            }
+          : undefined
+      }
+      onMove={
+        onMove
+          ? ({ nativeEvent }) => {
+              if (nativeEvent.revision === committedRevision.current) {
+                onMove(nativeEvent.sourceIndices, nativeEvent.destination);
+              }
+            }
+          : undefined
+      }
+      itemKeys={itemKeys}
+      revision={current.revision}
+      estimatedItemSize={estimatedItemSize}
+      onWindowChange={({ nativeEvent: event }) => {
+        if (
+          !Number.isSafeInteger(event.first) ||
+          !Number.isSafeInteger(event.last) ||
+          event.last < event.first
+        ) {
+          return;
+        }
+        setState((previous) => {
+          // Ignore requests from before a data change.
+          if (event.revision !== previous.revision) return previous;
+          const maximum = Math.max(0, previous.keys.length - 1);
+          const first = Math.max(0, Math.min(event.first, maximum));
+          const last = Math.max(first, Math.min(event.last, maximum));
+          const { capacity } = getWindow(
+            previous.keys.length,
+            first,
+            last,
+            previous.overscanCount,
+            previous.capacity
+          );
+          return first === previous.first &&
+            last === previous.last &&
+            capacity === previous.capacity
+            ? previous
+            : { ...previous, first, last, capacity };
+        });
+      }}>
+      <NativePool>
+        {indices.map((index, slot) => {
+          const item = data[index];
+          const itemKey = itemKeys[index];
+          if (item === undefined || itemKey === undefined) {
+            throw new Error(`List.ForEach could not resolve the item at index ${index}.`);
+          }
+          return (
+            <RecycledRow
+              key={slot}
+              item={item}
+              index={index}
+              itemKey={itemKey}
+              revision={current.revision}
+              renderItem={renderItem}
+            />
+          );
+        })}
+      </NativePool>
+    </NativeList>
+  );
+}