pytech-ui 1.0.21 → 1.0.23

package/android/src/main/java/expo/modules/myui/ListItem/Slots/ListItemFromSlots.kt

@@ -0,0 +1,60 @@
+package expo.modules.myui.ListItem
+
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import expo.modules.kotlin.views.ExpoComposeView
+import expo.modules.kotlin.views.FunctionalComposableScope
+import expo.modules.ui.SlotView
+
+import expo.modules.myui.getModifier
+import expo.modules.myui.section.sectionItemPosition
+import expo.modules.myui.ListItem.ListItemDynamic
+import expo.modules.myui.ListItem.Decorator
+import expo.modules.myui.ListItem.RenderSlot
+import expo.modules.myui.findChildBySlotName
+
+
+
+
+// Crea el ListItem desde los slots
+
+@Composable
+internal fun FunctionalComposableScope.ListItemFromSlots(props: ListItemProps) {
+	val composeView = view as ExpoComposeView<*>
+	val sectionPosition = composeView.sectionItemPosition(props)
+
+	val isFirst = sectionPosition?.isFirst ?: (props.isFirst ?: true)
+	val isLast = sectionPosition?.isLast ?: (props.isLast ?: true)
+
+	val headlineSlot = findChildBySlotName("headlineContent")
+	val overlineSlot = findChildBySlotName("overlineContent")
+	val supportingSlot = findChildBySlotName("supportingContent")
+	val leadingSlot = findChildBySlotName("leadingContent")
+	val trailingSlot = findChildBySlotName("trailingContent")
+	Decorator(
+		isFirst = isFirst,
+		isLast = isLast,
+		showDivider = props.showDivider,
+		modifier = getModifier(props.modifiers),
+	) { innerProps ->
+		ListItemDynamic(
+			props = props,
+			modifier = Modifier.fillMaxWidth(),
+			innerProps = innerProps,
+			leadingContent = leadingSlot?.let { slot -> { RenderSlot(slot) } },
+			overlineContent = overlineSlot?.let { slot -> { RenderSlot(slot) } },
+			supportingContent = supportingSlot?.let { slot -> { RenderSlot(slot) } },
+			headlineContent = headlineSlot?.let { slot -> { RenderSlot(slot) } },
+			trailingContent = trailingSlot?.let { slot -> { RenderSlot(slot) } },
+		)
+	}
+}
+
+
+@Composable
+internal fun FunctionalComposableScope.RenderSlot(slot: SlotView) {
+	with(composableScope) {
+		with(slot) { Content() }
+	}
+}

package/android/src/main/java/expo/modules/myui/ListItem/Slots/types.kt

@@ -0,0 +1,42 @@
+package expo.modules.myui.ListItem
+
+import android.graphics.Color
+import androidx.compose.ui.unit.Dp
+import expo.modules.kotlin.records.Field
+import expo.modules.kotlin.records.Record
+import expo.modules.kotlin.types.OptimizedRecord
+import expo.modules.kotlin.views.ComposeProps
+import expo.modules.kotlin.views.OptimizedComposeProps
+import expo.modules.ui.ModifierList
+
+
+
+@OptimizedRecord
+data class ListItemColorsRecord(
+  @Field val containerColor: Color? = null,
+  @Field val contentColor: Color? = null,
+  @Field val leadingContentColor: Color? = null,
+  @Field val trailingContentColor: Color? = null,
+  @Field val supportingContentColor: Color? = null,
+  @Field val overlineContentColor: Color? = null,
+) : Record
+
+@OptimizedComposeProps
+data class ListItemProps(
+
+  val showDivider: Boolean = true,
+  val isFirst: Boolean? = null,
+  val isLast: Boolean? = null,
+  val hasNavigationLink: Boolean? = null,
+
+  val tonalElevation: Float? = null,
+  val shadowElevation: Float? = null,
+  val colors: ListItemColorsRecord? = null,
+  val modifiers: ModifierList = emptyList(),
+  
+) : ComposeProps
+
+/** Props internas de Kotlin; el callback no puede venir del bridge JS. */
+internal data class ListItemInnerProps(
+  val onLeadingWidthChanged: ((Dp) -> Unit)? = null,
+)

