react-native-rn-story-editor 0.2.0 → 0.2.2

package/README.md

@@ -31,38 +31,44 @@ npm install react-native-rn-story-editor
 ```jsx
 import { useRef, useEffect } from 'react';
 import { View, StyleSheet, DeviceEventEmitter } from 'react-native';
-import { StoryEditorView, StoryEditorCommands } from 'react-native-rn-story-editor';
+import {
+  StoryEditorView,
+  StoryEditorCommands,
+} from 'react-native-rn-story-editor';
 
 export default function App() {
   const editorRef = useRef(null);
 
   useEffect(() => {
     // Listen for export events
-    const subscription = DeviceEventEmitter.addListener('onExportImage', (event) => {
-      console.log('Exported image base64:', event.image);
-    });
+    const subscription = DeviceEventEmitter.addListener(
+      'onExportImage',
+      (event) => {
+        console.log('Exported image base64:', event.image);
+      }
+    );
     return () => subscription.remove();
   }, []);
 
   return (
     <View style={styles.container}>
-      <StoryEditorView 
+      <StoryEditorView
         ref={editorRef}
         colorString="#32a852"
         baseImage="data:image/png;base64,iVBORw0KGgo..."
         style={styles.editor}
       />
-      
+
       {/* Export to gallery or get base64 */}
-      <Button 
-        title="Export Image" 
-        onPress={() => StoryEditorCommands.exportImage(editorRef.current)} 
+      <Button
+        title="Export Image"
+        onPress={() => StoryEditorCommands.exportImage(editorRef.current)}
       />
-      
+
       {/* Show text input dialog */}
-      <Button 
-        title="Add Text" 
-        onPress={() => StoryEditorCommands.showTextInput(editorRef.current)} 
+      <Button
+        title="Add Text"
+        onPress={() => StoryEditorCommands.showTextInput(editorRef.current)}
       />
     </View>
   );
@@ -70,27 +76,27 @@ export default function App() {
 
 const styles = StyleSheet.create({
   container: { flex: 1 },
-  editor: { width: 300, height: 400 }
+  editor: { width: 300, height: 400 },
 });
 ```
 
 ## Props
 
-| Prop | Type | Default | Description |
-|------|------|----------|-------------|
-| `color` | `number` | `Color.TRANSPARENT` | Numeric color value (e.g., `0xFF32a852`) |
-| `colorString` | `string` | `undefined` | Hex color string (e.g., `"#32a852"`) |
-| `baseImage` | `string` | `undefined` | Base64 encoded background image (supports data URI format) |
-| `addText` | `string` | `undefined` | Add text layer programmatically |
-| `addImage` | `string` | `undefined` | Add overlay image from base64 (supports data URI format) |
-| `style` | `ViewStyle` | `undefined` | React Native style object |
+| Prop          | Type        | Default             | Description                                                |
+| ------------- | ----------- | ------------------- | ---------------------------------------------------------- |
+| `color`       | `number`    | `Color.TRANSPARENT` | Numeric color value (e.g., `0xFF32a852`)                   |
+| `colorString` | `string`    | `undefined`         | Hex color string (e.g., `"#32a852"`)                       |
+| `baseImage`   | `string`    | `undefined`         | Base64 encoded background image (supports data URI format) |
+| `addText`     | `string`    | `undefined`         | Add text layer programmatically                            |
+| `addImage`    | `string`    | `undefined`         | Add overlay image from base64 (supports data URI format)   |
+| `style`       | `ViewStyle` | `undefined`         | React Native style object                                  |
 
 ## Commands
 
-| Command | Parameters | Description |
-|---------|------------|-------------|
-| `exportImage` | `(ref: React.Ref)` | Shows export dialog with gallery save and database options |
-| `showTextInput` | `(ref: React.Ref)` | Shows native text input dialog to add text layer |
+| Command         | Parameters         | Description                                                |
+| --------------- | ------------------ | ---------------------------------------------------------- |
+| `exportImage`   | `(ref: React.Ref)` | Shows export dialog with gallery save and database options |
+| `showTextInput` | `(ref: React.Ref)` | Shows native text input dialog to add text layer           |
 
 ## Events
 
