@expo/ui 56.0.15 → 56.0.17

package/android/src/main/java/expo/modules/ui/textfield/BasicTextField.kt

@@ -0,0 +1,203 @@
+package expo.modules.ui.textfield
+
+import android.annotation.SuppressLint
+import android.content.Context
+import android.graphics.Color
+import androidx.compose.foundation.text.BasicTextField
+import androidx.compose.foundation.text.selection.LocalTextSelectionColors
+import androidx.compose.foundation.text.selection.TextSelectionColors
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.CompositionLocalProvider
+import androidx.compose.runtime.compositionLocalOf
+import androidx.compose.ui.graphics.SolidColor
+import androidx.compose.ui.graphics.isUnspecified
+import expo.modules.kotlin.AppContext
+import expo.modules.kotlin.views.AsyncFunctionHandle
+import expo.modules.kotlin.views.AsyncFunctionHandle2
+import expo.modules.kotlin.views.ComposableScope
+import expo.modules.kotlin.views.ComposeProps
+import expo.modules.kotlin.views.ExpoComposeView
+import expo.modules.kotlin.views.FunctionalComposableScope
+import expo.modules.kotlin.views.OptimizedComposeProps
+import expo.modules.ui.GenericEventPayload1
+import expo.modules.ui.ModifierList
+import expo.modules.ui.composeOrNull
+import expo.modules.ui.findChildSlotView
+import expo.modules.ui.renderSlot
+import expo.modules.ui.state.ObservableState
+import expo.modules.ui.state.WorkletCallback
+
+// region Inner text field plumbing
+
+/**
+ * Carries the framework-provided `innerTextField` lambda from `BasicTextField`'s
+ * `decorationBox` down to the [InnerTextFieldView] marker, wherever the JS
+ * decoration places it. `null` when read outside a decoration (the marker then
+ * renders nothing rather than crashing).
+ */
+val LocalInnerTextField = compositionLocalOf<(@Composable () -> Unit)?> { null }
+
+class InnerTextFieldProps : ComposeProps
+
+/**
+ * Slot view for `BasicTextField.InnerTextField`.
+ */
+@SuppressLint("ViewConstructor")
+class InnerTextFieldView(context: Context, appContext: AppContext) :
+  ExpoComposeView<InnerTextFieldProps>(context, appContext) {
+  override val props = InnerTextFieldProps()
+
+  @Composable
+  override fun ComposableScope.Content() {
+    LocalInnerTextField.current?.invoke()
+  }
+}
+
+// endregion Inner text field plumbing
+
+// region Placeholder plumbing
+
+/**
+ * Tracks whether textfield is empty, in order to render placeholder slot
+ */
+val LocalTextFieldIsEmpty = compositionLocalOf { true }
+
+class PlaceholderProps : ComposeProps
+
+/**
+ * Slot view for `BasicTextField.Placeholder`. Renders its children only while
+ * the field is empty.
+ */
+@SuppressLint("ViewConstructor")
+class PlaceholderView(context: Context, appContext: AppContext) :
+  ExpoComposeView<PlaceholderProps>(context, appContext) {
+  override val props = PlaceholderProps()
+
+  @Composable
+  override fun ComposableScope.Content() {
+    if (LocalTextFieldIsEmpty.current) {
+      Children(this)
+    }
+  }
+}
+
+// endregion Placeholder plumbing
+
+// region Props
+
+@OptimizedComposeProps
+data class BasicTextFieldProps(
+  val value: ObservableState = ObservableState(""),
+  val selection: ObservableState = ObservableState(mapOf("start" to 0, "end" to 0)),
+  val maxLength: Int? = null,
+  val autoFocus: Boolean = false,
+  val enabled: Boolean = true,
+  val readOnly: Boolean = false,
+  val singleLine: Boolean = false,
+  val maxLines: Int? = null,
+  val minLines: Int? = null,
+  val textStyle: TextFieldTextStyleRecord? = null,
+  val visualTransformation: String? = null,
+  val keyboardOptions: TextFieldKeyboardOptionsRecord? = null,
+  val cursorColor: Color? = null,
+  val textSelectionColors: TextFieldSelectionColorsRecord? = null,
+  val onValueChangeSync: WorkletCallback? = null,
+  val modifiers: ModifierList = emptyList()
+) : ComposeProps
+
+// endregion Props
+
+// region View
+
+@Composable
+fun FunctionalComposableScope.BasicTextFieldContent(
+  props: BasicTextFieldProps,
+  setText: AsyncFunctionHandle<String>,
+  setSelection: AsyncFunctionHandle2<Int, Int>,
+  clear: AsyncFunctionHandle<Unit>,
+  focus: AsyncFunctionHandle<Unit>,
+  blur: AsyncFunctionHandle<Unit>,
+  onValueChanged: (TextFieldValuePayload) -> Unit,
+  onFocusChange: (GenericEventPayload1<Boolean>) -> Unit,
+  onKeyboardActionTriggered: (KeyboardActionEvent) -> Unit,
+  onSelectionChanged: (TextFieldSelectionPayload) -> Unit
+) {
+  val core = rememberTextFieldCore(
+    value = props.value,
+    selection = props.selection,
+    maxLength = props.maxLength,
+    autoFocus = props.autoFocus,
+    keyboardOptionsRecord = props.keyboardOptions,
+    modifiers = props.modifiers,
+    onValueChangeSync = props.onValueChangeSync,
+    setText = setText,
+    setSelection = setSelection,
+    clear = clear,
+    focus = focus,
+    blur = blur,
+    onValueChanged = onValueChanged,
+    onFocusChange = onFocusChange,
+    onKeyboardActionTriggered = onKeyboardActionTriggered,
+    onSelectionChanged = onSelectionChanged
+  )
+
+  val singleLine = props.singleLine
+  val maxLines = props.maxLines ?: if (singleLine) 1 else Int.MAX_VALUE
+  val minLines = props.minLines ?: 1
+
+  val textStyle = props.textStyle.toTextStyle(appContext.reactContext).let {
+    if (it.color.isUnspecified) it.copy(color = MaterialTheme.colorScheme.onSurface) else it
+  }
+  val visualTransformation = props.visualTransformation.toVisualTransformation()
+  val cursorBrush = SolidColor(props.cursorColor.composeOrNull ?: MaterialTheme.colorScheme.primary)
+
+  val current = LocalTextSelectionColors.current
+  val selectionColors = props.textSelectionColors?.let { record ->
+    val handle = record.handleColor.composeOrNull
+    val background = record.backgroundColor.composeOrNull
+    if (handle == null && background == null) {
+      current
+    } else {
+      TextSelectionColors(
+        handleColor = handle ?: current.handleColor,
+        backgroundColor = background ?: handle?.copy(alpha = 0.4f) ?: current.backgroundColor
+      )
+    }
+  } ?: current
+
+  val decoration: (@Composable () -> Unit)? =
+    findChildSlotView(view, "decorationBox")?.let { slot -> { slot.renderSlot() } }
+
+  CompositionLocalProvider(LocalTextSelectionColors provides selectionColors) {
+    BasicTextField(
+      value = core.value,
+      onValueChange = core.onValueChange,
+      modifier = core.modifier,
+      enabled = props.enabled,
+      readOnly = props.readOnly,
+      textStyle = textStyle,
+      keyboardOptions = core.keyboardOptions,
+      keyboardActions = core.keyboardActions,
+      singleLine = singleLine,
+      maxLines = maxLines,
+      minLines = minLines,
+      visualTransformation = visualTransformation,
+      cursorBrush = cursorBrush,
+      decorationBox = { innerTextField ->
+        if (decoration != null) {
+          CompositionLocalProvider(
+            LocalInnerTextField provides innerTextField,
+            LocalTextFieldIsEmpty provides core.value.text.isEmpty()
+          ) {
+            decoration()
+          }
+        } else {
+          innerTextField()
+        }
+      }
+    )
+  }
+}
+
+// endregion View