package/android/src/main/java/expo/modules/myui/ListItem/_shared/Decorator/Decorator.kt

@@ -0,0 +1,79 @@
+package expo.modules.myui.ListItem
+
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.unit.dp
+
+import expo.modules.myui.theme.ExtendedTheme
+
+
+
+/*
+
+Decorator para el ListItem
+
+Agrega:
+
+- Background
+- Shape
+- Divider
+
+Tiene la logica interna del LeadingWidth
+
+*/
+
+@Composable
+internal fun Decorator(
+	isFirst: Boolean,
+	isLast: Boolean,
+	showDivider: Boolean = true,
+	modifier: Modifier = Modifier,
+	content: @Composable (ListItemInnerProps) -> Unit,
+
+) {
+
+	val shouldShowDivider = showDivider && !isLast
+	val backgroundColor = ExtendedTheme.colorScheme.secondarySystemGroupedBackground
+	val shape = 
+		if (isFirst || isLast) {
+			itemClipShape(isFirst, isLast)
+		} else {
+			null
+		}
+
+	var leadingWidth by remember { mutableStateOf(0.dp) }
+	val shapeModifier = if (shape != null) {
+		Modifier.clip(shape).background(backgroundColor, shape)
+	} else {
+		Modifier.background(backgroundColor)
+	}
+
+	// clickable debe ir después de clip para que el ripple respete las esquinas
+	val rowModifier = Modifier
+		.fillMaxWidth()
+		.then(shapeModifier)
+		.then(modifier)
+
+	Column(modifier = rowModifier) {
+		content(
+			ListItemInnerProps(
+				onLeadingWidthChanged =
+					if (shouldShowDivider) {
+						{ width -> if (width != leadingWidth) { leadingWidth = width } }
+					} else {
+						null
+					},
+			),
+		)
+
+		if (shouldShowDivider) { ListItemDivider(leadingWidth = leadingWidth) }
+	}
+}

package/android/src/main/java/expo/modules/myui/ListItem/_shared/Decorator/Divider.kt

@@ -0,0 +1,36 @@
+package expo.modules.myui.ListItem
+
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.material3.HorizontalDivider
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.unit.Dp
+import androidx.compose.ui.unit.dp
+
+import expo.modules.myui.theme.ExtendedTheme
+import expo.modules.myui.theme.tokens.ListTokens
+
+
+
+/* Crea el divider segun el leadingWidth */
+
+@Composable
+internal fun ListItemDivider(leadingWidth: Dp) {
+	val leadingInset = if (leadingWidth > 0.dp) {
+		leadingWidth + ListTokens.ItemBetweenSpace + 4.dp // +4.dp porque tiene que dar 16.dp
+	} else {
+		0.dp
+	}
+
+	HorizontalDivider(
+		modifier = Modifier
+		.fillMaxWidth()
+		.padding(
+			start = ListTokens.DividerLeadingSpace + leadingInset,
+			end = ListTokens.DividerTrailingSpace,
+		),
+		color = ExtendedTheme.colorScheme.separator.copy(alpha = 0.4f),
+		thickness = 1.dp,
+	)
+}

package/android/src/main/java/expo/modules/myui/ListItem/_shared/Decorator/utilsDecorator.kt

@@ -0,0 +1,19 @@
+package expo.modules.myui.ListItem
+
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.ui.unit.dp
+
+import expo.modules.myui.theme.tokens.ShapeTokens
+
+
+
+private val GroupCornerRadius = ShapeTokens.CornerValueExtraLarge
+
+internal fun itemClipShape(isFirst: Boolean, isLast: Boolean): RoundedCornerShape {
+	return RoundedCornerShape(
+		topStart = if (isFirst) GroupCornerRadius else 0.dp,
+		topEnd = if (isFirst) GroupCornerRadius else 0.dp,
+		bottomStart = if (isLast) GroupCornerRadius else 0.dp,
+		bottomEnd = if (isLast) GroupCornerRadius else 0.dp,
+	)
+}

package/android/src/main/java/expo/modules/myui/ListItem/_shared/Dynamic/Dynamic.kt