@@ -123,16 +129,18 @@ When `exportImage` is called, users see a dialog with:
 ## Testing
 
 ### Unit Tests
+
 ```bash
 npm test
 ```
 
 ### Manual Testing
+
 ```bash
 # Test on Android
 npm run example:android
 
-# Test on iOS  
+# Test on iOS
 npm run example:ios
 
 # Test different React Native versions
@@ -142,8 +150,9 @@ npm install react-native@0.73
 ```
 
 ### Cross-Platform Verification
+
 - Android: Tested on API 24+ (emulators/devices)
-- iOS: Test on iOS 12+ (simulators/devices) 
+- iOS: Test on iOS 12+ (simulators/devices)
 - React Native: Test with multiple versions
 - TypeScript: All types compile correctly
 - Props: Color, style, baseImage, addText, addImage
@@ -153,6 +162,7 @@ npm install react-native@0.73
 ## Version History
 
 ### 0.2.0
+
 - Added layer management (text and image layers)
 - Added drag-and-drop functionality
 - Added base64 image support for backgrounds and overlays
@@ -162,6 +172,7 @@ npm install react-native@0.73
 - Improved event system for JavaScript communication
 
 ### 0.1.0
+
 - Initial release
 - Basic view component with color support
 - Native commands structure

package/android/src/main/java/com/rnstoryeditor/RnStoryEditorEventEmitter.kt

@@ -6,7 +6,12 @@ import com.facebook.react.bridge.ReactMethod
 import com.facebook.react.modules.core.DeviceEventManagerModule
 import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.WritableMap
+import android.util.Log
 
