react-native-unified-action-sheet 0.1.0 → 0.2.0

package/CHANGELOG.md

@@ -7,6 +7,44 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.2.0]
+
+### Added
+
+- `showPromptWithOptions(options)` — the same native dialog as the action sheet,
+  with a text field. React Native's own `Alert.prompt` is iOS-only and silently
+  does nothing on Android, so this is the one API here with no core equivalent.
+  Resolves `{ buttonIndex, text }`, or `undefined` after `dismissActionSheet()`.
+- Prompt button handlers receive the field's text. It is read when the prompt
+  closes, including on a dismissal, so a draft is recoverable rather than lost.
+- Prompt options: `placeholder`, `defaultValue`, `secureTextEntry` and
+  `keyboardType` (`'default' | 'email-address' | 'numeric' | 'phone-pad' |
+  'url'`). Buttons keep the sheet's `style`, `disabled` and `onPress`.
+- `setNextPromptResult({ buttonIndex, text })` in the shipped Jest mock, the
+  prompt counterpart to `setNextButtonIndex()`.
+- Exported types: `PromptButtonInterface`, `PromptCommonOptionsInterface`,
+  `PromptAndroidOptionsInterface`, `PromptOptionsInterface`,
+  `PromptResultInterface`, plus the shared `BaseButtonInterface`,
+  `BaseOptionsInterface` and `BaseAndroidOptionsInterface`.
+
+### Changed
+
+- The options and button fields the sheet and the prompt share are now declared
+  once, in `BaseOptionsInterface` / `BaseButtonInterface`, which both APIs
+  extend. No public type changed shape.
+
+### Notes
+
+- A prompt is always presented centered. UIKit has no text field in an action
+  sheet, so `presentationStyle` and `anchor` do not apply to one.
+- `dismissActionSheet()` and `dismissAllActionSheets()` close prompts too.
+
+## [0.1.1]
+
+No user-facing changes — the library is identical to 0.1.0. Republished from CI
+so the release carries npm provenance; 0.1.0 was published by hand, because npm
+only lets a trusted publisher be configured on a package that already exists.
+
 ## [0.1.0]
 
 Initial release.
@@ -37,5 +75,7 @@ Initial release.
 - No `com.google.android.material` dependency, and no runtime dependencies —
   `react` and `react-native` are peers.
 
-[unreleased]: https://github.com/galikvalkin/react-native-unified-action-sheet/compare/v0.1.0...HEAD
+[unreleased]: https://github.com/galikvalkin/react-native-unified-action-sheet/compare/v0.2.0...HEAD
+[0.2.0]: https://github.com/galikvalkin/react-native-unified-action-sheet/compare/v0.1.1...v0.2.0
+[0.1.1]: https://github.com/galikvalkin/react-native-unified-action-sheet/compare/v0.1.0...v0.1.1
 [0.1.0]: https://github.com/galikvalkin/react-native-unified-action-sheet/releases/tag/v0.1.0

package/README.md

@@ -12,8 +12,9 @@ Unified action sheet API for React Native: a native `UIAlertController` on iOS,
   <em>iPad: the same sheet presented as a popover, anchored to the view that opened it.</em>
 </p>
 