@@ -0,0 +1,163 @@
+package expo.modules.myui.ListItem
+
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.size
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.rounded.ArrowForwardIos
+import androidx.compose.material3.Icon
+import androidx.compose.material3.ListItem as ListItemMaterial
+import androidx.compose.material3.ListItemDefaults
+import androidx.compose.material3.Surface
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.Color as ComposeColor
+import androidx.compose.ui.layout.onSizeChanged
+import androidx.compose.ui.platform.LocalDensity
+import androidx.compose.ui.unit.dp
+import expo.modules.ui.composeOrNull
+
+import expo.modules.myui.TypographySlot.SlotTypography
+import expo.modules.myui.theme.ExtendedTheme
+
+
+
+/*
+
+ListItemDynamic es el componente que se encarga de la logica interna del ListItem
+
+Se encarga de poner visualmente:
+
+- LeadingContent
+- HeadlineContent
+- TrailingContent
+- OverlineContent
+- SupportingContent
+
+*/
+
+@Composable
+internal fun ListItemDynamic(
+	props: ListItemProps = ListItemProps(),
+	modifier: Modifier = Modifier,
+	innerProps: ListItemInnerProps = ListItemInnerProps(),
+	leadingContent: (@Composable () -> Unit)? = null,
+	headlineContent: (@Composable () -> Unit)? = null,
+	trailingContent: (@Composable () -> Unit)? = null,
+	overlineContent: (@Composable () -> Unit)? = null,
+	supportingContent: (@Composable () -> Unit)? = null,
+) {
+	val density = LocalDensity.current
+
+	val colors = listItemColors(props)
+
+	ListItemMaterial(
+		modifier = modifier,
+		colors = colors,
+		tonalElevation = props.tonalElevation?.dp ?: ListItemDefaults.Elevation,
+		shadowElevation = props.shadowElevation?.dp ?: ListItemDefaults.Elevation,
+		supportingContent = supportingContent?.let { content ->
+			{ StyledSlotContent("supportingcontent", colors.supportingContentColor, content) }
+		},
+		leadingContent = leadingContent?.let { content ->
+			{
+				val styledContent: @Composable () -> Unit = {
+					StyledSlotContent("leadingcontent", colors.leadingContentColor, content)
+				}
+				val onLeadingWidthChanged = innerProps.onLeadingWidthChanged
+				if (onLeadingWidthChanged != null) {
+					Box(
+						modifier = Modifier.onSizeChanged { size ->
+						onLeadingWidthChanged(with(density) { size.width.toDp() })
+						},
+					) {
+						styledContent()
+					}
+				} else {
+					styledContent()
+				}
+			}
+		},
+		overlineContent = overlineContent?.let { content ->
+			{ StyledSlotContent("overlinecontent", colors.overlineContentColor, content) }
+		},
+		headlineContent = {
+			when {
+				headlineContent == null && trailingContent == null -> Unit
+				trailingContent == null -> {
+					Box(modifier = Modifier.fillMaxWidth()) {
+						headlineContent?.let { content ->
+							StyledSlotContent("headlinecontent", colors.contentColor, content)
+						}
+					}
+				}
+				headlineContent == null -> {
+					Box(
+						modifier = Modifier.fillMaxWidth(),
+						contentAlignment = Alignment.CenterEnd,
+					) {
+						StyledSlotContent("trailingcontent", colors.trailingContentColor, trailingContent)
+					}
+				}
+				else -> {
+					DynamicRow(
+						first = { StyledSlotContent("headlinecontent", colors.contentColor, headlineContent) },
+						second = { StyledSlotContent("trailingcontent", colors.trailingContentColor, trailingContent) },
+					)
+				}
+			}
+		},
+		trailingContent = if (props.hasNavigationLink == true) {
+			{
+				Icon(
+					imageVector = Icons.Rounded.ArrowForwardIos,
+					contentDescription = null,
+					tint = ExtendedTheme.colorScheme.tertiaryLabel,
+					modifier = Modifier.size(17.dp),
+				)
+			}
+		} else {
+			null
+		},
+	)
+}
+
+
+@Composable
+internal fun listItemColors(props: ListItemProps) = ListItemDefaults.colors(
+	containerColor = props.colors?.containerColor.composeOrNull ?: ComposeColor.Transparent,
+	contentColor = props.colors?.contentColor.composeOrNull ?: ExtendedTheme.colorScheme.label,
+	leadingContentColor = props.colors?.leadingContentColor.composeOrNull ?: ExtendedTheme.colorScheme.link,
+	trailingContentColor = props.colors?.trailingContentColor.composeOrNull ?: ExtendedTheme.colorScheme.secondaryLabel,
+	supportingContentColor = props.colors?.supportingContentColor.composeOrNull ?: ExtendedTheme.colorScheme.secondaryLabel,
+	overlineContentColor = props.colors?.overlineContentColor.composeOrNull ?: ExtendedTheme.colorScheme.secondaryLabel,
+)
+
+@Composable
+private fun SlotContentColor(
+	contentColor: Color?,
+	content: @Composable () -> Unit,
+) {
+	if (contentColor != null) {
+		Surface(color = Color.Transparent, contentColor = contentColor) {
+			content()
+		}
+	} else {
+		content()
+	}
+}
+
+@Composable
+private fun StyledSlotContent(
+	slotName: String,
+	contentColor: Color?,
+	content: @Composable () -> Unit,
+) {
+	SlotContentColor(contentColor) {
+		SlotTypography(slotName) {
+			content()
+		}
+	}
+}

