@expo/ui 58.0.6 → 58.0.8

package/CHANGELOG.md

@@ -10,6 +10,24 @@
 
 ### 💡 Others
 
+## 58.0.8 — 2026-09-28
+
+### 🎉 New features
+
+- [iOS] Export the `FrameAlignment` type for the `alignment` parameter of `frame()`. ([#50702](https://github.com/expo/expo/pull/50702) by [@amandeepmittal](https://github.com/amandeepmittal))
+- [Android] Add `contentDescription` to the `semantics` modifier, so TalkBack can announce a label other than the visible content. ([#50688](https://github.com/expo/expo/pull/50688) by [@enavermate](https://github.com/enavermate))
+- Added `get()` and `set()` to the universal `ObservableState` type and to the web implementation of `useNativeState`, as React Compiler-compliant alternatives to `.value`. ([#50684](https://github.com/expo/expo/pull/50684) by [@Den1Marshall](https://github.com/Den1Marshall))
+
+## 58.0.7 — 2026-09-25
+
+### 🎉 New features
+
+- [iOS] Added `presentationCornerRadius` modifier. ([#50632](https://github.com/expo/expo/pull/50632) by [@shanelord01](https://github.com/shanelord01))
+
+### 🐛 Bug fixes
+
+- [iOS] Fixed `onPress` on universal components such as `Row` and `Column` not firing when tapping empty space, such as a `Spacer`. ([#50599](https://github.com/expo/expo/pull/50599) by [@expo-bot](https://github.com/expo-bot))
+
 ## 58.0.6 — 2026-09-23
 
 ### 🛠 Breaking changes
@@ -19,6 +37,7 @@
 ### 🎉 New features
 
 - [iOS] `List.ForEach` recycles rows from a small pool around the visible range, so large lists only render the rows near the viewport. Deprecated element children in favor of this form. ([#49975](https://github.com/expo/expo/pull/49975) by [@nishan](https://github.com/intergalacticspacehighway))
+- [Android] Added `LazyColumn.Items` and `LazyRow.Items`, which render rows from `data` and `keyExtractor` with a `children` function: `{({ item, index }) => <Row item={item} />}`. Rows are recycled from a small pool around the visible range, so large lists only render the rows near the viewport. Set `recycling={false}` to render every row. ([#50258](https://github.com/expo/expo/pull/50258) by [@nishan](https://github.com/intergalacticspacehighway))
 
 ## 58.0.5 — 2026-09-22
 
@@ -101,6 +120,7 @@
 
 ### 🐛 Bug fixes
 
+- [Android] Fix hosted React Native content sliding off the top of a `BottomSheet` when the keyboard opens. ([#49399](https://github.com/expo/expo/issues/49399) by [@starsky-nev](https://github.com/starsky-nev)) ([#49427](https://github.com/expo/expo/pull/49427) by [@intergalacticspacehighway](https://github.com/intergalacticspacehighway))
 - [Android] Fix `DatePickerDialog` preselecting today when `initialDate` is omitted, and keep its confirm button disabled while no date is selected so `onDateSelected` never receives an invalid date. ([#49898](https://github.com/expo/expo/pull/49898) by [@pataar](https://github.com/pataar))
 - [Android][iOS] Fix `community/bottom-sheet` content shrinking to its own width instead of filling the sheet when the sheet sizes to its content. ([#49742](https://github.com/expo/expo/issues/49742) by [@agung-adhinata](https://github.com/agung-adhinata)) ([#49762](https://github.com/expo/expo/pull/49762) by [@intergalacticspacehighway](https://github.com/intergalacticspacehighway))
 - [Android] Fixed a `Text` or an `Icon` with no explicit color rendering black inside `Host`, which made it unreadable in the dark color scheme. `Host` now provides `LocalContentColor` from the color scheme. ([#49697](https://github.com/expo/expo/pull/49697) by [@expo-bot](https://github.com/expo-bot))

package/android/build.gradle

@@ -12,13 +12,13 @@ apply plugin: 'expo-module-gradle-plugin'
 apply plugin: 'org.jetbrains.kotlin.plugin.compose'
 
 group = 'expo.modules.ui'
-version = '58.0.6'
+version = '58.0.8'
 
 android {
   namespace "expo.modules.ui"
   defaultConfig {
     versionCode 1
-    versionName "58.0.6"
+    versionName "58.0.8"
     testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
   }
   buildFeatures {

package/android/src/main/java/expo/modules/ui/ExpoUIModule.kt

@@ -203,6 +203,15 @@ class ExpoUIModule : Module() {
     }
     View(LazyColumnView::class)
     View(LazyRowView::class)
+    View(LazyItemsView::class) {
+      Events("onWindowChange")
+
+      OnViewDestroys { view: LazyItemsView ->
+        view.cancelPendingWindowChange()
+      }
+    }
+    View(LazyItemsPoolView::class)
+    View(LazyItemsSlotView::class)
 
     // Class-based views so TooltipBoxView can detect them by type via findChildOfType
     View(PlainTooltipView::class)

package/android/src/main/java/expo/modules/ui/LazyColumnView.kt

@@ -69,7 +69,8 @@ class LazyColumnView(context: Context, appContext: AppContext) :
     val padding = props.contentPadding.value
 
     LazyColumn(
-      modifier = ModifierRegistry.applyModifiers(props.modifiers.value, appContext, this@Content, globalEventDispatcher),
+      modifier = ModifierRegistry.applyModifiers(props.modifiers.value, appContext, this@Content, globalEventDispatcher)
+        .lazyRecycledItemsCrossAxis(this@LazyColumnView, isVertical = true),
       verticalArrangement = verticalArrangement,
       horizontalAlignment = horizontalAlignment,
       contentPadding = PaddingValues(
@@ -82,6 +83,10 @@ class LazyColumnView(context: Context, appContext: AppContext) :
       val count = composableChildCount.intValue
       for (index in 0..<count) {
         val child = getChildAt(index) as? ExpoComposeView<*> ?: continue
+        if (child is LazyItemsView) {
+          lazyRecycledItems(child, this@Content, isVertical = true)
+          continue
+        }
         item {
           with(this@Content) {
             with(child) {

package/android/src/main/java/expo/modules/ui/LazyItemsView.kt

@@ -0,0 +1,313 @@
+package expo.modules.ui
+
+import android.annotation.SuppressLint
+import android.content.Context
+import android.os.Handler
+import android.os.Looper
+import android.view.View
+import android.view.ViewGroup
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxHeight
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.width
+import androidx.compose.foundation.lazy.LazyListScope
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.DisposableEffect
+import androidx.compose.runtime.MutableIntState
+import androidx.compose.runtime.MutableState
+import androidx.compose.runtime.mutableIntStateOf
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.layout.layout
+import androidx.compose.ui.layout.onSizeChanged
+import androidx.compose.ui.platform.LocalDensity
+import androidx.compose.ui.unit.dp
+import expo.modules.kotlin.AppContext
+import expo.modules.kotlin.records.Field
+import expo.modules.kotlin.records.Record
+import expo.modules.kotlin.viewevent.EventDispatcher
+import expo.modules.kotlin.views.ComposableScope
+import expo.modules.kotlin.views.ComposeProps
+import expo.modules.kotlin.views.ExpoComposeView
+import expo.modules.kotlin.views.OptimizedComposeProps
+
+@OptimizedComposeProps
+data class LazyItemsProps(
+  val itemKeys: MutableState<List<String>> = mutableStateOf(emptyList()),
+  val revision: MutableState<Int> = mutableStateOf(0),
+  val estimatedItemSize: MutableState<Double> = mutableStateOf(64.0)
+) : ComposeProps
+
+internal data class WindowChangeEvent(
+  @Field val first: Int,
+  @Field val last: Int,
+  @Field val revision: Int
+) : Record
+
+/**
+ * A block of recycled items inside [LazyColumnView] or [LazyRowView]. It renders no content of its
+ * own: [lazyRecycledItems] expands it into one lazy item per key, each backed by a slot of its
+ * pool child.
+ */
+@SuppressLint("ViewConstructor")
+class LazyItemsView(context: Context, appContext: AppContext) :
+  ExpoComposeView<LazyItemsProps>(context, appContext) {
+  override val props = LazyItemsProps()
+  private val onWindowChange by EventDispatcher<WindowChangeEvent>()
+
+  internal val pool: MutableState<LazyItemsPoolView?> = mutableStateOf(null)
+  internal val window = LazyItemsWindow { first, last, revision ->
+    onWindowChange(WindowChangeEvent(first, last, revision))
+  }
+
+  override fun onViewAdded(child: View?) {
+    super.onViewAdded(child)
+    pool.value = findChildOfType<LazyItemsPoolView>(this)
+  }
+
+  override fun onViewRemoved(child: View?) {
+    super.onViewRemoved(child)
+    pool.value = findChildOfType<LazyItemsPoolView>(this)
+  }
+
+  internal fun cancelPendingWindowChange() {
+    window.cancel()
+  }
+
+  @Composable
+  override fun ComposableScope.Content() = Unit
+}
+
+@OptimizedComposeProps
+class LazyItemsPoolProps : ComposeProps
+
+/**
+ * Holds the recycled slots, so mounting a slot never republishes the props of [LazyItemsView].
+ */
+@SuppressLint("ViewConstructor")
+class LazyItemsPoolView(context: Context, appContext: AppContext) :
+  ExpoComposeView<LazyItemsPoolProps>(context, appContext) {
+  override val props = LazyItemsPoolProps()
+
+  internal val slotCount: MutableIntState = mutableIntStateOf(0)
+
+  override fun onViewAdded(child: View?) {
+    super.onViewAdded(child)
+    slotCount.intValue = childCount
+  }
+
+  override fun onViewRemoved(child: View?) {
+    super.onViewRemoved(child)
+    slotCount.intValue = childCount
+  }
+
+  @Composable
+  override fun ComposableScope.Content() = Unit
+}
+
+@OptimizedComposeProps
+data class LazyItemsSlotProps(
+  val itemKey: MutableState<String> = mutableStateOf(""),
+  val index: MutableState<Int> = mutableStateOf(0),
+  val revision: MutableState<Int> = mutableStateOf(0)
+) : ComposeProps
+
+/**
+ * One recycled slot. JS assigns item `index` to slot `index % slotCount` and republishes these
+ * props when the slot moves to another item.
+ */
+@SuppressLint("ViewConstructor")
+class LazyItemsSlotView(context: Context, appContext: AppContext) :
+  ExpoComposeView<LazyItemsSlotProps>(context, appContext) {
+  override val props = LazyItemsSlotProps()
+
+  @Composable
+  override fun ComposableScope.Content() {
+    Children(this)
+  }
+}
+
+/**
+ * Expands a [LazyItemsView] child into one lazy item per key. An item composes its slot only while
+ * the slot still carries that item, and shows a placeholder of the measured or estimated size
+ * while JS moves the slot over.
+ */
+internal fun LazyListScope.lazyRecycledItems(
+  view: LazyItemsView,
+  scope: ComposableScope,
+  isVertical: Boolean
+) {
+  val keys = view.props.itemKeys.value
+  val revision = view.props.revision.value
+  val estimatedItemSize = view.props.estimatedItemSize.value
+  if (keys.isEmpty()) {
+    return
+  }
+  val window = view.window
+  items(count = keys.size, key = { keys[it] }) { index ->
+    val itemKey = keys[index]
+    val token = remember(itemKey, index, revision) { Any() }
+    DisposableEffect(token) {
+      window.appear(itemKey, index, token, revision, keys)
+      onDispose { window.disappear(itemKey, token) }
+    }
+
+    val pool = view.pool.value
+    val slotCount = pool?.slotCount?.intValue ?: 0
+    val slot = if (pool != null && slotCount > 0) {
+      pool.getChildAt(index % slotCount) as? LazyItemsSlotView
+    } else {
+      null
+    }
+    // A slot carries this item only until JS moves it to another one.
+    val content = slot?.takeIf {
+      it.props.itemKey.value == itemKey &&
+        it.props.index.value == index &&
+        it.props.revision.value == revision
+    }
+
+    val density = LocalDensity.current
+    val placeholderSize = with(density) {
+      window.size(itemKey, estimatedItemSize.dp.roundToPx()).toDp()
+    }
+    Box(
+      modifier = Modifier.onSizeChanged { size ->
+        if (content != null) {
+          window.measure(itemKey, if (isVertical) size.height else size.width, revision)
+        }
+      }
+    ) {
+      if (content != null) {
+        with(scope) {
+          with(content) {
+            Content()
+          }
+        }
+      } else {
+        Spacer(
+          modifier = if (isVertical) {
+            Modifier.fillMaxWidth().height(placeholderSize)
+          } else {
+            Modifier.fillMaxHeight().width(placeholderSize)
+          }
+        )
+      }
+    }
+  }
+}
+
+/**
+ * Clears the cached item sizes of every [LazyItemsView] child when the list's cross-axis
+ * constraint changes. It runs before the items measure, so it never discards fresh sizes.
+ */
+internal fun Modifier.lazyRecycledItemsCrossAxis(list: ViewGroup, isVertical: Boolean): Modifier =
+  layout { measurable, constraints ->
+    val crossAxisSize = if (isVertical) constraints.maxWidth else constraints.maxHeight
+    for (index in 0..<list.childCount) {
+      (list.getChildAt(index) as? LazyItemsView)?.window?.updateCrossAxisSize(crossAxisSize)
+    }
+    val placeable = measurable.measure(constraints)
+    layout(placeable.width, placeable.height) {
+      placeable.place(0, 0)
+    }
+  }
+
+/**
+ * Tracks the live items without triggering recomposition, and batches window requests to JS.
+ */
+internal class LazyItemsWindow(
+  private val send: (first: Int, last: Int, revision: Int) -> Unit
+) {
+  private val handler = Handler(Looper.getMainLooper())
+  private val appeared = mutableMapOf<String, Int>()
+  private val tokens = mutableMapOf<String, Any>()
+  private val sizes = mutableMapOf<String, Int>()
+  private var crossAxisSize = 0
+  private var revision = -1
+  private var pending = false
+  private var lastSent: Triple<Int, Int, Int>? = null
+
+  fun appear(key: String, index: Int, token: Any, revision: Int, keys: List<String>) {
+    reset(revision, keys)
+    if (index !in keys.indices || keys[index] != key) {
+      return
+    }
+    appeared[key] = index
+    tokens[key] = token
+    schedule()
+  }
+
+  fun disappear(key: String, token: Any) {
+    // Ignore callbacks from an item that has been replaced.
+    if (tokens[key] !== token) {
+      return
+    }
+    appeared.remove(key)
+    tokens.remove(key)
+    if (appeared.isEmpty()) {
+      lastSent = null
+    }
+    schedule()
+  }
+
+  fun size(key: String, fallback: Int): Int = sizes[key] ?: fallback
+
+  fun measure(key: String, size: Int, revision: Int) {
+    if (revision != this.revision || size <= 0) {
+      return
+    }
+    sizes[key] = size
+  }
+
+  fun updateCrossAxisSize(size: Int) {
+    if (size == crossAxisSize) {
+      return
+    }
+    if (crossAxisSize > 0) {
+      sizes.clear()
+    }
+    crossAxisSize = size
+  }
+
+  fun cancel() {
+    handler.removeCallbacksAndMessages(null)
+    pending = false
+  }
+
+  private fun reset(newRevision: Int, keys: List<String>) {
+    if (revision == newRevision) {
+      return
+    }
+    revision = newRevision
+    sizes.clear()
+    val positions = HashMap<String, Int>(keys.size)
+    keys.forEachIndexed { index, key -> positions[key] = index }
+    val kept = appeared.keys.mapNotNull { key -> positions[key]?.let { key to it } }
+    appeared.clear()
+    appeared.putAll(kept)
+    tokens.keys.retainAll { positions.containsKey(it) }
+    lastSent = null
+    schedule()
+  }
+
+  private fun schedule() {
+    if (pending) {
+      return
+    }
+    pending = true
+    handler.post {
+      pending = false
+      val first = appeared.values.minOrNull() ?: return@post
+      val last = appeared.values.maxOrNull() ?: return@post
+      val event = Triple(first, last, revision)
+      if (event == lastSent) {
+        return@post
+      }
+      lastSent = event
+      send(first, last, revision)
+    }
+  }
+}

package/android/src/main/java/expo/modules/ui/LazyRowView.kt

@@ -58,7 +58,8 @@ class LazyRowView(context: Context, appContext: AppContext) :
     val padding = props.contentPadding.value
 
     LazyRow(
-      modifier = ModifierRegistry.applyModifiers(props.modifiers.value, appContext, this@Content, globalEventDispatcher),
+      modifier = ModifierRegistry.applyModifiers(props.modifiers.value, appContext, this@Content, globalEventDispatcher)
+        .lazyRecycledItemsCrossAxis(this@LazyRowView, isVertical = false),
       horizontalArrangement = horizontalArrangement,
       verticalAlignment = verticalAlignment,
       contentPadding = PaddingValues(
@@ -71,6 +72,10 @@ class LazyRowView(context: Context, appContext: AppContext) :
       val count = composableChildCount.intValue
       for (index in 0..<count) {
         val child = getChildAt(index) as? ExpoComposeView<*> ?: continue
+        if (child is LazyItemsView) {
+          lazyRecycledItems(child, this@Content, isVertical = false)
+          continue
+        }
         item {
           with(this@Content) {
             with(child) {

package/android/src/main/java/expo/modules/ui/ModifierRegistry.kt

@@ -67,6 +67,7 @@ import androidx.compose.ui.layout.onVisibilityChanged
 import androidx.compose.ui.layout.positionInWindow
 import androidx.compose.ui.platform.LocalDensity
 import androidx.compose.ui.semantics.Role
+import androidx.compose.ui.semantics.contentDescription
 import androidx.compose.ui.semantics.contentType
 import androidx.compose.ui.semantics.semantics
 import androidx.compose.ui.unit.DpOffset
@@ -681,9 +682,16 @@ object ModifierRegistry {
 
     register("semantics") { map, _, appContext, _ ->
       val params = recordFromMap<SemanticsParams>(map, appContext)
-      params.contentType.toContentType()?.let { ct ->
-        Modifier.semantics { contentType = ct }
-      } ?: Modifier
+      val type = params.contentType.toContentType()
+      val description = params.contentDescription
+      if (type == null && description == null) {
+        Modifier
+      } else {
+        Modifier.semantics {
+          type?.let { contentType = it }
+          description?.let { contentDescription = it }
+        }
+      }
     }
 
     register("clip") { map, _, appContext, _ ->

package/android/src/main/java/expo/modules/ui/RNHostView.kt

@@ -10,9 +10,11 @@ import android.view.ViewParent
 import android.widget.FrameLayout
 import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.layout.requiredSize
+import androidx.compose.foundation.layout.wrapContentSize
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.MutableState
 import androidx.compose.runtime.mutableStateOf
+import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.layout.onGloballyPositioned
 import androidx.compose.ui.layout.onSizeChanged
@@ -180,10 +182,22 @@ internal class RNHostView(context: Context, appContext: AppContext) :
 
     return with(density) {
       if (childSize.width > 0 && childSize.height > 0) {
-        Modifier.requiredSize(
-          childSize.width.toDp(),
-          childSize.height.toDp()
-        )
+        // When RNHostView's size is greater than its parent, then parent centers RNHostView and truncates its top and bottom.
+        // e.g. Parent size = 200px, RNHostView size = 300px, the parent will position the RNHostView at center and truncate 50px from top and bottom.
+        // This causes issues where the top of RNHostView can go out of screen.
+        // These scenario mostly happen when a Keyboard opens in a sheet.
+        // https://github.com/expo/expo/issues/49399
+        // Adding wrapContentSize with Alignment.TopCenter and unbounded = true
+        // makes sure that the RNHostView is always positioned at the top of its parent.
+        // Only the vertical axis changes. A matchContents child is measured unconstrained, so it is
+        // routinely wider than its Compose slot, and centering it horizontally is what keeps its
+        // contents lined up with the parent.
+        Modifier
+          .wrapContentSize(Alignment.TopCenter, unbounded = true)
+          .requiredSize(
+            childSize.width.toDp(),
+            childSize.height.toDp()
+          )
       } else {
         Modifier
       }

package/android/src/main/java/expo/modules/ui/SemanticsModifier.kt

@@ -7,7 +7,8 @@ import expo.modules.kotlin.types.OptimizedRecord
 
 @OptimizedRecord
 internal data class SemanticsParams(
-  @Field val contentType: String? = null
+  @Field val contentType: String? = null,
+  @Field val contentDescription: String? = null
 ) : Record
 
 internal fun String?.toContentType(): ContentType? = when (this) {

package/build/jetpack-compose/LazyColumn/index.d.ts

@@ -49,3 +49,9 @@ export interface LazyColumnProps {
  * A lazy column component that efficiently displays a vertically scrolling list.
  */
 export declare function LazyColumn(props: LazyColumnProps): import("react").JSX.Element;
+export declare namespace LazyColumn {
+    var Items: {
+        <ItemT>({ recycling, ...props }: import("..").LazyItemsProps<ItemT>): import("react").JSX.Element;
+        displayName: string;
+    };
+}

package/build/jetpack-compose/LazyColumn/index.js

@@ -1,5 +1,6 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { requireNativeView } from 'expo';
+import { LazyItems } from '../LazyItems';
 import { createViewModifierEventListener } from '../modifiers/utils';
 const LazyColumnNativeView = requireNativeView('ExpoUI', 'LazyColumnView');
 function transformProps(props) {
@@ -17,5 +18,6 @@ function transformProps(props) {
         ...transformProps(props)
     });
 }
+LazyColumn.Items = LazyItems;
 
 //# sourceMappingURL=index.js.map

package/build/jetpack-compose/LazyColumn/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["jetpack-compose/LazyColumn/index.tsx"],"sourcesContent":[null],"names":["requireNativeView","createViewModifierEventListener","LazyColumnNativeView","transformProps","props","modifiers","restProps","undefined","LazyColumn"],"mappings":";AAAA,SAASA,iBAAiB,QAAQ,OAAO;AAGzC,SAASC,+BAA+B,QAAQ,qBAAqB;AAwDrE,MAAMC,uBAAmEF,kBACvE,UACA;AAGF,SAASG,eAAeC,KAAsB;IAC5C,MAAM,EAAEC,SAAS,EAAE,GAAGC,WAAW,GAAGF;IACpC,OAAO;QACLC;QACA,GAAIA,YAAYJ,gCAAgCI,aAAaE,SAAS;QACtE,GAAGD,SAAS;IACd;AACF;AAEA;;CAEC,GACD,OAAO,SAASE,WAAWJ,KAAsB;IAC/C,qBAAO,KAACF;QAAsB,GAAGC,eAAeC,MAAM;;AACxD"}
+{"version":3,"sources":["jetpack-compose/LazyColumn/index.tsx"],"sourcesContent":[null],"names":["requireNativeView","LazyItems","createViewModifierEventListener","LazyColumnNativeView","transformProps","props","modifiers","restProps","undefined","LazyColumn","Items"],"mappings":";AAAA,SAASA,iBAAiB,QAAQ,OAAO;AAGzC,SAASC,SAAS,QAAQ,eAAe;AACzC,SAASC,+BAA+B,QAAQ,qBAAqB;AAwDrE,MAAMC,uBAAmEH,kBACvE,UACA;AAGF,SAASI,eAAeC,KAAsB;IAC5C,MAAM,EAAEC,SAAS,EAAE,GAAGC,WAAW,GAAGF;IACpC,OAAO;QACLC;QACA,GAAIA,YAAYJ,gCAAgCI,aAAaE,SAAS;QACtE,GAAGD,SAAS;IACd;AACF;AAEA;;CAEC,GACD,OAAO,SAASE,WAAWJ,KAAsB;IAC/C,qBAAO,KAACF;QAAsB,GAAGC,eAAeC,MAAM;;AACxD;AAEAI,WAAWC,KAAK,GAAGT"}

package/build/jetpack-compose/LazyItems/index.d.ts

@@ -0,0 +1,54 @@
+import { type RenderItem } from '../../recycling/useRecycledRows';
+export interface LazyItemsProps<ItemT> {
+    /** Items to display. Replace the array when updating data. */
+    data: readonly ItemT[];
+    /** Returns a stable, unique string key, also used as the lazy list item key. */
+    keyExtractor: (item: ItemT, index: number) => string;
+    /**
+     * Renders a row. 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: RenderItem<ItemT>;
+    /**
+     * 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 size in dp along the scroll axis, until a row is measured. Must be positive.
+     * Measurements reset when the data changes. In `LazyColumn.Items` they also reset when the list
+     * width changes. Ignored when `recycling` is `false`.
+     * @default 64
+     */
+    estimatedItemSize?: number;
+}
+/**
+ * A block of recycled rows inside `LazyColumn` or `LazyRow`, mirroring the Compose
+ * `items(count, key)` builder. Only a small pool of rows around the visible range is mounted,
+ * so large data sets stay cheap. Rows that are not ready yet show a placeholder of
+ * `estimatedItemSize`, or of the size last measured for that item.
+ *
+ * Mount it as a direct child of `LazyColumn` or `LazyRow`. Plain children of the same list stay
+ * single items, so static and recycled content can be mixed in order.
+ * @platform android
+ */
+export declare const LazyItems: {
+    <ItemT>({ recycling, ...props }: LazyItemsProps<ItemT>): import("react").JSX.Element;
+    displayName: string;
+};
+/**
+ * @hidden
+ * Creates the `Items` component of one lazy list, so its errors name that list.
+ */
+export declare function createLazyItems(componentName: string): {
+    <ItemT>({ recycling, ...props }: LazyItemsProps<ItemT>): import("react").JSX.Element;
+    displayName: string;
+};

package/build/jetpack-compose/LazyItems/index.js

@@ -0,0 +1,63 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { requireNativeView } from 'expo';
+import { Fragment } from 'react';
+import { useItemKeys, useRecycledRows } from '../../recycling/useRecycledRows';
+const LazyItemsNativeView = requireNativeView('ExpoUI', 'LazyItemsView');
+const LazyItemsSlotNativeView = requireNativeView('ExpoUI', 'LazyItemsSlotView');
+const LazyItemsPoolNativeView = requireNativeView('ExpoUI', 'LazyItemsPoolView');
+/**
+ * A block of recycled rows inside `LazyColumn` or `LazyRow`, mirroring the Compose
+ * `items(count, key)` builder. Only a small pool of rows around the visible range is mounted,
+ * so large data sets stay cheap. Rows that are not ready yet show a placeholder of
+ * `estimatedItemSize`, or of the size last measured for that item.
+ *
+ * Mount it as a direct child of `LazyColumn` or `LazyRow`. Plain children of the same list stay
+ * single items, so static and recycled content can be mixed in order.
+ * @platform android
+ */ export const LazyItems = createLazyItems('LazyColumn.Items');
+/**
+ * @hidden
+ * Creates the `Items` component of one lazy list, so its errors name that list.
+ */ export function createLazyItems(componentName) {
+    function Items({ recycling = true, ...props }) {
+        return recycling ? /*#__PURE__*/ _jsx(RecycledItems, {
+            ...props
+        }) : /*#__PURE__*/ _jsx(StaticItems, {
+            ...props
+        });
+    }
+    // Each row is a plain child of the lazy list, so it becomes one lazy item.
+    function StaticItems({ data, keyExtractor, children: renderItem }) {
+        const itemKeys = useItemKeys(componentName, data, keyExtractor);
+        return data.map((item, index)=>/*#__PURE__*/ _jsx(Fragment, {
+                children: renderItem({
+                    item,
+                    index
+                })
+            }, itemKeys[index]));
+    }
+    function RecycledItems({ data, keyExtractor, children: renderItem, overscanCount, estimatedItemSize = 64 }) {
+        const { itemKeys, revision, rows, onWindowChange } = useRecycledRows({
+            componentName,
+            Slot: LazyItemsSlotNativeView,
+            data,
+            keyExtractor,
+            renderItem,
+            overscanCount,
+            estimatedItemSize
+        });
+        return /*#__PURE__*/ _jsx(LazyItemsNativeView, {
+            itemKeys: itemKeys,
+            revision: revision,
+            estimatedItemSize: estimatedItemSize,
+            onWindowChange: ({ nativeEvent })=>onWindowChange(nativeEvent),
+            children: /*#__PURE__*/ _jsx(LazyItemsPoolNativeView, {
+                children: rows
+            })
+        });
+    }
+    Items.displayName = componentName;
+    return Items;
+}
+
+//# sourceMappingURL=index.js.map

package/build/jetpack-compose/LazyItems/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["jetpack-compose/LazyItems/index.tsx"],"sourcesContent":[null],"names":["requireNativeView","Fragment","useItemKeys","useRecycledRows","LazyItemsNativeView","LazyItemsSlotNativeView","LazyItemsPoolNativeView","LazyItems","createLazyItems","componentName","Items","recycling","props","RecycledItems","StaticItems","data","keyExtractor","children","renderItem","itemKeys","map","item","index","overscanCount","estimatedItemSize","revision","rows","onWindowChange","Slot","nativeEvent","displayName"],"mappings":";AAAA,SAASA,iBAAiB,QAAQ,OAAO;AACzC,SAASC,QAAQ,QAA2B,QAAQ;AAEpD,SACEC,WAAW,EACXC,eAAe,QAIV,kCAAkC;AA0CzC,MAAMC,sBACJJ,kBAAwC,UAAU;AACpD,MAAMK,0BACJL,kBAAqC,UAAU;AACjD,MAAMM,0BACJN,kBAAkB,UAAU;AAE9B;;;;;;;;;CASC,GACD,OAAO,MAAMO,YAAYC,gBAAgB,oBAAoB;AAE7D;;;CAGC,GACD,OAAO,SAASA,gBAAgBC,aAAqB;IACnD,SAASC,MAAa,EAAEC,YAAY,IAAI,EAAE,GAAGC,OAA8B;QACzE,OAAOD,0BAAY,KAACE;YAAe,GAAGD,KAAK;2BAAO,KAACE;YAAa,GAAGF,KAAK;;IAC1E;IAEA,2EAA2E;IAC3E,SAASE,YAAmB,EAC1BC,IAAI,EACJC,YAAY,EACZC,UAAUC,UAAU,EACqB;QACzC,MAAMC,WAAWjB,YAAYO,eAAeM,MAAMC;QAClD,OAAOD,KAAKK,GAAG,CAAC,CAACC,MAAMC,sBACrB,KAACrB;0BAAgCiB,WAAW;oBAAEG;oBAAMC;gBAAM;eAA3CH,QAAQ,CAACG,MAAM;IAElC;IAEA,SAAST,cAAqB,EAC5BE,IAAI,EACJC,YAAY,EACZC,UAAUC,UAAU,EACpBK,aAAa,EACbC,oBAAoB,EAAE,EACmB;QACzC,MAAM,EAAEL,QAAQ,EAAEM,QAAQ,EAAEC,IAAI,EAAEC,cAAc,EAAE,GAAGxB,gBAAgB;YACnEM;YACAmB,MAAMvB;YACNU;YACAC;YACAE;YACAK;YACAC;QACF;QAEA,qBACE,KAACpB;YACCe,UAAUA;YACVM,UAAUA;YACVD,mBAAmBA;YACnBG,gBAAgB,CAAC,EAAEE,WAAW,EAAE,GAAKF,eAAeE;sBACpD,cAAA,KAACvB;0BAAyBoB;;;IAGhC;IACAhB,MAAMoB,WAAW,GAAGrB;IACpB,OAAOC;AACT"}