-- **Fully native, always on top.** The sheet gets its own platform window, so it renders above your entire React Native view tree — including above an already-open [`Modal`](https://reactnative.dev/docs/modal). JS-rendered action sheets live *inside* the component tree, where `overflow`, `zIndex`, a transform or an open modal can clip or bury them.
+- **Fully native, always on top.** The sheet gets its own platform window, so it renders above your whole view tree — including an already-open [`Modal`](https://reactnative.dev/docs/modal). JS-rendered sheets live *inside* the component tree, where `overflow`, `zIndex`, a transform or an open modal can clip or bury them.
 - **One API, native on both platforms**, so the same options behave the same way.
+- **Prompts included.** React Native's `Alert.prompt` is iOS-only and silently does nothing on Android; `showPromptWithOptions()` works on both.
 - Works on React Native **0.81 (old and new architecture)** through the **latest** release.
 - **No extra native dependencies** on either platform, and zero runtime dependencies (`react` / `react-native` peers only).
 
@@ -44,7 +45,7 @@ await showActionSheetWithOptions({
 });
 ```
 
-Each button is an object. `style` marks the two native roles, which are mutually exclusive; `disabled` is independent of it; and `onPress` runs when that button resolves the sheet, so reordering buttons cannot send one down another's branch. The call also resolves with the tapped index, and the two never disagree:
+`style` marks the two native roles, which are mutually exclusive; `disabled` is independent of it. `onPress` runs when that button resolves the sheet, and the call also resolves with the tapped index — the two never disagree:
 
 | | promise resolves with | `onPress` runs |
 | --- | --- | --- |
@@ -75,6 +76,34 @@ const anchorRef = useRef<View>(null);
 
 Anything with a `measureInWindow` method works, which is every React Native host component ref. On iOS the anchor only applies on iPad, where the sheet becomes a popover; iPhone always presents from the bottom.
 
+### Prompts
+
+`showPromptWithOptions()` is the same dialog with a text field:
+
+```ts
+import { showPromptWithOptions } from 'react-native-unified-action-sheet';
+
+const result = await showPromptWithOptions({
+  title: 'Rename item',
+  placeholder: 'New name',
+  defaultValue: 'Untitled',
+  options: [
+    { label: 'Save', onPress: (text) => rename(text) },
+    { label: 'Cancel', style: 'cancel' },
+  ],
+});
+// { buttonIndex, text }, or undefined after dismissActionSheet().
+```
+
+Buttons behave as they do for the sheet, except `onPress` receives the field's
+text. That text is whatever was in the field when the prompt closed, including
+on a dismissal, so a draft is recoverable. Extra options: `placeholder`,
+`defaultValue`, `secureTextEntry` and `keyboardType` (`'default' |
+'email-address' | 'numeric' | 'phone-pad' | 'url'`).
+
+A prompt is always centered — UIKit has no text field in an action sheet, so
+`presentationStyle` and `anchor` do not apply.
+
 ### Dismissing from code
 
 `dismissActionSheet()` closes the most recently opened sheet, `dismissAllActionSheets()` closes every open one. Both are no-ops when nothing is open, and the dismissed sheets resolve with `undefined`.
@@ -91,13 +120,13 @@ import {
 | Option | Type | iOS | Android | Description |
 | --- | --- | :---: | :---: | --- |
 | `options` | `ActionSheetButtonInterface[]` | ✅ | ✅ | The buttons, in order: `{ label, style?, disabled?, onPress? }`. |
-| `style` (per button) | `'cancel' \| 'destructive'?` | ✅ | ✅ | `'cancel'` renders a separated cancel row on Android and resolves on backdrop tap / back; `'destructive'` renders in the destructive color. Only the first `'cancel'` counts. |
+| `style` (per button) | `'cancel' \| 'destructive'?` | ✅ | ✅ | `'cancel'` renders a separated row and resolves on backdrop tap / back; `'destructive'` uses the destructive color. Only the first `'cancel'` counts. |
 | `disabled` (per button) | `boolean?` | ✅ | ✅ | Renders the row dimmed and unresponsive to taps. |
 | `onPress` (per button) | `() => void?` | ✅ | ✅ | Runs when this button resolves the sheet. |
 | `title` | `string?` | ✅ | ✅ | Sheet title. |
 | `message` | `string?` | ✅ | ✅ | Secondary text under the title. |
-| `presentationStyle` | `'centered' \| 'anchored'` | ✅ | ✅ | `'centered'` is a centered dialog; `'anchored'` attaches to `anchor` (an iPad popover on iOS). **Defaults differ**: Android defaults to `'centered'`, iOS to the standard action sheet. |
-| `anchor` | `ActionSheetAnchorInterface?` | ✅ | ✅ | The view to attach to — a ref, or anything with `measureInWindow`. Without a measurable anchor an `'anchored'` sheet falls back to a centered dialog. |
+| `presentationStyle` | `'centered' \| 'anchored'` | ✅ | ✅ | `'centered'` is a centered dialog; `'anchored'` attaches to `anchor` (an iPad popover on iOS). **Defaults differ**: Android `'centered'`, iOS the standard action sheet. |
+| `anchor` | `ActionSheetAnchorInterface?` | ✅ | ✅ | A ref, or anything with `measureInWindow`. Without a measurable anchor an `'anchored'` sheet falls back to a centered dialog. |
 | `anchorAlignment` | `'start' \| 'center'` | — | ✅ | Alignment of an `'anchored'` popup relative to its anchor. `'start'` (default) aligns leading edges, flipping in RTL. |
 | `userInterfaceStyle` | `'light' \| 'dark'` | ✅ | ✅ | Forces the appearance; defaults to following the system setting. |
 | `tintColor` | `string?` | ✅ | ✅ | Text color of non-destructive buttons. |
@@ -105,26 +134,16 @@ import {
 | `destructiveColor` | `string?` | ✅ | ✅ | Overrides the destructive row color (Android's palette error color, iOS system red). |
 | `buttonTextAlignment` | `'start' \| 'center'` | — | ✅ | Alignment of button labels. Defaults to `'start'`, which follows layout direction. |
 
-The options types are exported for typing your own wrappers:
-
-```ts
-import type {
-  ActionSheetOptionsInterface, // what showActionSheetWithOptions accepts
-  ActionSheetCommonOptionsInterface,
-  ActionSheetAndroidOptionsInterface,
-  ActionSheetButtonInterface, // a single button
-  ActionSheetAnchorInterface, // anything with measureInWindow
-} from 'react-native-unified-action-sheet';
-```
+Every options and button type is exported for typing your own wrappers —
+`ActionSheetOptionsInterface`, `PromptOptionsInterface`, `PromptResultInterface`
+and the interfaces they are composed from.
 
 ### Platform notes
 
 - **Which gestures dismiss differs.** On iOS a sheet can only be tapped away if it has a `'cancel'` button, and a `'centered'` one never can — UIKit treats it as strictly modal. Android's centered dialog always cancels on a backdrop tap. Give a sheet a cancel button if you want that gesture everywhere.
 - **On iPad, a popover hides the cancel row**, since tapping outside already cancels. The index you receive is unaffected.
 - **Sheets stack.** Opening one over another puts it on top, and each resolves its own promise. Opening a sheet over a `Modal` does not dismiss the modal.
-- **Light or dark follows the system setting** unless `userInterfaceStyle` forces one, chosen when the sheet opens. The sheet uses its own palette, so it looks the same in any host app.
-- **Long lists scroll**, with the title and message pinned above them.
-- On Android, a sheet with no available activity resolves the cancel index rather than hanging, so a cancel handler can run for a sheet that never appeared.
+- **Light or dark follows the system setting** unless `userInterfaceStyle` forces one, chosen when the sheet opens. It uses its own palette, so it looks the same in any host app.
 
 ## Testing
 
@@ -136,7 +155,7 @@ jest.mock('react-native-unified-action-sheet', () =>
 );
 ```
 
-Every sheet then resolves with no selection. To simulate a tap, queue the index the next sheet should resolve with — the pressed button's `onPress` runs, just as it would for real:
+Every sheet then resolves with no selection. To simulate a tap, queue the index it should resolve with — the pressed button's `onPress` runs as it would for real:
 
 ```ts
 import { setNextButtonIndex } from 'react-native-unified-action-sheet/jest';
@@ -145,7 +164,9 @@ setNextButtonIndex(0);
 await openTheSheet();
 ```
 
-Prefer that over `mockResolvedValueOnce`, which replaces the implementation and so skips `onPress`. `dismissActionSheet` and `dismissAllActionSheets` are plain spies.
+`setNextPromptResult({ buttonIndex, text })` does the same for a prompt. Prefer
+these over `mockResolvedValueOnce`, which replaces the implementation and so
+skips `onPress`. `dismissActionSheet` and `dismissAllActionSheets` are spies.
 
 ## Compatibility
 

package/android/src/main/java/com/unifiedactionsheet/PromptOptions.kt

@@ -0,0 +1,132 @@
+package com.unifiedactionsheet
+
+import android.text.InputType
+import com.facebook.react.bridge.ReadableMap
+
+/// The subset of React Native's keyboardType values that map onto both
+/// platforms. Anything unrecognised falls back to the plain text keyboard.
+internal enum class PromptKeyboardType {
+  DEFAULT,
+  EMAIL_ADDRESS,
+  NUMERIC,
+  PHONE_PAD,
+  URL,
+  ;
+
+  fun toInputType(secure: Boolean): Int {
+    if (secure) {
+      // Keep the keyboard class: masking a passcode should still show digits.
+      return when (this) {
+        NUMERIC, PHONE_PAD ->
+          InputType.TYPE_CLASS_NUMBER or InputType.TYPE_NUMBER_VARIATION_PASSWORD
+        else -> InputType.TYPE_CLASS_TEXT or InputType.TYPE_TEXT_VARIATION_PASSWORD
+      }
+    }
+
+    return when (this) {
+      DEFAULT -> InputType.TYPE_CLASS_TEXT
+      EMAIL_ADDRESS -> InputType.TYPE_CLASS_TEXT or InputType.TYPE_TEXT_VARIATION_EMAIL_ADDRESS
+      NUMERIC -> InputType.TYPE_CLASS_NUMBER
+      PHONE_PAD -> InputType.TYPE_CLASS_PHONE
+      URL -> InputType.TYPE_CLASS_TEXT or InputType.TYPE_TEXT_VARIATION_URI
+    }
+  }
+
+  companion object {
+    fun fromWire(value: String?): PromptKeyboardType = when (value) {
+      "email-address" -> EMAIL_ADDRESS
+      "numeric" -> NUMERIC
+      "phone-pad" -> PHONE_PAD
+      "url" -> URL
+      else -> DEFAULT
+    }
+  }
+}
+
+internal data class PromptOptions(
+  val options: List<String>,
+  val cancelButtonIndex: Int?,
+  val destructiveButtonIndices: Set<Int>,
+  val disabledButtonIndices: Set<Int>,
+  val title: String?,
+  val message: String?,
+  val placeholder: String?,
+  val defaultValue: String?,
+  val keyboardType: PromptKeyboardType,
+  val secureTextEntry: Boolean,
+  val tintColor: String?,
+  val cancelButtonTintColor: String?,
+  val destructiveColor: String?,
+  val buttonTextAlignment: ButtonTextAlignment,
+  val userInterfaceStyle: ForcedAppearance,
+) {
+  /// The prompt reuses the sheet's content and dialog code, which are written
+  /// against ActionSheetOptions. Presentation is fixed to centered: UIKit has
+  /// no text field in an action sheet, so an anchored prompt has no iOS
+  /// counterpart and would break the "same options behave the same way" rule.
+  fun toSheetOptions(): ActionSheetOptions = ActionSheetOptions(
+    options = options,
+    cancelButtonIndex = cancelButtonIndex,
+    destructiveButtonIndices = destructiveButtonIndices,
+    title = title,
+    message = message,
+    tintColor = tintColor,
+    cancelButtonTintColor = cancelButtonTintColor,
+    destructiveColor = destructiveColor,
+    buttonTextAlignment = buttonTextAlignment,
+    disabledButtonIndices = disabledButtonIndices,
+    userInterfaceStyle = userInterfaceStyle,
+    presentationStyle = PresentationStyle.CENTERED,
+    anchorRect = null,
+    anchorAlignment = AnchorAlignment.START,
+  )
+
+  companion object {
+    fun fromReadableMap(map: ReadableMap): PromptOptions {
+      val labels = mutableListOf<String>()
+      map.getArray("options")?.let { array ->
+        for (index in 0 until array.size()) {
+          array.getString(index)?.let(labels::add)
+        }
+      }
+
+      return PromptOptions(
+        options = labels,
+        cancelButtonIndex = optInt(map, "cancelButtonIndex"),
+        destructiveButtonIndices = optIndices(map, "destructiveButtonIndices"),
+        disabledButtonIndices = optIndices(map, "disabledButtonIndices"),
+        title = optString(map, "title"),
+        message = optString(map, "message"),
+        placeholder = optString(map, "placeholder"),
+        defaultValue = optString(map, "defaultValue"),
+        keyboardType = PromptKeyboardType.fromWire(optString(map, "keyboardType")),
+        secureTextEntry = optBoolean(map, "secureTextEntry"),
+        tintColor = optString(map, "tintColor"),
+        cancelButtonTintColor = optString(map, "cancelButtonTintColor"),
+        destructiveColor = optString(map, "destructiveColor"),
+        buttonTextAlignment = ButtonTextAlignment.fromWire(optString(map, "buttonTextAlignment")),
+        userInterfaceStyle = ForcedAppearance.fromWire(optString(map, "userInterfaceStyle")),
+      )
+    }
+
+    private fun optIndices(map: ReadableMap, key: String): Set<Int> {
+      val indices = mutableSetOf<Int>()
+      map.getArray(key)?.let { array ->
+        for (index in 0 until array.size()) {
+          indices.add(array.getInt(index))
+        }
+      }
+
+      return indices
+    }
+
+    private fun optInt(map: ReadableMap, key: String): Int? =
+      if (map.hasKey(key) && !map.isNull(key)) map.getInt(key) else null
+
+    private fun optBoolean(map: ReadableMap, key: String): Boolean =
+      map.hasKey(key) && !map.isNull(key) && map.getBoolean(key)
+
+    private fun optString(map: ReadableMap, key: String): String? =
+      if (map.hasKey(key) && !map.isNull(key)) map.getString(key) else null
+  }
+}

package/android/src/main/java/com/unifiedactionsheet/SheetContentBuilder.kt

@@ -6,9 +6,11 @@ import android.util.TypedValue
 import android.view.Gravity
 import android.view.View
 import android.widget.Button
+import android.widget.EditText
 import android.widget.LinearLayout
 import android.widget.TextView
 import androidx.appcompat.content.res.AppCompatResources
+import androidx.appcompat.widget.AppCompatEditText
 import androidx.core.graphics.ColorUtils
 import androidx.core.view.AccessibilityDelegateCompat
 import androidx.core.view.ViewCompat
@@ -22,6 +24,8 @@ internal fun buildContent(
   options: ActionSheetOptions,
   palette: SheetPalette,
   includeCancelRow: Boolean = true,
+  /// Sits between the message and the rows. Only the prompt supplies one.
+  inputView: View? = null,
   onSelect: (Int) -> Unit,
 ): LinearLayout {
   val container = LinearLayout(context).apply {
@@ -36,6 +40,8 @@ internal fun buildContent(
     container.addView(buildHeader(context, it, palette.secondaryText, isTitle = false))
   }
 
+  inputView?.let(container::addView)
+
   val centerLabels = options.buttonTextAlignment == ButtonTextAlignment.CENTER
 
   val optionColor = parseColor(options.tintColor) ?: palette.primaryText
@@ -96,6 +102,31 @@ internal fun buildContent(
   return container
 }
 
+internal fun buildPromptInput(
+  context: Context,
+  options: PromptOptions,
+  palette: SheetPalette,
+): EditText = AppCompatEditText(context).apply {
+  setText(options.defaultValue.orEmpty())
+  hint = options.placeholder
+  setTextSize(TypedValue.COMPLEX_UNIT_SP, 16f)
+  setTextColor(palette.primaryText)
+  setHintTextColor(ColorUtils.setAlphaComponent(palette.secondaryText, DISABLED_TEXT_ALPHA))
+  setPadding(dp(context, 16), dp(context, 8), dp(context, 16), dp(context, 8))
+  isSingleLine = true
+  // After isSingleLine, never before: setSingleLine() installs
+  // SingleLineTransformationMethod, which replaces the password masking that
+  // setInputType() sets up. Ordering them the other way renders a secure field
+  // in plain text while still reporting a password input type.
+  inputType = options.keyboardType.toInputType(options.secureTextEntry)
+  // Land the caret after any default value rather than before it.
+  setSelection(text?.length ?: 0)
+  layoutParams = LinearLayout.LayoutParams(
+    LinearLayout.LayoutParams.MATCH_PARENT,
+    LinearLayout.LayoutParams.WRAP_CONTENT,
+  )
+}
+
 private fun buildHeader(
   context: Context,
   text: String,

package/android/src/main/java/com/unifiedactionsheet/SheetPresenters.kt

@@ -83,6 +83,60 @@ internal object CenteredDialogPresenter : SheetPresenter {
   }
 }
 
+/// The centered dialog with a text field above the buttons. Deliberately not a
+/// SheetPresenter: it takes PromptOptions and hands the field's text back with
+/// the index, which the sheet interface has no place for.
+internal fun buildPromptDialog(
+  activity: Activity,
+  options: PromptOptions,
+  onSelect: (Dialog, Int, String) -> Unit,
+): Pair<Dialog, () -> String> {
+  val isDark = isDarkAppearance(activity, options.userInterfaceStyle)
+  val palette = paletteFor(isDark)
+  val dialog = AppCompatDialog(activity, dialogTheme(isDark))
+  dialog.supportRequestWindowFeature(Window.FEATURE_NO_TITLE)
+
+  val context: Context = dialog.context
+  val input = buildPromptInput(context, options, palette)
+  val currentText = { input.text?.toString().orEmpty() }
+
+  val container = buildContent(
+    context = context,
+    options = options.toSheetOptions(),
+    palette = palette,
+    inputView = input,
+  ) { index -> onSelect(dialog, index, currentText()) }
+
+  dialog.setContentView(container)
+  dialog.setCanceledOnTouchOutside(true)
+
+  val background = GradientDrawable().apply {
+    cornerRadius = dp(context, PROMPT_CORNER_RADIUS_DP).toFloat()
+    setColor(palette.surface)
+  }
+  dialog.window?.setBackgroundDrawable(background)
+  container.background = background.constantState?.newDrawable() ?: background
+  container.clipToOutline = true
+
+  val metrics = context.resources.displayMetrics
+  val width = (metrics.widthPixels - 2 * dp(context, PROMPT_MARGIN_DP))
+    .coerceAtMost(dp(context, PROMPT_MAX_WIDTH_DP))
+    .coerceAtLeast(minOf(dp(context, PROMPT_MIN_WIDTH_DP), metrics.widthPixels))
+  dialog.window?.setLayout(width, WindowManager.LayoutParams.WRAP_CONTENT)
+
+  // A prompt exists to be typed into, so raise the keyboard with it rather than
+  // making the user tap the field first.
+  dialog.window?.setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_VISIBLE)
+  input.requestFocus()
+
+  return dialog to currentText
+}
+
+private const val PROMPT_CORNER_RADIUS_DP = 28
+private const val PROMPT_MARGIN_DP = 24
+private const val PROMPT_MIN_WIDTH_DP = 280
+private const val PROMPT_MAX_WIDTH_DP = 560
+
 internal class AnchoredDialogPresenter(private val anchorRect: Rect) : SheetPresenter {
   override fun build(
     activity: Activity,

package/android/src/main/java/com/unifiedactionsheet/UnifiedActionSheetModule.kt

@@ -2,6 +2,7 @@ package com.unifiedactionsheet
 
 import android.app.Activity
 import android.app.Dialog
+import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.LifecycleEventListener
 import com.facebook.react.bridge.Promise
 import com.facebook.react.bridge.ReactApplicationContext
@@ -37,6 +38,19 @@ class UnifiedActionSheetModule(reactContext: ReactApplicationContext) :
     }
   }
 
+  override fun showPromptWithOptions(options: ReadableMap, promise: Promise) {
+    val parsed = PromptOptions.fromReadableMap(options)
+    val activity = reactApplicationContext.currentActivity
+      ?: return promise.reject(
+        "E_NO_ACTIVITY",
+        "No current activity to attach the prompt to.",
+      )
+
+    UiThreadUtil.runOnUiThread {
+      presentPrompt(activity, parsed, promise)
+    }
+  }
+
   override fun dismissActionSheet() {
     UiThreadUtil.runOnUiThread {
       openDialogs.lastOrNull()?.let { dialog ->
@@ -118,6 +132,47 @@ class UnifiedActionSheetModule(reactContext: ReactApplicationContext) :
     dialog.show()
   }
 
+  /// Mirrors presentSheet exactly, except the resolved value carries the text
+  /// as well as the index. The dialog joins the same openDialogs registry, so
+  /// dismissActionSheet()/dismissAllActionSheets() close prompts too.
+  private fun presentPrompt(
+    activity: Activity,
+    options: PromptOptions,
+    promise: Promise,
+  ) {
+    val resolved = AtomicBoolean(false)
+    val resolveOnce: (Int?, String) -> Unit = { index, text ->
+      if (resolved.compareAndSet(false, true)) {
+        promise.resolve(
+          Arguments.createMap().apply {
+            putInt("buttonIndex", index ?: -1)
+            putString("text", text)
+          },
+        )
+      }
+    }
+
+    val (dialog, currentText) = buildPromptDialog(activity, options) { presented, index, text ->
+      presented.dismiss()
+      resolveOnce(index, text)
+    }
+    openDialogs.add(dialog)
+
+    // Read the field at dismissal time: what the user typed survives a backdrop
+    // tap, so a caller can still recover a draft.
+    dialog.setOnCancelListener { resolveOnce(options.cancelButtonIndex, currentText()) }
+    dialog.setOnDismissListener {
+      openDialogs.remove(dialog)
+      if (dismissedByApi.remove(dialog)) {
+        resolveOnce(DISMISSED_BY_API, currentText())
+      } else {
+        resolveOnce(options.cancelButtonIndex, currentText())
+      }
+    }
+
+    dialog.show()
+  }
+
   companion object {
     const val NAME = NativeUnifiedActionSheetSpec.NAME
 

package/ios/UnifiedActionSheet.mm

@@ -73,6 +73,53 @@ RCT_EXPORT_METHOD(showActionSheetWithOptions
   });
 }
 
+RCT_EXPORT_METHOD(showPromptWithOptions
+                  : (JS::NativeUnifiedActionSheet::SpecShowPromptWithOptionsOptions &)options resolve
+                  : (RCTPromiseResolveBlock)resolve reject
+                  : (RCTPromiseRejectBlock)reject)
+{
+  NSMutableDictionary *payload = [NSMutableDictionary new];
+
+  payload[@"options"] = RCTConvertVecToArray(options.options(), ^id(NSString *element) {
+    return element;
+  });
+
+  if (options.cancelButtonIndex()) {
+    payload[@"cancelButtonIndex"] = @(*options.cancelButtonIndex());
+  }
+  if (options.destructiveButtonIndices()) {
+    payload[@"destructiveButtonIndices"] =
+        RCTConvertVecToArray(*options.destructiveButtonIndices(), ^id(double element) {
+          return @(element);
+        });
+  }
+  if (options.disabledButtonIndices()) {
+    payload[@"disabledButtonIndices"] = RCTConvertVecToArray(*options.disabledButtonIndices(), ^id(double element) {
+      return @(element);
+    });
+  }
+  if (options.secureTextEntry()) {
+    payload[@"secureTextEntry"] = @(*options.secureTextEntry());
+  }
+
+  payload[@"title"] = options.title();
+  payload[@"message"] = options.message();
+  payload[@"placeholder"] = options.placeholder();
+  payload[@"defaultValue"] = options.defaultValue();
+  payload[@"keyboardType"] = options.keyboardType();
+  payload[@"tintColor"] = options.tintColor();
+  payload[@"cancelButtonTintColor"] = options.cancelButtonTintColor();
+  payload[@"destructiveColor"] = options.destructiveColor();
+  payload[@"userInterfaceStyle"] = options.userInterfaceStyle();
+
+  dispatch_async(dispatch_get_main_queue(), ^{
+    [UnifiedActionSheetImpl.shared showPromptWithOptions:payload
+                                             completion:^(NSInteger buttonIndex, NSString *text) {
+                                               resolve(@{@"buttonIndex" : @(buttonIndex), @"text" : text});
+                                             }];
+  });
+}
+
 RCT_EXPORT_METHOD(dismissActionSheet)
 {
   dispatch_async(dispatch_get_main_queue(), ^{