package/android/src/main/java/expo/modules/myui/ListItem/_shared/Dynamic/Row.kt

@@ -0,0 +1,136 @@
+package expo.modules.myui.ListItem
+
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.wrapContentWidth
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.layout.SubcomposeLayout
+import androidx.compose.ui.unit.Constraints
+import androidx.compose.ui.unit.Dp
+import kotlin.math.max
+
+import expo.modules.myui.theme.tokens.ListTokens
+
+
+
+/**
+ * Headline + trailing en una fila.
+ *
+ * - Caben con ancho natural: headline al inicio, trailing al final.
+ * - No caben: el que no supera la mitad queda en su ancho natural; el otro ocupa el resto.
+ * - Si ambos superan la mitad: reparto 50/50.
+ */
+
+@Composable
+internal fun DynamicRow(
+	modifier: Modifier = Modifier,
+	spacing: Dp = ListTokens.ItemBetweenSpace,
+	first: @Composable () -> Unit,
+	second: @Composable () -> Unit,
+) {
+	SubcomposeLayout(
+		modifier = modifier.fillMaxWidth(),
+	) { constraints ->
+		val spacingPx = spacing.roundToPx()
+		val maxWidth = constraints.maxWidth
+
+		val naturalConstraints = Constraints(
+			minWidth = 0,
+			maxWidth = maxWidth,
+			minHeight = 0,
+			maxHeight = constraints.maxHeight,
+		)
+
+		val firstNatural = subcompose(Slot.FirstMeasure) {
+			Box(Modifier.wrapContentWidth(Alignment.Start)) { first() }
+		}.first().measure(naturalConstraints)
+
+		val secondNatural = subcompose(Slot.SecondMeasure) {
+			Box(Modifier.wrapContentWidth(Alignment.End)) { second() }
+		}.first().measure(naturalConstraints)
+
+		val needsSplit = firstNatural.width + spacingPx + secondNatural.width > maxWidth
+
+		if (needsSplit) {
+			val available = max(0, maxWidth - spacingPx)
+			val halfWidth = available / 2
+			val firstExceedsHalf = firstNatural.width > halfWidth
+			val secondExceedsHalf = secondNatural.width > halfWidth
+
+			val firstWidth: Int
+			val secondWidth: Int
+			when {
+				firstExceedsHalf && !secondExceedsHalf -> {
+					secondWidth = secondNatural.width
+					firstWidth = available - secondWidth
+				}
+				secondExceedsHalf && !firstExceedsHalf -> {
+					firstWidth = firstNatural.width
+					secondWidth = available - firstWidth
+				}
+				else -> {
+					firstWidth = halfWidth
+					secondWidth = halfWidth
+				}
+			}
+
+			val firstConstraints = Constraints(
+				minWidth = firstWidth,
+				maxWidth = firstWidth,
+				minHeight = 0,
+				maxHeight = constraints.maxHeight,
+			)
+			val secondConstraints = Constraints(
+				minWidth = secondWidth,
+				maxWidth = secondWidth,
+				minHeight = 0,
+				maxHeight = constraints.maxHeight,
+			)
+
+			val firstSplit = subcompose(Slot.FirstSplit) {
+				Box(
+					modifier = Modifier.fillMaxWidth(),
+					contentAlignment = Alignment.CenterStart,
+				) {
+					first()
+				}
+			}.first().measure(firstConstraints)
+
+			val secondSplit = subcompose(Slot.SecondSplit) {
+				Box(
+					modifier = Modifier.fillMaxWidth(),
+					contentAlignment = Alignment.CenterEnd,
+				) {
+					second()
+				}
+			}.first().measure(secondConstraints)
+
+			val height = max(firstSplit.height, secondSplit.height).coerceAtLeast(constraints.minHeight)
+
+			layout(maxWidth, height) {
+				val firstY = (height - firstSplit.height) / 2
+				val secondY = (height - secondSplit.height) / 2
+				firstSplit.placeRelative(0, firstY)
+				secondSplit.placeRelative(firstWidth + spacingPx, secondY)
+			}
+		} else {
+			val height = max(firstNatural.height, secondNatural.height).coerceAtLeast(constraints.minHeight)
+
+			layout(maxWidth, height) {
+				val firstY = (height - firstNatural.height) / 2
+				val secondY = (height - secondNatural.height) / 2
+				firstNatural.placeRelative(0, firstY)
+				secondNatural.placeRelative(maxWidth - secondNatural.width, secondY)
+			}
+		}
+	}
+}
+
+private enum class Slot {
+  FirstMeasure,
+  SecondMeasure,
+  FirstSplit,
+  SecondSplit,
+}