+/**
+ * Event emitter for Story Editor
+ * Handles both success events and error events
+ */
 class RnStoryEditorEventEmitter(reactContext: ReactApplicationContext) : ReactContextBaseJavaModule(reactContext) {
 
     override fun getName(): String {
@@ -14,19 +19,95 @@ class RnStoryEditorEventEmitter(reactContext: ReactApplicationContext) : ReactCo
     }
 
     companion object {
+        private const val TAG = "StoryEditorEvent"
         private var reactAppContext: ReactApplicationContext? = null
 
         fun setReactContext(context: ReactApplicationContext) {
             reactAppContext = context
+            Log.d(TAG, "React context set successfully")
         }
 
+        /**
+         * Emits a success event with base64 image data
+         */
         fun emitEvent(eventName: String, base64: String) {
-            val params = Arguments.createMap()
-            params.putString("image", base64)
-            reactAppContext?.let { ctx ->
-                ctx.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
-                    .emit(eventName, params)
+            try {
+                val params = Arguments.createMap().apply {
+                    putString("base64", base64)
+                    putNull("error")
+                }
+                
+                reactAppContext?.let { ctx ->
+                    ctx.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+                        .emit(eventName, params)
+                    Log.d(TAG, "Event emitted successfully: $eventName")
+                } ?: run {
+                    Log.e(TAG, "Cannot emit event - React context is null")
+                }
+            } catch (e: Exception) {
+                Log.e(TAG, "Failed to emit event: ${e.message}")
+                emitError(StoryEditorError.unknownError("emitEvent", e))
             }
         }
+
+        /**
+         * Emits an error event to JavaScript
+         */
+        fun emitError(error: StoryEditorError) {
+            try {
+                val params = Arguments.createMap().apply {
+                    putString("code", error.code)
+                    putString("message", error.message)
+                    error.nativeError?.let {
+                        putString("nativeError", it.message)
+                    }
+                }
+                
+                reactAppContext?.let { ctx ->
+                    ctx.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+                        .emit("onStoryEditorError", params)
+                    Log.e(TAG, "Error emitted [${error.code}]: ${error.message}")
+                } ?: run {
+                    Log.e(TAG, "Cannot emit error - React context is null. Error: [${error.code}] ${error.message}")
+                }
+            } catch (e: Exception) {
+                Log.e(TAG, "Failed to emit error event: ${e.message}")
+            }
+        }
+
+        /**
+         * Convenience method to emit export success
+         */
+        fun emitExportSuccess(base64: String) {
+            emitEvent("onExportImage", base64)
+        }
+
+        /**
+         * Convenience method to emit export error
+         */
+        fun emitExportError(error: StoryEditorError) {
+            try {
+                val params = Arguments.createMap().apply {
+                    putString("base64", "")
+                    putString("errorCode", error.code)
+                    putString("errorMessage", error.message)
+                }
+                
+                reactAppContext?.let { ctx ->
+                    ctx.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+                        .emit("onExportImage", params)
+                    Log.e(TAG, "Export error emitted [${error.code}]: ${error.message}")
+                }
+            } catch (e: Exception) {
+                Log.e(TAG, "Failed to emit export error: ${e.message}")
+            }
+        }
+
+        /**
+         * Check if react context is available
+         */
+        fun hasReactContext(): Boolean {
+            return reactAppContext != null
+        }
     }
 }

package/android/src/main/java/com/rnstoryeditor/RnStoryEditorView.kt

@@ -67,10 +67,14 @@ class RnStoryEditorView(context: Context, attrs: AttributeSet? = null) : View(co
     }
 
     fun addImage(base64: String) {
-        base64?.let {
-            val bytes = Base64.decode(it, Base64.DEFAULT)
+        safeStoryEditorCall("addImage") {
+            val bytes = Base64.decode(base64, Base64.DEFAULT)
             val bitmap = BitmapFactory.decodeByteArray(bytes, 0, bytes.size)
             
+            if (bitmap == null) {
+                throw StoryEditorError.bitmapDecodeFailed("Failed to decode base64 to bitmap")
+            }
+            
             // Scale image to reasonable size (max 200dp width)
             val maxWidth = 200f * resources.displayMetrics.density
             val scale = maxWidth / bitmap.width
@@ -85,29 +89,45 @@ class RnStoryEditorView(context: Context, attrs: AttributeSet? = null) : View(co
             
             layers.add(Layer.ImageLayer(scaledBitmap, x, y, scaledWidth, scaledHeight))
             invalidate()
+        }.onError { error ->
+            RnStoryEditorEventEmitter.emitError(error)
         }
     }
 
     fun showTextInputDialog() {
         Log.d("RnStoryEditorView", "showTextInputDialog called")
-        val editText = EditText(context)
-        editText.hint = "Enter text here"
         
-        AlertDialog.Builder(context)
-            .setTitle("Add Text Layer")
-            .setView(editText)
-            .setPositiveButton("Add") { dialog, _ ->
-                val inputText = editText.text.toString()
-                Log.d("RnStoryEditorView", "Input text: $inputText")
-                if (inputText.isNotEmpty()) {
-                    addText(inputText)
+        try {
+            val editText = EditText(context)
+            editText.hint = "Enter text here"
+            
+            AlertDialog.Builder(context)
+                .setTitle("Add Text Layer")
+                .setView(editText)
+                .setPositiveButton("Add") { dialog, _ ->
+                    val inputText = editText.text.toString()
+                    Log.d("RnStoryEditorView", "Input text: $inputText")
+                    if (inputText.isNotEmpty()) {
+                        try {
+                            addText(inputText)
+                        } catch (e: Exception) {
+                            RnStoryEditorEventEmitter.emitError(
+                                StoryEditorError.textInputFailed("Failed to add text: ${e.message}")
+                            )
+                        }
+                    }
+                    dialog.dismiss()
                 }
-                dialog.dismiss()
-            }
-            .setNegativeButton("Cancel") { dialog, _ ->
-                dialog.dismiss()
-            }
-            .show()
+                .setNegativeButton("Cancel") { dialog, _ ->
+                    dialog.dismiss()
+                }
+                .show()
+        } catch (e: Exception) {
+            Log.e("RnStoryEditorView", "Error showing text input dialog: ${e.message}")
+            RnStoryEditorEventEmitter.emitError(
+                StoryEditorError.textInputFailed("Dialog creation failed: ${e.message}")
+            )
+        }
     }
 
     fun showImageOptionsDialog(imageLayer: Layer.ImageLayer) {
@@ -261,8 +281,8 @@ class RnStoryEditorView(context: Context, attrs: AttributeSet? = null) : View(co
         return true
     }
 
-    fun saveImageToGallery(bitmap: Bitmap): Boolean {
-        return try {
+    fun saveImageToGallery(bitmap: Bitmap): StoryEditorResult<String> {
+        return safeStoryEditorCall("saveImageToGallery") {
             val timestamp = SimpleDateFormat("yyyyMMdd_HHmmss", Locale.getDefault()).format(Date())
             val filename = "StoryEditor_$timestamp.png"
             
@@ -276,23 +296,27 @@ class RnStoryEditorView(context: Context, attrs: AttributeSet? = null) : View(co
                 }
                 
                 val uri = resolver.insert(MediaStore.Images.Media.EXTERNAL_CONTENT_URI, contentValues)
-                uri?.let {
-                    val outputStream: OutputStream? = resolver.openOutputStream(it)
-                    outputStream?.use { stream ->
-                        bitmap.compress(Bitmap.CompressFormat.PNG, 100, stream)
+                    ?: throw StoryEditorError.fileSaveFailed("Failed to create MediaStore entry")
+                    
+                resolver.openOutputStream(uri)?.use { stream ->
+                    if (!bitmap.compress(Bitmap.CompressFormat.PNG, 100, stream)) {
+                        throw StoryEditorError.fileSaveFailed("Bitmap compression failed")
                     }
-                }
+                } ?: throw StoryEditorError.fileSaveFailed("Failed to open output stream")
+                
+                uri.toString()
             } else {
                 // Android 9 and below use File
                 val directory = File(Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_PICTURES), "StoryEditor")
-                if (!directory.exists()) {
-                    directory.mkdirs()
+                if (!directory.exists() && !directory.mkdirs()) {
+                    throw StoryEditorError.fileSaveFailed("Failed to create directory")
                 }
                 
                 val imageFile = File(directory, filename)
-                val outputStream = FileOutputStream(imageFile)
-                outputStream.use { stream ->
-                    bitmap.compress(Bitmap.CompressFormat.PNG, 100, stream)
+                FileOutputStream(imageFile).use { stream ->
+                    if (!bitmap.compress(Bitmap.CompressFormat.PNG, 100, stream)) {
+                        throw StoryEditorError.fileSaveFailed("Bitmap compression failed")
+                    }
                 }
                 
                 // Add to gallery
@@ -301,83 +325,100 @@ class RnStoryEditorView(context: Context, attrs: AttributeSet? = null) : View(co
                     put(MediaStore.Images.Media.MIME_TYPE, "image/png")
                 }
                 context.contentResolver.insert(MediaStore.Images.Media.EXTERNAL_CONTENT_URI, contentValues)
+                imageFile.absolutePath
+            }.also {
+                Log.d("RnStoryEditorView", "Image saved to gallery: $filename")
             }
-            
-            Log.d("RnStoryEditorView", "Image saved to gallery: $filename")
-            true
-        } catch (e: Exception) {
-            Log.e("RnStoryEditorView", "Error saving image: ${e.message}")
-            false
         }
     }
 
     // Merge layers and send base64 back to JS
     fun exportAndSendBase64() {
-        val bitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888)
-        val canvas = Canvas(bitmap)
-        draw(canvas)
+        safeStoryEditorCall("exportAndSendBase64") {
+            if (width <= 0 || height <= 0) {
+                throw StoryEditorError.imageExportFailed("View has invalid dimensions: ${width}x${height}")
+            }
+            
+            val bitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888)
+            val canvas = Canvas(bitmap)
+            draw(canvas)
 
-        val outputStream = ByteArrayOutputStream()
-        bitmap.compress(Bitmap.CompressFormat.PNG, 100, outputStream)
-        val byteArray = outputStream.toByteArray()
-        val base64 = Base64.encodeToString(byteArray, Base64.NO_WRAP)
+            val outputStream = ByteArrayOutputStream()
+            if (!bitmap.compress(Bitmap.CompressFormat.PNG, 100, outputStream)) {
+                throw StoryEditorError.imageExportFailed("Failed to compress bitmap to PNG")
+            }
+            
+            val byteArray = outputStream.toByteArray()
+            val base64 = Base64.encodeToString(byteArray, Base64.NO_WRAP)
 
-        // Show export dialog with download and database options
-        showExportPreviewDialog(bitmap, base64)
+            // Show export dialog with download and database options
+            showExportPreviewDialog(bitmap, base64)
+        }.onError { error ->
+            RnStoryEditorEventEmitter.emitExportError(error)
+        }
     }
 
     fun showExportPreviewDialog(bitmap: Bitmap, base64: String) {
-        val imageView = ImageView(context)
-        imageView.setImageBitmap(bitmap)
-        imageView.setPadding(20, 20, 20, 20)
-        
-        val infoText = TextView(context)
-        val sizeKB = base64.length / 1024
-        val sizeMB = sizeKB / 1024.0
-        val imageCount = layers.count { it is Layer.ImageLayer }
-        val textCount = layers.count { it is Layer.TextLayer }
-        infoText.text = """
-            Export Information:
-            • Image Size: ${bitmap.width} x ${bitmap.height}px
-            • File Size: ${sizeKB} KB (${String.format("%.2f", sizeMB)} MB)
-            • Base64 Length: ${base64.length} characters
-            • Format: PNG with Base64 encoding
-            • Image Layers: $imageCount
-            • Text Layers: $textCount
-            • Total Layers: ${layers.size}
+        try {
+            val imageView = ImageView(context)
+            imageView.setImageBitmap(bitmap)
+            imageView.setPadding(20, 20, 20, 20)
             
-            Choose export option below.
-        """.trimIndent()
-        infoText.setPadding(20, 10, 20, 20)
-        infoText.textSize = 14f
-        
-        val scrollView = ScrollView(context)
-        val layout = android.widget.LinearLayout(context)
-        layout.orientation = android.widget.LinearLayout.VERTICAL
-        layout.addView(imageView)
-        layout.addView(infoText)
-        scrollView.addView(layout)
-        
-        AlertDialog.Builder(context)
-            .setTitle("Export Options")
-            .setView(scrollView)
-            .setPositiveButton("Download to Gallery") { dialog, _ ->
-                val success = saveImageToGallery(bitmap)
-                if (success) {
-                    android.widget.Toast.makeText(context, "Image saved to gallery!", android.widget.Toast.LENGTH_SHORT).show()
-                } else {
-                    android.widget.Toast.makeText(context, "Failed to save image", android.widget.Toast.LENGTH_SHORT).show()
+            val infoText = TextView(context)
+            val sizeKB = base64.length / 1024
+            val sizeMB = sizeKB / 1024.0
+            val imageCount = layers.count { it is Layer.ImageLayer }
+            val textCount = layers.count { it is Layer.TextLayer }
+            infoText.text = """
+                Export Information:
+                • Image Size: ${bitmap.width} x ${bitmap.height}px
+                • File Size: ${sizeKB} KB (${String.format("%.2f", sizeMB)} MB)
+                • Base64 Length: ${base64.length} characters
+                • Format: PNG with Base64 encoding
+                • Image Layers: $imageCount
+                • Text Layers: $textCount
+                • Total Layers: ${layers.size}
+                
+                Choose export option below.
+            """.trimIndent()
+            infoText.setPadding(20, 10, 20, 20)
+            infoText.textSize = 14f
+            
+            val scrollView = ScrollView(context)
+            val layout = android.widget.LinearLayout(context)
+            layout.orientation = android.widget.LinearLayout.VERTICAL
+            layout.addView(imageView)
+            layout.addView(infoText)
+            scrollView.addView(layout)
+            
+            AlertDialog.Builder(context)
+                .setTitle("Export Options")
+                .setView(scrollView)
+                .setPositiveButton("Download to Gallery") { dialog, _ ->
+                    saveImageToGallery(bitmap)
+                        .onSuccess { path ->
+                            android.widget.Toast.makeText(context, "Image saved to gallery!", android.widget.Toast.LENGTH_SHORT).show()
+                        }
+                        .onError { error ->
+                            android.widget.Toast.makeText(context, "Failed to save image: ${error.message}", android.widget.Toast.LENGTH_LONG).show()
+                            RnStoryEditorEventEmitter.emitError(error)
+                        }
+                    dialog.dismiss()
                 }
-                dialog.dismiss()
-            }
-            .setNeutralButton("Send to Database") { dialog, _ ->
-                // Send event to JS with base64
-                RnStoryEditorEventEmitter.emitEvent("onExportImage", base64)
-                dialog.dismiss()
-            }
-            .setNegativeButton("Cancel") { dialog, _ ->
-                dialog.dismiss()
-            }
-            .show()
+                .setNeutralButton("Send to Database") { dialog, _ ->
+                    // Send event to JS with base64
+                    RnStoryEditorEventEmitter.emitExportSuccess(base64)
+                    dialog.dismiss()
+                }
+                .setNegativeButton("Cancel") { dialog, _ ->
+                    dialog.dismiss()
+                }
+                .show()
+        } catch (e: Exception) {
+            Log.e("RnStoryEditorView", "Error showing export dialog: ${e.message}")
+            RnStoryEditorEventEmitter.emitExportError(
+                StoryEditorError.imageExportFailed("Failed to show export dialog: ${e.message}", e)
+            )
+        }
     }
 }

package/android/src/main/java/com/rnstoryeditor/RnStoryEditorViewManager.kt

@@ -61,10 +61,28 @@ class RnStoryEditorViewManager : SimpleViewManager<RnStoryEditorView>(),
   @ReactProp(name = "baseImage")
   override fun setBaseImage(view: RnStoryEditorView, base64: String?) {
     base64?.let {
-      val cleanData = cleanBase64(it)
-      val bytes = android.util.Base64.decode(cleanData, android.util.Base64.DEFAULT)
-      val bitmap = android.graphics.BitmapFactory.decodeByteArray(bytes, 0, bytes.size)
-      view.setBaseImage(bitmap)
+      try {
+        val cleanData = cleanBase64(it)
+        val bytes = android.util.Base64.decode(cleanData, android.util.Base64.DEFAULT)
+        val bitmap = android.graphics.BitmapFactory.decodeByteArray(bytes, 0, bytes.size)
+        
+        if (bitmap == null) {
+          RnStoryEditorEventEmitter.emitError(
+            StoryEditorError.bitmapDecodeFailed("Decoded bitmap is null, invalid base64 data")
+          )
+          return
+        }
+        
+        view.setBaseImage(bitmap)
+      } catch (e: IllegalArgumentException) {
+        RnStoryEditorEventEmitter.emitError(StoryEditorError.invalidBase64())
+      } catch (e: OutOfMemoryError) {
+        RnStoryEditorEventEmitter.emitError(StoryEditorError.memoryError("decode base64", e))
+      } catch (e: Exception) {
+        RnStoryEditorEventEmitter.emitError(
+          StoryEditorError.bitmapDecodeFailed(e.message ?: "Unknown error")
+        )
+      }
     }
   }
 
@@ -76,8 +94,18 @@ class RnStoryEditorViewManager : SimpleViewManager<RnStoryEditorView>(),
   @ReactProp(name = "addImage")
   override fun setAddImage(view: RnStoryEditorView, base64: String?) {
     base64?.let { 
-      val cleanData = cleanBase64(it)
-      view.addImage(cleanData) 
+      try {
+        val cleanData = cleanBase64(it)
+        view.addImage(cleanData)
+      } catch (e: IllegalArgumentException) {
+        RnStoryEditorEventEmitter.emitError(StoryEditorError.invalidBase64())
+      } catch (e: StoryEditorError) {
+        RnStoryEditorEventEmitter.emitError(e)
+      } catch (e: Exception) {
+        RnStoryEditorEventEmitter.emitError(
+          StoryEditorError.layerOperationFailed("add image", e.message ?: "Unknown error")
+        )
+      }
     }
   }
 
@@ -88,8 +116,20 @@ class RnStoryEditorViewManager : SimpleViewManager<RnStoryEditorView>(),
 
   override fun receiveCommand(view: RnStoryEditorView, commandId: Int, args: ReadableArray?) {
     when (commandId) {
-      1 -> view.exportAndSendBase64()
-      2 -> view.showTextInputDialog()
+      1 -> {
+        safeStoryEditorCall("exportImage") {
+          view.exportAndSendBase64()
+        }.onError { error ->
+          RnStoryEditorEventEmitter.emitExportError(error)
+        }
+      }
+      2 -> {
+        safeStoryEditorCall("showTextInput") {
+          view.showTextInputDialog()
+        }.onError { error ->
+          RnStoryEditorEventEmitter.emitError(error)
+        }
+      }
     }
   }