package/android/src/main/java/expo/modules/ui/{TextFieldView.kt → textfield/TextField.kt}

@@ -1,44 +1,34 @@
-package expo.modules.ui
+package expo.modules.ui.textfield
 
 import android.graphics.Color
-import androidx.compose.foundation.text.KeyboardActions
-import androidx.compose.foundation.text.KeyboardOptions
 import androidx.compose.foundation.text.selection.TextSelectionColors
+import androidx.compose.material3.ExperimentalMaterial3ExpressiveApi
+import androidx.compose.material3.MaterialExpressiveTheme
+import androidx.compose.material3.MotionScheme
 import androidx.compose.material3.OutlinedTextField
 import androidx.compose.material3.OutlinedTextFieldDefaults
 import androidx.compose.material3.TextField
 import androidx.compose.material3.TextFieldColors
 import androidx.compose.material3.TextFieldDefaults
 import androidx.compose.runtime.Composable
-import androidx.compose.runtime.LaunchedEffect
-import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.remember
-import androidx.compose.ui.focus.FocusRequester
-import androidx.compose.ui.focus.focusRequester
-import androidx.compose.ui.focus.onFocusChanged
-import androidx.compose.ui.platform.LocalFocusManager
-import androidx.compose.ui.text.TextRange
-import androidx.compose.ui.text.TextStyle
-import androidx.compose.ui.text.input.ImeAction
-import androidx.compose.ui.text.input.KeyboardCapitalization
-import androidx.compose.ui.text.input.KeyboardType
-import androidx.compose.ui.text.input.PasswordVisualTransformation
-import androidx.compose.ui.text.input.TextFieldValue
-import androidx.compose.ui.text.input.VisualTransformation
-import androidx.compose.ui.text.style.TextAlign
-import androidx.compose.ui.unit.TextUnit
-import androidx.compose.ui.unit.sp
 import expo.modules.kotlin.records.Field
 import expo.modules.kotlin.records.Record
 import expo.modules.kotlin.types.Enumerable