package/android/src/main/java/expo/modules/myui/Menu/DropdownMenu.kt

@@ -0,0 +1,48 @@
+package expo.modules.myui.menu
+
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.widthIn
+import androidx.compose.material3.DropdownMenu
+import androidx.compose.material3.MenuDefaults
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.LocalConfiguration
+import androidx.compose.ui.unit.dp
+import expo.modules.kotlin.views.FunctionalComposableScope
+import expo.modules.myui.theme.tokens.ShapeTokens
+import expo.modules.ui.ModifierRegistry
+import expo.modules.ui.UIComposableScope
+import expo.modules.ui.composeOrNull
+import expo.modules.ui.findChildSlotView
+import expo.modules.ui.isSlotView
+
+private val HorizontalScreenInset = 16.dp
+
+@Composable
+fun FunctionalComposableScope.DropdownMenuContent(
+  props: DropdownMenuProps,
+  onDismissRequest: () -> Unit
+) {
+  val itemsSlotView = findChildSlotView(view, "items")
+  val maxMenuWidth = LocalConfiguration.current.screenWidthDp.dp - HorizontalScreenInset * 2
+
+  Box(modifier = ModifierRegistry.applyModifiers(props.modifiers, appContext, composableScope, globalEventDispatcher)) {
+    Children(UIComposableScope(), filter = { !isSlotView(it) })
+
+    DropdownMenu(
+      containerColor = props.color?.composeOrNull ?: MenuDefaults.containerColor,
+      expanded = props.expanded,
+      onDismissRequest = onDismissRequest,
+      shape = ShapeTokens.CornerExtraLarge,
+      modifier = Modifier.widthIn(max = maxMenuWidth),
+    ) {
+      itemsSlotView?.let {
+        with(UIComposableScope()) {
+          with(it) {
+            Content()
+          }
+        }
+      }
+    }
+  }
+}

package/android/src/main/java/expo/modules/myui/Menu/DropdownMenuRecords.kt

@@ -0,0 +1,20 @@
+package expo.modules.myui.menu
+
+import android.graphics.Color
+import expo.modules.kotlin.types.Enumerable
+import expo.modules.kotlin.views.ComposeProps
+import expo.modules.ui.ModifierList
+import expo.modules.kotlin.views.OptimizedComposeProps
+
+enum class ActivationMethod(val value: String) : Enumerable {
+  SINGLE_PRESS("singlePress"),
+  LONG_PRESS("longPress")
+}
+
+@OptimizedComposeProps
+data class DropdownMenuProps(
+  val activationMethod: ActivationMethod = ActivationMethod.SINGLE_PRESS,
+  val expanded: Boolean = false,
+  val color: Color? = null,
+  val modifiers: ModifierList = emptyList()
+) : ComposeProps

