@expo/ui 55.0.0 → 55.0.2

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

@@ -2,86 +2,240 @@ package expo.modules.ui
 
 import android.annotation.SuppressLint
 import android.content.Context
+import android.util.Log
+import android.view.MotionEvent
 import android.view.View
 import android.view.ViewGroup
-import androidx.compose.foundation.rememberScrollState
-import androidx.compose.foundation.verticalScroll
+import android.widget.FrameLayout
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.requiredSize
 import androidx.compose.runtime.Composable
+import androidx.compose.runtime.DisposableEffect
 import androidx.compose.runtime.MutableState
 import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.layout.onSizeChanged
+import androidx.compose.ui.platform.LocalDensity
+import androidx.compose.ui.unit.IntSize
 import androidx.compose.ui.viewinterop.AndroidView
-import com.facebook.react.ReactRootView
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.common.annotations.UnstableReactNativeAPI
+import com.facebook.react.config.ReactFeatureFlags
+import com.facebook.react.uimanager.JSPointerDispatcher
+import com.facebook.react.uimanager.JSTouchDispatcher
+import com.facebook.react.uimanager.RootView
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.UIManagerHelper
+import com.facebook.react.uimanager.events.EventDispatcher
 import expo.modules.kotlin.AppContext
 import expo.modules.kotlin.views.ComposableScope
 import expo.modules.kotlin.views.ComposeProps
 import expo.modules.kotlin.views.ExpoComposeView
 import expo.modules.kotlin.views.RNHostViewInterface
-import expo.modules.kotlin.views.ShadowNodeProxy
-import java.lang.ref.WeakReference
 