+import expo.modules.kotlin.types.OptimizedRecord
 import expo.modules.kotlin.views.AsyncFunctionHandle
 import expo.modules.kotlin.views.AsyncFunctionHandle2
 import expo.modules.kotlin.views.ComposeProps
 import expo.modules.kotlin.views.FunctionalComposableScope
-import expo.modules.kotlin.types.OptimizedRecord
+import expo.modules.kotlin.views.OptimizedComposeProps
+import expo.modules.ui.GenericEventPayload1
+import expo.modules.ui.ModifierList
+import expo.modules.ui.ShapeRecord
+import expo.modules.ui.composeOrNull
+import expo.modules.ui.findChildSlotView
+import expo.modules.ui.renderSlot
+import expo.modules.ui.shapeFromShapeRecord
 import expo.modules.ui.state.ObservableState
 import expo.modules.ui.state.WorkletCallback
-import expo.modules.kotlin.views.OptimizedComposeProps
 
 // region Records
 
@@ -47,25 +37,6 @@ enum class TextFieldVariant(val value: String) : Enumerable {
   OUTLINED("outlined")
 }
 
-@OptimizedRecord
-data class TextFieldKeyboardOptionsRecord(
-  @Field val capitalization: String? = null,
-  @Field val autoCorrectEnabled: Boolean? = null,
-  @Field val keyboardType: String? = null,
-  @Field val imeAction: String? = null
-) : Record
-
-@OptimizedRecord
-data class TextFieldTextStyleRecord(
-  @Field val textAlign: TextAlignType? = null,
-  @Field val color: Color? = null,
-  @Field val fontSize: Float? = null,
-  @Field val fontFamily: String? = null,
-  @Field val fontWeight: TextFontWeight? = null,
-  @Field val lineHeight: Float? = null,
-  @Field val letterSpacing: Float? = null
-) : Record
-
 @OptimizedRecord
 data class TextFieldColorsRecord(
   // Text
@@ -129,21 +100,6 @@ data class TextFieldSelectionColorsRecord(
   @Field val backgroundColor: Color? = null
 ) : Record
 
-data class KeyboardActionEvent(
-  @Field val action: String,
-  @Field val value: String
-) : Record
-
-data class TextFieldSelectionPayload(
-  @Field val start: Int,
-  @Field val end: Int
-) : Record
-
-data class TextFieldValuePayload(
-  @Field val text: String,
-  @Field val selection: TextFieldSelectionPayload
-) : Record
-
 // endregion Records
 
 // region Color builder
@@ -227,56 +183,9 @@ data class TextFieldProps(
 
 // endregion Props
 
-// region Mappers
-
-private fun String?.toKeyboardType(): KeyboardType = when (this) {
-  "text" -> KeyboardType.Text
-  "number" -> KeyboardType.Number
-  "email" -> KeyboardType.Email
-  "phone" -> KeyboardType.Phone
-  "decimal" -> KeyboardType.Decimal
-  "password" -> KeyboardType.Password
-  "ascii" -> KeyboardType.Ascii
-  "uri" -> KeyboardType.Uri
-  "numberPassword" -> KeyboardType.NumberPassword
-  else -> KeyboardType.Text
-}
-
-private fun String?.toCapitalization(): KeyboardCapitalization = when (this) {
-  "characters" -> KeyboardCapitalization.Characters
-  "none" -> KeyboardCapitalization.None
-  "sentences" -> KeyboardCapitalization.Sentences
-  "words" -> KeyboardCapitalization.Words
-  else -> KeyboardCapitalization.None
-}
-
-private fun String?.toImeAction(): ImeAction = when (this) {
-  "default" -> ImeAction.Default
-  "none" -> ImeAction.None
-  "go" -> ImeAction.Go
-  "search" -> ImeAction.Search
-  "send" -> ImeAction.Send
-  "previous" -> ImeAction.Previous
-  "next" -> ImeAction.Next
-  "done" -> ImeAction.Done
-  else -> ImeAction.Default
-}
-
-// endregion Mappers
-
-// region Value helpers
-
-private fun ObservableState.extractSelection(textLength: Int): TextRange {
-  val selMap = value as? Map<*, *>
-  val start = (selMap?.get("start") as? Number)?.toInt()?.coerceIn(0, textLength) ?: 0
-  val end = (selMap?.get("end") as? Number)?.toInt()?.coerceIn(0, textLength) ?: 0
-  return TextRange(start, end)
-}
-
-// endregion Value helpers
-
 // region View
 
+@OptIn(ExperimentalMaterial3ExpressiveApi::class)
 @Composable
 fun FunctionalComposableScope.TextFieldContent(
   props: TextFieldProps,
@@ -290,31 +199,24 @@ fun FunctionalComposableScope.TextFieldContent(
   onKeyboardActionTriggered: (KeyboardActionEvent) -> Unit,
   onSelectionChanged: (TextFieldSelectionPayload) -> Unit
 ) {
-  val focusManager = LocalFocusManager.current
-  val focusRequester = remember { FocusRequester() }
-  val state = props.value
-
-  setText.handle { text ->
-    state.value = text
-    // setText moves the cursor to the end; use setSelection afterwards to override.
-    props.selection.value = mapOf("start" to text.length, "end" to text.length)
-  }
-  focus.handle {
-    focusRequester.requestFocus()
-  }
-  blur.handle {
-    focusManager.clearFocus()
-  }
-  setSelection.handle { start, end ->
-    val text = state.value as? String ?: ""
-    val clampedStart = start.coerceIn(0, text.length)
-    val clampedEnd = end.coerceIn(0, text.length)
-    props.selection.value = mapOf("start" to clampedStart, "end" to clampedEnd)
-  }
-  clear.handle {
-    state.value = ""
-    props.selection.value = mapOf("start" to 0, "end" to 0)
-  }
+  val core = rememberTextFieldCore(
+    value = props.value,
+    selection = props.selection,
+    maxLength = props.maxLength,
+    autoFocus = props.autoFocus,
+    keyboardOptionsRecord = props.keyboardOptions,
+    modifiers = props.modifiers,
+    onValueChangeSync = props.onValueChangeSync,
+    setText = setText,
+    setSelection = setSelection,
+    clear = clear,
+    focus = focus,
+    blur = blur,
+    onValueChanged = onValueChanged,
+    onFocusChange = onFocusChange,
+    onKeyboardActionTriggered = onKeyboardActionTriggered,
+    onSelectionChanged = onSelectionChanged
+  )
 
   // Slots
   val label: (@Composable () -> Unit)? = findChildSlotView(view, "label")?.let { slot -> { slot.renderSlot() } }
@@ -325,58 +227,11 @@ fun FunctionalComposableScope.TextFieldContent(
   val suffix: (@Composable () -> Unit)? = findChildSlotView(view, "suffix")?.let { slot -> { slot.renderSlot() } }
   val supportingText: (@Composable () -> Unit)? = findChildSlotView(view, "supportingText")?.let { slot -> { slot.renderSlot() } }
 
-  // Keyboard
-  val kbOpts = props.keyboardOptions
-  val keyboardOptions = KeyboardOptions.Default.copy(
-    keyboardType = kbOpts?.keyboardType.toKeyboardType(),
-    autoCorrectEnabled = kbOpts?.autoCorrectEnabled ?: true,
-    capitalization = kbOpts?.capitalization.toCapitalization(),
-    imeAction = kbOpts?.imeAction.toImeAction()
-  )
-  val currentText = { state.value as? String ?: "" }
-  val keyboardActions = KeyboardActions(
-    onDone = {
-      defaultKeyboardAction(ImeAction.Done)
-      onKeyboardActionTriggered(KeyboardActionEvent("done", currentText()))
-    },
-    onGo = {
-      defaultKeyboardAction(ImeAction.Go)
-      onKeyboardActionTriggered(KeyboardActionEvent("go", currentText()))
-    },
-    onNext = {
-      defaultKeyboardAction(ImeAction.Next)
-      onKeyboardActionTriggered(KeyboardActionEvent("next", currentText()))
-    },
-    onPrevious = {
-      defaultKeyboardAction(ImeAction.Previous)
-      onKeyboardActionTriggered(KeyboardActionEvent("previous", currentText()))
-    },
-    onSearch = {
-      defaultKeyboardAction(ImeAction.Search)
-      onKeyboardActionTriggered(KeyboardActionEvent("search", currentText()))
-    },
-    onSend = {
-      defaultKeyboardAction(ImeAction.Send)
-      onKeyboardActionTriggered(KeyboardActionEvent("send", currentText()))
-    }
-  )
-
   // Lines
   val singleLine = props.singleLine
   val maxLines = props.maxLines ?: if (singleLine) 1 else Int.MAX_VALUE
   val minLines = props.minLines ?: 1
 
-  // Modifier
-  val modifier = ModifierRegistry.applyModifiers(props.modifiers, appContext, composableScope, globalEventDispatcher)
-    .focusRequester(focusRequester)
-    .onFocusChanged { focusState ->
-      onFocusChange(GenericEventPayload1(focusState.isFocused))
-    }
-
-  if (props.autoFocus) {
-    LaunchedEffect(Unit) { focusRequester.requestFocus() }
-  }
-
   val isOutlined = props.variant == TextFieldVariant.OUTLINED
   val shape = shapeFromShapeRecord(props.shape)
     ?: if (isOutlined) OutlinedTextFieldDefaults.shape else TextFieldDefaults.shape
@@ -398,99 +253,40 @@ fun FunctionalComposableScope.TextFieldContent(
     }
   } ?: baseColors
 
-  val text = state.value as? String ?: ""
-  val selection = props.selection.extractSelection(text.length)
-
-  val localValue = remember { mutableStateOf(TextFieldValue(text, selection)) }
-  if (localValue.value.text != text || localValue.value.selection != selection) {
-    localValue.value = TextFieldValue(text, selection)
-  }
-
-  val value = localValue.value
-
-  val onValueChange: (TextFieldValue) -> Unit = { incoming ->
-    val new = props.maxLength?.let { max ->
-      if (incoming.text.length > max) {
-        val truncated = incoming.text.substring(0, max)
-        incoming.copy(
-          text = truncated,
-          selection = TextRange(
-            incoming.selection.start.coerceAtMost(max),
-            incoming.selection.end.coerceAtMost(max)
-          )
-        )
-      } else {
-        null
-      }
-    } ?: incoming
-    val prev = localValue.value
-    localValue.value = new
-    if (new.selection != prev.selection) {
-      val cur = props.selection.value as? Map<*, *>
-      val curStart = (cur?.get("start") as? Number)?.toInt()
-      val curEnd = (cur?.get("end") as? Number)?.toInt()
-      if (curStart != new.selection.start || curEnd != new.selection.end) {
-        props.selection.value = mapOf(
-          "start" to new.selection.start,
-          "end" to new.selection.end
-        )
-      }
-      onSelectionChanged(TextFieldSelectionPayload(new.selection.start, new.selection.end))
-    }
-    if (new.text != prev.text) {
-      state.value = new.text
-      val payload = TextFieldValuePayload(
-        text = new.text,
-        selection = TextFieldSelectionPayload(new.selection.start, new.selection.end)
+  val textStyle = props.textStyle.toTextStyle(appContext.reactContext)
+  val visualTransformation = props.visualTransformation.toVisualTransformation()
+
+  // Workaround (pending upstream fix, https://issuetracker.google.com/issues/519816993)
+  // the expressive motion scheme's spring overshoots >1f, and TextField's calculateHeight
+  // extrapolates that overshoot, transiently growing the field and jiggling surrounding
+  // content. Forcing the standard (non-overshooting) spatial spring removes the jiggle.
+  MaterialExpressiveTheme(motionScheme = MotionScheme.standard()) {
+    if (isOutlined) {
+      OutlinedTextField(
+        value = core.value, onValueChange = core.onValueChange, modifier = core.modifier,
+        enabled = props.enabled, readOnly = props.readOnly, textStyle = textStyle,
+        label = label, placeholder = placeholder,
+        leadingIcon = leadingIcon, trailingIcon = trailingIcon,
+        prefix = prefix, suffix = suffix, supportingText = supportingText,
+        isError = props.isError, visualTransformation = visualTransformation,
+        keyboardOptions = core.keyboardOptions, keyboardActions = core.keyboardActions,
+        singleLine = singleLine, maxLines = maxLines, minLines = minLines,
+        shape = shape, colors = colors
+      )
+    } else {
+      TextField(
+        value = core.value, onValueChange = core.onValueChange, modifier = core.modifier,
+        enabled = props.enabled, readOnly = props.readOnly, textStyle = textStyle,
+        label = label, placeholder = placeholder,
+        leadingIcon = leadingIcon, trailingIcon = trailingIcon,
+        prefix = prefix, suffix = suffix, supportingText = supportingText,
+        isError = props.isError, visualTransformation = visualTransformation,
+        keyboardOptions = core.keyboardOptions, keyboardActions = core.keyboardActions,
+        singleLine = singleLine, maxLines = maxLines, minLines = minLines,
+        shape = shape, colors = colors
       )
-      onValueChanged(payload)
-      props.onValueChangeSync?.invoke(new.text)
     }
   }
-
-  val context = appContext.reactContext
-  val textStyle = props.textStyle?.let { textStyleProps ->
-    TextStyle(
-      color = colorToComposeColorOrNull(textStyleProps.color) ?: androidx.compose.ui.graphics.Color.Unspecified,
-      fontSize = textStyleProps.fontSize?.sp ?: TextUnit.Unspecified,
-      fontWeight = textStyleProps.fontWeight?.toComposeFontWeight(),
-      fontFamily = context?.let { resolveFontFamily(textStyleProps.fontFamily, it) },
-      letterSpacing = textStyleProps.letterSpacing?.sp ?: TextUnit.Unspecified,
-      lineHeight = textStyleProps.lineHeight?.sp ?: TextUnit.Unspecified,
-      textAlign = textStyleProps.textAlign?.toComposeTextAlign() ?: TextAlign.Unspecified
-    )
-  } ?: TextStyle.Default
-
-  val visualTransformation = when (props.visualTransformation) {
-    "password" -> PasswordVisualTransformation()
-    else -> VisualTransformation.None
-  }
-
-  if (isOutlined) {
-    OutlinedTextField(
-      value = value, onValueChange = onValueChange, modifier = modifier,
-      enabled = props.enabled, readOnly = props.readOnly, textStyle = textStyle,
-      label = label, placeholder = placeholder,
-      leadingIcon = leadingIcon, trailingIcon = trailingIcon,
-      prefix = prefix, suffix = suffix, supportingText = supportingText,
-      isError = props.isError, visualTransformation = visualTransformation,
-      keyboardOptions = keyboardOptions, keyboardActions = keyboardActions,
-      singleLine = singleLine, maxLines = maxLines, minLines = minLines,
-      shape = shape, colors = colors
-    )
-  } else {
-    TextField(
-      value = value, onValueChange = onValueChange, modifier = modifier,
-      enabled = props.enabled, readOnly = props.readOnly, textStyle = textStyle,
-      label = label, placeholder = placeholder,
-      leadingIcon = leadingIcon, trailingIcon = trailingIcon,
-      prefix = prefix, suffix = suffix, supportingText = supportingText,
-      isError = props.isError, visualTransformation = visualTransformation,
-      keyboardOptions = keyboardOptions, keyboardActions = keyboardActions,
-      singleLine = singleLine, maxLines = maxLines, minLines = minLines,
-      shape = shape, colors = colors
-    )
-  }
 }
 
 // endregion View