package/android/src/main/java/expo/modules/myui/MyUiModifiers.kt

@@ -0,0 +1,94 @@
+package expo.modules.myui
+
+import android.graphics.Color as AndroidColor
+import androidx.compose.foundation.layout.heightIn
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.drawBehind
+import androidx.compose.ui.geometry.Offset
+import androidx.compose.ui.graphics.Brush
+import androidx.compose.ui.graphics.Color as ComposeColor
+import androidx.compose.ui.platform.LocalConfiguration
+import androidx.compose.ui.unit.Dp
+import androidx.compose.ui.unit.dp
+import expo.modules.ui.ModifierRegistry
+import expo.modules.ui.columnScope
+import expo.modules.ui.rowScope
+
+private fun normalizeColorString(s: String): String {
+	val t = s.trim()
+	return if (t.startsWith("#")) t else "#$t"
+}
+
+/**
+ * Registra modificadores extra para Jetpack Compose (p. ej. degradados con [Brush]).
+ * Debe llamarse al crear el módulo nativo; [ModifierRegistry] es el mismo que usa @expo/ui.
+ */
+fun registerModifiers() {
+	
+	// --------------------------- backgroundLinearGradient---------------------------
+
+	ModifierRegistry.register("backgroundLinearGradient") { map, _, _, _ ->
+		val raw = map["colors"] as? List<*> ?: return@register Modifier
+		val composeColors = raw.mapNotNull { item ->
+			val hex = (item as? String)?.trim()?.takeIf { it.isNotEmpty() } ?: return@mapNotNull null
+			runCatching {
+				val argb = AndroidColor.parseColor(normalizeColorString(hex))
+				ComposeColor(argb)
+			}.getOrNull()
+		}
+		if (composeColors.size < 2) return@register Modifier
+
+		val sx = (map["startX"] as? Number)?.toFloat() ?: 0f
+		val sy = (map["startY"] as? Number)?.toFloat() ?: 0f
+		val ex = (map["endX"] as? Number)?.toFloat() ?: 0f
+		val ey = (map["endY"] as? Number)?.toFloat() ?: 1f
+
+		Modifier.drawBehind {
+			val brush = Brush.linearGradient(
+				colors = composeColors,
+				start = Offset(size.width * sx, size.height * sy),
+				end = Offset(size.width * ex, size.height * ey)
+			)
+			drawRect(brush = brush, size = size)
+		}
+	}
+
+	// --------------------------- heightIn ------------------------------------------
+
+	ModifierRegistry.register("heightIn") { map, _, _, _ ->
+		val minDp = (map["min"] as? Number)?.toFloat()
+		val maxDp = (map["max"] as? Number)?.toFloat()
+		val minFraction = (map["minFraction"] as? Number)?.toFloat()
+		val maxFraction = (map["maxFraction"] as? Number)?.toFloat()
+
+		val screenHeightDp = LocalConfiguration.current.screenHeightDp.toFloat()
+
+		val resolvedMin = when {
+			minDp != null -> minDp.dp
+			minFraction != null -> (screenHeightDp * minFraction).dp
+			else -> Dp.Unspecified
+		}
+		val resolvedMax = when {
+			maxFraction != null -> (screenHeightDp * maxFraction).dp
+			maxDp != null -> maxDp.dp
+			else -> Dp.Unspecified
+		}
+
+		Modifier.heightIn(min = resolvedMin, max = resolvedMax)
+	}
+
+	// --------------------------- flexWeight ----------------------------------------
+
+	ModifierRegistry.register("flexWeight") { map, scope, _, _ ->
+		val weight = (map["weight"] as? Number)?.toFloat() ?: 1f
+		val fill = map["fill"] as? Boolean ?: false
+
+		scope?.rowScope?.run {
+			Modifier.weight(weight, fill = fill)
+		} ?: scope?.columnScope?.run {
+			Modifier.weight(weight, fill = fill)
+		} ?: Modifier
+	}
+
+	// -------------------------------------------------------------------------------
+}