-internal data class RNHostProps(
-  val matchContents: MutableState<Boolean?> = mutableStateOf(null),
-  val verticalScrollEnabled: MutableState<Boolean?> = mutableStateOf(null),
-  val modifiers: MutableState<ModifierList> = mutableStateOf(emptyList())
+internal data class RNHostViewProps(
+  val matchContents: MutableState<Boolean?> = mutableStateOf(null)
 ) : ComposeProps
 
 @SuppressLint("ViewConstructor")
 internal class RNHostView(context: Context, appContext: AppContext) :
-  ExpoComposeView<RNHostProps>(context, appContext), RNHostViewInterface {
-  override val props = RNHostProps()
-  override var matchContents: Boolean = false
-    get() = props.matchContents.value ?: false
+  ExpoComposeView<RNHostViewProps>(context, appContext) {
+  companion object {
+    private const val TAG = "RNHostView"
+  }
+
+  override val props = RNHostViewProps()
+
+  private val childViewState = mutableStateOf<View?>(null)
+  private val wrapperState = mutableStateOf<TouchDispatchingRootViewGroup?>(null)
+
+  override fun addView(child: View, index: Int, params: ViewGroup.LayoutParams) {
+    childViewState.value = child
+    val wrapper = TouchDispatchingRootViewGroup(child.context).apply {
+      val reactContext = child.context as? ReactContext
+      if (reactContext != null) {
+        eventDispatcher = UIManagerHelper.getEventDispatcherForReactTag(reactContext, child.id)
+      } else {
+        Log.e(TAG, "RNHostView: child context is not a ReactContext, touch events will not be dispatched to JS")
+      }
+      addView(child, FrameLayout.LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT))
+    }
+    wrapperState.value = wrapper
+  }
 
-  private val container = RNHostContainerView(context, WeakReference(shadowNodeProxy))
+  override fun removeView(view: View) {
+    if (view == childViewState.value) {
+      wrapperState.value?.removeView(view)
+      childViewState.value = null
+      wrapperState.value = null
+    } else {
+      super.removeView(view)
+    }
+  }
+
+  override fun removeViewAt(index: Int) {
+    childViewState.value?.let { child ->
+      wrapperState.value?.removeView(child)
+    }
+    childViewState.value = null
+    wrapperState.value = null
+  }
 
   @Composable
   override fun ComposableScope.Content() {
-    val (verticalScrollEnabled) = props.verticalScrollEnabled
-    val (modifiers) = props.modifiers
-
-    AndroidView(
-      factory = {
-        container
-      },
-      modifier = ModifierRegistry.applyModifiers(modifiers, appContext, this@Content, globalEventDispatcher)
-        .then(if (verticalScrollEnabled == true) Modifier.verticalScroll(rememberScrollState()) else Modifier)
-    )
+    val matchContents = props.matchContents.value ?: false
+
+    wrapperState.value?.let { wrapper ->
+      val childView = childViewState.value ?: return@let
+      if (matchContents) {
+        AndroidView(
+          factory = { wrapper },
+          modifier = applySizeFromYogaNodeModifier(childView)
+        )
+      } else {
+        AndroidView(
+          factory = { wrapper },
+          modifier = Modifier
+            .fillMaxSize()
+            .then(reportSizeToYogaNodeModifier())
+        )
+      }
+    }
   }
 
-  override fun addView(child: View, index: Int, params: ViewGroup.LayoutParams) {
-    container.addView(child, index, params)
+  // Sets Compose view size from Yoga node size
+  // Listens yoga node size changes and updates the Compose view size
+  @Composable
+  private fun applySizeFromYogaNodeModifier(childView: View): Modifier {
+    val density = LocalDensity.current
+
+    val childSize = remember {
+      mutableStateOf(
+        if (childView.width > 0 && childView.height > 0) IntSize(childView.width, childView.height)
+        else IntSize.Zero
+      )
+    }
+
+    DisposableEffect(childView) {
+      val listener = View.OnLayoutChangeListener { _, l, t, r, b, _, _, _, _ ->
+        childSize.value = IntSize(r - l, b - t)
+      }
+      childView.addOnLayoutChangeListener(listener)
+      onDispose { childView.removeOnLayoutChangeListener(listener) }
+    }
+
+    return with(density) {
+      if (childSize.value.width > 0 && childSize.value.height > 0) {
+        Modifier.requiredSize(
+          childSize.value.width.toDp(),
+          childSize.value.height.toDp()
+        )
+      } else {
+        Modifier
+      }
+    }
   }
 
-  override fun onMeasure(widthMeasureSpec: Int, heightMeasureSpec: Int) {
-    super.onMeasure(widthMeasureSpec, heightMeasureSpec)
-    container.measure(widthMeasureSpec, heightMeasureSpec)
-  }
-
-  override fun onLayout(
-    changed: Boolean,
-    left: Int,
-    top: Int,
-    right: Int,
-    bottom: Int
-  ) {
-    super.onLayout(changed, left, top, right, bottom)
-    val offsetX = paddingLeft
-    val offsetY = paddingRight
-    container.layout(offsetX, offsetY, offsetX + width, offsetY + height)
+  // Sets Yoga node size from Compose view size
+  // Listens Compose view size changes and updates the Yoga node size
+  @Composable
+  private fun reportSizeToYogaNodeModifier(): Modifier {
+    val density = LocalDensity.current
+    return Modifier.onSizeChanged { size ->
+      with(density) {
+        shadowNodeProxy.setViewSize(
+          size.width.toDp().value.toDouble(),
+          size.height.toDp().value.toDouble()
+        )
+      }
+    }
   }
 }
 
-internal class RNHostContainerView(context: Context, private val shadowNodeProxy: WeakReference<ShadowNodeProxy>) : ReactRootView(context) {
-  var matchContents = false
+/**
+ * A thin FrameLayout that intercepts touch events and dispatches them to JS via
+ * JSTouchDispatcher/JSPointerDispatcher, replicating the pattern from React Native's
+ * DialogRootViewGroup in ReactModalHostView.
+ */
+private class TouchDispatchingRootViewGroup(
+  context: Context
+) : FrameLayout(context), RootView {
+  private val jsTouchDispatcher = JSTouchDispatcher(this)
+  private var jsPointerDispatcher: JSPointerDispatcher? = null
+
+  var eventDispatcher: EventDispatcher? = null
+
+  private val reactContext: ThemedReactContext
+    get() = context as ThemedReactContext
+
+  init {
+    if (ReactFeatureFlags.dispatchPointerEvents) {
+      jsPointerDispatcher = JSPointerDispatcher(this)
+    }
+  }
+
+  override fun onMeasure(widthMeasureSpec: Int, heightMeasureSpec: Int) {
+    // Always gets called with EXACTLY mode
+    // because parent has either fillMaxSize (matchContents = false) or requiredSize (matchContents = true) modifiers
+    setMeasuredDimension(
+      MeasureSpec.getSize(widthMeasureSpec),
+      MeasureSpec.getSize(heightMeasureSpec)
+    )
+  }
 
   override fun onLayout(changed: Boolean, left: Int, top: Int, right: Int, bottom: Int) {
-    super.onLayout(changed, left, top, right, bottom)
-    if (matchContents && childCount > 1) {
-      val subview = getChildAt(0)
-      shadowNodeProxy.get()?.setViewSize(subview.width.toDouble(), subview.height.toDouble())
-    } else {
-      shadowNodeProxy.get()?.setViewSize(width.toDouble(), height.toDouble())
+    // No-op: don't re-layout children. Yoga calls child.layout() directly
+    // and we must not override those values.
+  }
+
+  override fun onInterceptTouchEvent(event: MotionEvent): Boolean {
+    eventDispatcher?.let { dispatcher ->
+      jsTouchDispatcher.handleTouchEvent(event, dispatcher, reactContext)
+      jsPointerDispatcher?.handleMotionEvent(event, dispatcher, true)
+    }
+    return super.onInterceptTouchEvent(event)
+  }
+
+  @SuppressLint("ClickableViewAccessibility")
+  override fun onTouchEvent(event: MotionEvent): Boolean {
+    eventDispatcher?.let { dispatcher ->
+      jsTouchDispatcher.handleTouchEvent(event, dispatcher, reactContext)
+      jsPointerDispatcher?.handleMotionEvent(event, dispatcher, false)
     }
+    super.onTouchEvent(event)
+    return true
+  }
+
+  override fun onInterceptHoverEvent(event: MotionEvent): Boolean {
+    eventDispatcher?.let { jsPointerDispatcher?.handleMotionEvent(event, it, true) }
+    return super.onInterceptHoverEvent(event)
+  }
+
+  override fun onHoverEvent(event: MotionEvent): Boolean {
+    eventDispatcher?.let { jsPointerDispatcher?.handleMotionEvent(event, it, false) }
+    return super.onHoverEvent(event)
+  }
+
+  @OptIn(UnstableReactNativeAPI::class)
+  override fun onChildStartedNativeGesture(childView: View?, ev: MotionEvent) {
+    eventDispatcher?.let { dispatcher ->
+      jsTouchDispatcher.onChildStartedNativeGesture(ev, dispatcher, reactContext)
+      jsPointerDispatcher?.onChildStartedNativeGesture(childView, ev, dispatcher)
+    }
+  }
+
+  override fun onChildEndedNativeGesture(childView: View, ev: MotionEvent) {
+    eventDispatcher?.let { jsTouchDispatcher.onChildEndedNativeGesture(ev, it) }
+    jsPointerDispatcher?.onChildEndedNativeGesture()
+  }
+
+  override fun requestDisallowInterceptTouchEvent(disallowIntercept: Boolean) {
+    // No-op - override to still receive events in onInterceptTouchEvent
+    // even when a child view disallows interception
+  }
+
+  override fun handleException(t: Throwable) {
+    reactContext.reactApplicationContext.handleException(RuntimeException(t))
   }
 }

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

@@ -25,12 +25,48 @@ class SwitchColors : Record {
   @Field
   val checkedTrackColor: Color? = null
 
+  @Field
+  val checkedBorderColor: Color? = null
+
+  @Field
+  val checkedIconColor: Color? = null
+
   @Field
   val uncheckedThumbColor: Color? = null
 
   @Field
   val uncheckedTrackColor: Color? = null
 
+  @Field
+  val uncheckedBorderColor: Color? = null
+
+  @Field
+  val uncheckedIconColor: Color? = null
+
+  @Field
+  val disabledCheckedThumbColor: Color? = null
+
+  @Field
+  val disabledCheckedTrackColor: Color? = null
+
+  @Field
+  val disabledCheckedBorderColor: Color? = null
+
+  @Field
+  val disabledCheckedIconColor: Color? = null
+
+  @Field
+  val disabledUncheckedThumbColor: Color? = null
+
+  @Field
+  val disabledUncheckedTrackColor: Color? = null
+
+  @Field
+  val disabledUncheckedBorderColor: Color? = null
+
+  @Field
+  val disabledUncheckedIconColor: Color? = null
+
   @Field
   val checkedColor: Color? = null
 
@@ -52,6 +88,7 @@ class SwitchColors : Record {
 
 data class SwitchProps(
   val value: Boolean = false,
+  val enabled: Boolean = true,
   val variant: String = "switch",
   val elementColors: SwitchColors = SwitchColors(),
   val modifiers: ModifierList = emptyList()
@@ -63,12 +100,14 @@ fun SwitchComposable(
   onCheckedChange: ((Boolean) -> Unit)?,
   colors: SwitchColors,
   modifier: Modifier = Modifier,
+  enabled: Boolean = true,
   thumbContent: (@Composable () -> Unit)? = null
 ) {
   Switch(
     checked = checked,
     onCheckedChange = onCheckedChange,
     modifier = modifier,
+    enabled = enabled,
     thumbContent = thumbContent,
     colors = SwitchDefaults.colors(
       // For some reason the default way of passing colors using `compose` results in a transparent view
@@ -76,20 +115,45 @@ fun SwitchComposable(
         ?: SwitchDefaults.colors().checkedThumbColor,
       checkedTrackColor = colors.checkedTrackColor.composeOrNull
         ?: SwitchDefaults.colors().checkedTrackColor,
+      checkedBorderColor = colors.checkedBorderColor.composeOrNull
+        ?: SwitchDefaults.colors().checkedBorderColor,
+      checkedIconColor = colors.checkedIconColor.composeOrNull
+        ?: SwitchDefaults.colors().checkedIconColor,
       uncheckedThumbColor = colors.uncheckedThumbColor.composeOrNull
         ?: SwitchDefaults.colors().uncheckedThumbColor,
       uncheckedTrackColor = colors.uncheckedTrackColor.composeOrNull
-        ?: SwitchDefaults.colors().uncheckedTrackColor
+        ?: SwitchDefaults.colors().uncheckedTrackColor,
+      uncheckedBorderColor = colors.uncheckedBorderColor.composeOrNull
+        ?: SwitchDefaults.colors().uncheckedBorderColor,
+      uncheckedIconColor = colors.uncheckedIconColor.composeOrNull
+        ?: SwitchDefaults.colors().uncheckedIconColor,
+      disabledCheckedBorderColor = colors.disabledCheckedBorderColor.composeOrNull
+        ?: SwitchDefaults.colors().disabledCheckedBorderColor,
+      disabledCheckedThumbColor = colors.disabledCheckedThumbColor.composeOrNull
+        ?: SwitchDefaults.colors().disabledCheckedThumbColor,
+      disabledCheckedTrackColor = colors.disabledCheckedTrackColor.composeOrNull
+        ?: SwitchDefaults.colors().disabledCheckedTrackColor,
+      disabledCheckedIconColor = colors.disabledCheckedIconColor.composeOrNull
+        ?: SwitchDefaults.colors().disabledCheckedIconColor,
+      disabledUncheckedBorderColor = colors.disabledUncheckedBorderColor.composeOrNull
+        ?: SwitchDefaults.colors().disabledUncheckedBorderColor,
+      disabledUncheckedThumbColor = colors.disabledUncheckedThumbColor.composeOrNull
+        ?: SwitchDefaults.colors().disabledUncheckedThumbColor,
+      disabledUncheckedTrackColor = colors.disabledUncheckedTrackColor.composeOrNull
+        ?: SwitchDefaults.colors().disabledUncheckedTrackColor,
+      disabledUncheckedIconColor = colors.disabledUncheckedIconColor.composeOrNull
+        ?: SwitchDefaults.colors().disabledUncheckedIconColor
     )
   )
 }
 
 @Composable
-fun CheckboxComposable(checked: Boolean, onCheckedChange: ((Boolean) -> Unit)?, colors: SwitchColors, modifier: Modifier) {
+fun CheckboxComposable(checked: Boolean, onCheckedChange: ((Boolean) -> Unit)?, colors: SwitchColors, modifier: Modifier, enabled: Boolean = true) {
   Checkbox(
     checked = checked,
     onCheckedChange = onCheckedChange,
     modifier = modifier,
+    enabled = enabled,
     colors = CheckboxDefaults.colors(
       checkedColor = colors.checkedColor.compose,
       disabledCheckedColor = colors.disabledCheckedColor.compose,
@@ -108,11 +172,12 @@ fun ThemedHybridSwitch(
   onCheckedChange: ((Boolean) -> Unit)?,
   colors: SwitchColors,
   modifier: Modifier = Modifier,
+  enabled: Boolean = true,
   thumbContent: (@Composable () -> Unit)? = null
 ) {
   when (variant) {
-    "switch" -> SwitchComposable(checked, onCheckedChange, colors, modifier, thumbContent)
-    else -> CheckboxComposable(checked, onCheckedChange, colors, modifier)
+    "switch" -> SwitchComposable(checked, onCheckedChange, colors, modifier, enabled, thumbContent)
+    else -> CheckboxComposable(checked, onCheckedChange, colors, modifier, enabled)
   }
 }
 
@@ -129,6 +194,7 @@ fun FunctionalComposableScope.SwitchContent(
     { newChecked -> onValueChange(ValueChangeEvent(newChecked)) },
     props.elementColors,
     ModifierRegistry.applyModifiers(props.modifiers, appContext, composableScope, globalEventDispatcher),
+    props.enabled,
     thumbContent = thumbContentSlotView?.let {
       {
         with(ComposableScope()) {

package/android/src/main/java/expo/modules/ui/button/IconButton.kt

@@ -16,6 +16,7 @@ import expo.modules.ui.ModifierList
 import expo.modules.ui.ModifierRegistry
 import expo.modules.ui.ShapeRecord
 import expo.modules.ui.compose
+import expo.modules.ui.menu.LocalContextMenuExpanded
 import expo.modules.ui.shapeFromShapeRecord
 
 enum class IconButtonVariant(val value: String) : Enumerable {
@@ -95,11 +96,16 @@ fun FunctionalComposableScope.IconButtonContent(
   val colors = props.elementColors
   val disabled = props.disabled
 
+  val contextMenuExpanded = LocalContextMenuExpanded.current
+
   StyledIconButton(
     variant ?: IconButtonVariant.DEFAULT,
     colors,
     disabled ?: false,
-    onPress = { onButtonPressed(ButtonPressedEvent()) },
+    onPress = {
+      contextMenuExpanded?.let { it.value = true }
+      onButtonPressed(ButtonPressedEvent())
+    },
     modifier = ModifierRegistry.applyModifiers(props.modifiers, appContext, composableScope, globalEventDispatcher),
     shape = shapeFromShapeRecord(props.shape)
   ) {

package/android/src/main/java/expo/modules/ui/convertibles/AnimatableFloat.kt

@@ -0,0 +1,26 @@
+package expo.modules.ui.convertibles
+
+import androidx.compose.animation.core.AnimationSpec
+import androidx.compose.animation.core.animateFloatAsState
+import androidx.compose.animation.core.snap
+import androidx.compose.animation.core.spring
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+
+@Composable
+fun resolveAnimatable(map: Map<String, Any?>, key: String, default: Float): Float {
+  val raw = map[key]
+  val targetValue = when {
+    raw is Number -> raw.toFloat()
+    raw is Map<*, *> && raw["\$animated"] == true ->
+      (raw["targetValue"] as Number).toFloat()
+    else -> default
+  }
+  val spec: AnimationSpec<Float> = when {
+    raw is Map<*, *> && raw["\$animated"] == true ->
+      parseAnimationSpec(raw["animationSpec"]) ?: spring()
+    else -> snap()
+  }
+  val animated by animateFloatAsState(targetValue, spec, label = key)
+  return animated
+}

package/android/src/main/java/expo/modules/ui/convertibles/AnimationSpecParams.kt

@@ -0,0 +1,93 @@
+package expo.modules.ui.convertibles
+
+import androidx.compose.animation.core.AnimationSpec
+import androidx.compose.animation.core.EaseInOut
+import androidx.compose.animation.core.FastOutLinearInEasing
+import androidx.compose.animation.core.FastOutSlowInEasing
+import androidx.compose.animation.core.LinearEasing
+import androidx.compose.animation.core.LinearOutSlowInEasing
+import androidx.compose.animation.core.Spring
+import androidx.compose.animation.core.keyframes
+import androidx.compose.animation.core.snap
+import androidx.compose.animation.core.spring
+import androidx.compose.animation.core.tween
+import expo.modules.kotlin.records.Field
+import expo.modules.kotlin.records.Record
+import expo.modules.kotlin.records.recordFromMap
+import expo.modules.kotlin.types.Enumerable
+
+internal enum class EasingType(val value: String) : Enumerable {
+  LINEAR("linear"),
+  FAST_OUT_SLOW_IN("fastOutSlowIn"),
+  FAST_OUT_LINEAR_IN("fastOutLinearIn"),
+  LINEAR_OUT_SLOW_IN("linearOutSlowIn"),
+  EASE("ease");
+
+  fun toEasing() = when (this) {
+    LINEAR -> LinearEasing
+    FAST_OUT_SLOW_IN -> FastOutSlowInEasing
+    FAST_OUT_LINEAR_IN -> FastOutLinearInEasing
+    LINEAR_OUT_SLOW_IN -> LinearOutSlowInEasing
+    EASE -> EaseInOut
+  }
+}
+
+internal data class SpringSpecParams(
+  @Field val dampingRatio: Float = Spring.DampingRatioNoBouncy,
+  @Field val stiffness: Float = Spring.StiffnessMedium,
+  @Field val visibilityThreshold: Float? = null
+) : Record {
+  fun toAnimationSpec(): AnimationSpec<Float> = spring(
+    dampingRatio = dampingRatio,
+    stiffness = stiffness,
+    visibilityThreshold = visibilityThreshold
+  )
+}
+
+internal data class TweenSpecParams(
+  @Field val durationMillis: Int = 300,
+  @Field val delayMillis: Int = 0,
+  @Field val easing: EasingType? = null
+) : Record {
+  fun toAnimationSpec(): AnimationSpec<Float> = tween(
+    durationMillis = durationMillis,
+    delayMillis = delayMillis,
+    easing = easing?.toEasing() ?: FastOutSlowInEasing
+  )
+}
+
+internal data class SnapSpecParams(
+  @Field val delayMillis: Int = 0
+) : Record {
+  fun toAnimationSpec(): AnimationSpec<Float> = snap(delayMillis = delayMillis)
+}
+
+internal data class KeyframesSpecParams(
+  @Field val durationMillis: Int = 300,
+  @Field val delayMillis: Int = 0
+) : Record {
+  @Suppress("UNCHECKED_CAST")
+  fun toAnimationSpec(raw: Map<*, *>): AnimationSpec<Float> {
+    val kf = raw["keyframes"] as? Map<String, Number> ?: emptyMap()
+    return keyframes {
+      this.durationMillis = this@KeyframesSpecParams.durationMillis
+      this.delayMillis = this@KeyframesSpecParams.delayMillis
+      for ((time, value) in kf) {
+        value.toFloat() at time.toInt()
+      }
+    }
+  }
+}
+
+@Suppress("UNCHECKED_CAST")
+internal fun parseAnimationSpec(raw: Any?): AnimationSpec<Float>? {
+  if (raw !is Map<*, *>) return null
+  val map = raw as Map<String, Any?>
+  return when (raw["\$type"]) {
+    "spring" -> recordFromMap<SpringSpecParams>(map).toAnimationSpec()
+    "tween" -> recordFromMap<TweenSpecParams>(map).toAnimationSpec()
+    "snap" -> recordFromMap<SnapSpecParams>(map).toAnimationSpec()
+    "keyframes" -> recordFromMap<KeyframesSpecParams>(map).toAnimationSpec(raw)
+    else -> null
+  }
+}

package/android/src/main/java/expo/modules/ui/convertibles/GraphicsLayerParams.kt

@@ -0,0 +1,24 @@
+package expo.modules.ui.convertibles
+
+import android.graphics.Color
+import expo.modules.kotlin.records.Field
+import expo.modules.kotlin.records.Record
+import expo.modules.kotlin.types.Enumerable
+import expo.modules.ui.BuiltinShapeRecord
+
+enum class CompositingStrategyType(val value: String) : Enumerable {
+  AUTO("auto"),
+  OFFSCREEN("offscreen"),
+  MODULATE("modulate")
+}
+
+internal data class GraphicsLayerParams(
+  @Field val cameraDistance: Float = 8f,
+  @Field val transformOriginX: Float = 0.5f,
+  @Field val transformOriginY: Float = 0.5f,
+  @Field val clip: Boolean = false,
+  @Field val shape: BuiltinShapeRecord? = null,
+  @Field val ambientShadowColor: Color? = null,
+  @Field val spotShadowColor: Color? = null,
+  @Field val compositingStrategy: CompositingStrategyType? = null
+) : Record

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

@@ -0,0 +1,14 @@
+import { ContentAlignment, FloatingToolbarExitAlwaysScrollBehavior, PrimitiveBaseProps } from '../layout-types';
+export type BoxProps = {
+    children?: React.ReactNode;
+    /**
+     * Alignment of children within the box.
+     */
+    contentAlignment?: ContentAlignment;
+    /**
+     * Scroll behavior for the floating toolbar exit.
+     */
+    floatingToolbarExitAlwaysScrollBehavior?: FloatingToolbarExitAlwaysScrollBehavior;
+} & PrimitiveBaseProps;
+export declare function Box(props: BoxProps): import("react").JSX.Element;
+//# sourceMappingURL=index.d.ts.map

package/build/jetpack-compose/Box/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/jetpack-compose/Box/index.tsx"],"names":[],"mappings":"AAEA,OAAO,EACL,gBAAgB,EAChB,uCAAuC,EACvC,kBAAkB,EAEnB,MAAM,iBAAiB,CAAC;AAEzB,MAAM,MAAM,QAAQ,GAAG;IACrB,QAAQ,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC;IAC3B;;OAEG;IACH,gBAAgB,CAAC,EAAE,gBAAgB,CAAC;IACpC;;OAEG;IACH,uCAAuC,CAAC,EAAE,uCAAuC,CAAC;CACnF,GAAG,kBAAkB,CAAC;AAIvB,wBAAgB,GAAG,CAAC,KAAK,EAAE,QAAQ,+BAElC"}

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

@@ -0,0 +1,22 @@
+import { HorizontalAlignment, HorizontalArrangement, PrimitiveBaseProps, VerticalAlignment, VerticalArrangement } from '../layout-types';
+export type ColumnProps = {
+    children?: React.ReactNode;
+    /**
+     * Horizontal arrangement of children.
+     */
+    horizontalArrangement?: HorizontalArrangement;
+    /**
+     * Vertical arrangement of children.
+     */
+    verticalArrangement?: VerticalArrangement;
+    /**
+     * Horizontal alignment of children.
+     */
+    horizontalAlignment?: HorizontalAlignment;
+    /**
+     * Vertical alignment of children.
+     */
+    verticalAlignment?: VerticalAlignment;
+} & PrimitiveBaseProps;
+export declare function Column(props: ColumnProps): import("react").JSX.Element;
+//# sourceMappingURL=index.d.ts.map

package/build/jetpack-compose/Column/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/jetpack-compose/Column/index.tsx"],"names":[],"mappings":"AAEA,OAAO,EACL,mBAAmB,EACnB,qBAAqB,EACrB,kBAAkB,EAClB,iBAAiB,EACjB,mBAAmB,EAEpB,MAAM,iBAAiB,CAAC;AAEzB,MAAM,MAAM,WAAW,GAAG;IACxB,QAAQ,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC;IAC3B;;OAEG;IACH,qBAAqB,CAAC,EAAE,qBAAqB,CAAC;IAC9C;;OAEG;IACH,mBAAmB,CAAC,EAAE,mBAAmB,CAAC;IAC1C;;OAEG;IACH,mBAAmB,CAAC,EAAE,mBAAmB,CAAC;IAC1C;;OAEG;IACH,iBAAiB,CAAC,EAAE,iBAAiB,CAAC;CACvC,GAAG,kBAAkB,CAAC;AAOvB,wBAAgB,MAAM,CAAC,KAAK,EAAE,WAAW,+BAExC"}