@thiagobueno/rn-selectable-text 1.0.0

package/LICENSE

@@ -0,0 +1,20 @@
+MIT License
+
+Copyright (c) 2025 Robert Sherling
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,123 @@
+Disclaimer -
+
+I tested this code in my own projects, but this code has been with heavy assistance from Claude Code. If you see a problem - submit a ticket!
+
+# rn-selectable-text
+
+A React Native library for custom text selection menus, redesigned from the ground up for React Native 0.81.1 with full support for the new architecture (Fabric).
+
+The `SelectableTextView` component wraps your text content and provides custom menu options that appear when users select text. It supports nested text styling and cross-platform event handling.
+
+## Features
+
+- Cross-platform support (iOS & Android)
+- Support for nested text with different styles
+- Custom menu options with callback handling
+
+## Installation
+
+```sh
+yarn add @thiagobueno/rn-selectable-text
+```
+
+For iOS, run pod install:
+```sh
+cd ios && pod install
+```
+
+## Usage
+
+### Basic Example
+
+```tsx
+import React, { useState } from 'react';
+import { View, Text, Alert } from 'react-native';
+import { SelectableTextView } from '@thiagobueno/rn-selectable-text';
+
+export default function App() {
+
+  const handleSelection = (event) => {
+    const { chosenOption, highlightedText } = event;
+    Alert.alert(
+      'Selection Event',
+      `Option: ${chosenOption}\nSelected Text: ${highlightedText}`
+    );
+  };
+
+  return (
+    <View>
+
+      <SelectableTextView
+        menuOptions={['look up', 'copy', 'share']}
+        onSelection={handleSelection}
+        style={{ margin: 20 }}
+      >
+        <Text>This is simple selectable text</Text>
+      </SelectableTextView>
+    </View>
+  );
+}
+```
+
+### Advanced Example with Nested Text Styling
+
+```jsx
+<SelectableTextView
+  menuOptions={['Action 1', 'Action 2', 'Custom Action']}
+  onSelection={handleSelection}
+  style={{ marginHorizontal: 20 }}
+>
+  <Text style={{ color: 'black', fontSize: 16 }}>
+    This text is black{' '}
+    <Text style={{ textDecorationLine: 'underline', color: 'red' }}>
+      this part is underlined and red
+    </Text>{' '}
+    and this is black again. All of it is selectable with custom menu options!
+  </Text>
+</SelectableTextView>
+```
+
+## API Reference
+
+### SelectableTextView Props
+
+| Prop          | Type                              | Required | Description                                 |
+| ------------- | --------------------------------- | -------- | ------------------------------------------- |
+| `children`    | `React.ReactNode`                 | Yes      | Text components to make selectable          |
+| `menuOptions` | `string[]`                        | Yes      | Array of menu option strings                |
+| `onSelection` | `(event: SelectionEvent) => void` | No       | Callback fired when menu option is selected |
+| `style`       | `ViewStyle`                       | No       | Style object for the container              |
+
+### SelectionEvent
+
+The `onSelection` callback receives an event object with:
+
+```typescript
+interface SelectionEvent {
+  chosenOption: string;    // The menu option that was selected
+  highlightedText: string; // The text that was highlighted by the user
+}
+```
+
+## Requirements
+
+- React Native 0.81.1+
+- iOS 11.0+
+- Android API level 21+
+- React Native's new architecture (Fabric) enabled
+
+## Platform Differences
+
+The library handles platform differences internally:
+- **iOS**: Uses direct event handlers for optimal performance
+- **Android**: Uses DeviceEventEmitter for reliable event delivery
+
+Both platforms provide the same API and functionality.
+
+## License
+
+MIT
+
+---
+
+Made with [create-react-native-library](https://github.com/callstack/react-native-builder-bob)

package/android/build.gradle

@@ -0,0 +1,77 @@
+buildscript {
+  ext.getExtOrDefault = {name ->
+    return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties['SelectableText_' + name]
+  }
+
+  repositories {
+    google()
+    mavenCentral()
+  }
+
+  dependencies {
+    classpath "com.android.tools.build:gradle:8.7.2"
+    // noinspection DifferentKotlinGradleVersion
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${getExtOrDefault('kotlinVersion')}"
+  }
+}
+
+
+apply plugin: "com.android.library"
+apply plugin: "kotlin-android"
+
+apply plugin: "com.facebook.react"
+
+def getExtOrIntegerDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["SelectableText_" + name]).toInteger()
+}
+
+android {
+  namespace "com.selectabletext"
+
+  compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
+
+  defaultConfig {
+    minSdkVersion getExtOrIntegerDefault("minSdkVersion")
+    targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
+  }
+
+  buildFeatures {
+    buildConfig true
+  }
+
+  buildTypes {
+    release {
+      minifyEnabled false
+    }
+  }
+
+  lintOptions {
+    disable "GradleCompatible"
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_1_8
+    targetCompatibility JavaVersion.VERSION_1_8
+  }
+
+  sourceSets {
+    main {
+      java.srcDirs += [
+        "generated/java",
+        "generated/jni"
+      ]
+    }
+  }
+}
+
+repositories {
+  mavenCentral()
+  google()
+}
+
+def kotlin_version = getExtOrDefault("kotlinVersion")
+
+dependencies {
+  implementation "com.facebook.react:react-android"
+  implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+}

package/android/gradle.properties

@@ -0,0 +1,5 @@
+SelectableText_kotlinVersion=2.0.21
+SelectableText_minSdkVersion=24
+SelectableText_targetSdkVersion=34
+SelectableText_compileSdkVersion=35
+SelectableText_ndkVersion=27.1.12297006

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,2 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+</manifest>

package/android/src/main/java/com/selectabletext/SelectableTextPackage.kt

@@ -0,0 +1,19 @@
+package com.selectabletext
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+import java.util.ArrayList
+
+class SelectableTextViewPackage : ReactPackage {
+  override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
+    val viewManagers: MutableList<ViewManager<*, *>> = ArrayList()
+    viewManagers.add(SelectableTextViewManager())
+    return viewManagers
+  }
+
+  override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
+    return emptyList()
+  }
+}

package/android/src/main/java/com/selectabletext/SelectableTextView.kt

@@ -0,0 +1,97 @@
+package com.selectabletext
+
+import android.content.Context
+import android.util.AttributeSet
+import android.view.ActionMode
+import android.view.Menu
+import android.view.MenuItem
+import android.widget.FrameLayout
+import android.widget.TextView
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.modules.core.DeviceEventManagerModule
+
+class SelectableTextView : FrameLayout {
+  private var menuOptions: Array<String> = emptyArray()
+  private var textView: TextView? = null
+  
+  constructor(context: Context?) : super(context!!)
+  constructor(context: Context?, attrs: AttributeSet?) : super(context!!, attrs)
+  constructor(context: Context?, attrs: AttributeSet?, defStyleAttr: Int) : super(
+    context!!,
+    attrs,
+    defStyleAttr
+  )
+  
+  fun setMenuOptions(options: Array<String>) {
+    this.menuOptions = options
+    setupTextView()
+  }
+  
+  private fun setupTextView() {
+    // Find the first TextView child
+    for (i in 0 until childCount) {
+      val child = getChildAt(i)
+      if (child is TextView) {
+        textView = child
+        setupSelectionCallback(child)
+        break
+      }
+    }
+  }
+  
+  private fun setupSelectionCallback(textView: TextView) {
+    textView.setTextIsSelectable(true)
+    textView.customSelectionActionModeCallback = object : ActionMode.Callback {
+      override fun onCreateActionMode(mode: ActionMode?, menu: Menu?): Boolean {
+        return true
+      }
+      
+      override fun onPrepareActionMode(mode: ActionMode?, menu: Menu?): Boolean {
+        menu?.clear()
+        menuOptions.forEachIndexed { index, option ->
+          menu?.add(0, index, 0, option)
+        }
+        return true
+      }
+      
+      override fun onActionItemClicked(mode: ActionMode?, item: MenuItem?): Boolean {
+        val selectionStart = textView.selectionStart
+        val selectionEnd = textView.selectionEnd
+        val selectedText = textView.text.toString().substring(selectionStart, selectionEnd)
+        val chosenOption = menuOptions[item?.itemId ?: 0]
+        
+        // Send event to React Native
+        onSelectionEvent(chosenOption, selectedText)
+        
+        mode?.finish()
+        return true
+      }
+      
+      override fun onDestroyActionMode(mode: ActionMode?) {
+        // Called when action mode is destroyed
+      }
+    }
+  }
+  
+  private fun onSelectionEvent(chosenOption: String, highlightedText: String) {
+    val reactContext = context as ReactContext
+    val params = Arguments.createMap().apply {
+      putInt("viewTag", id)
+      putString("chosenOption", chosenOption)
+      putString("highlightedText", highlightedText)
+    }
+    
+    reactContext
+      .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+      .emit("SelectableTextSelection", params)
+  }
+  
+  override fun onLayout(changed: Boolean, left: Int, top: Int, right: Int, bottom: Int) {
+    super.onLayout(changed, left, top, right, bottom)
+    if (changed && textView == null) {
+      setupTextView()
+    }
+  }
+}

package/android/src/main/java/com/selectabletext/SelectableTextViewManager.kt

@@ -0,0 +1,53 @@
+package com.selectabletext
+
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.common.MapBuilder
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.uimanager.ViewGroupManager
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.ViewManagerDelegate
+import com.facebook.react.uimanager.annotations.ReactProp
+import com.facebook.react.viewmanagers.SelectableTextViewManagerInterface
+import com.facebook.react.viewmanagers.SelectableTextViewManagerDelegate
+
+@ReactModule(name = SelectableTextViewManager.NAME)
+class SelectableTextViewManager : ViewGroupManager<SelectableTextView>(),
+  SelectableTextViewManagerInterface<SelectableTextView> {
+  private val mDelegate: ViewManagerDelegate<SelectableTextView>
+
+  init {
+    mDelegate = SelectableTextViewManagerDelegate(this)
+  }
+
+  override fun getDelegate(): ViewManagerDelegate<SelectableTextView>? {
+    return mDelegate
+  }
+
+  override fun getName(): String {
+    return NAME
+  }
+
+  public override fun createViewInstance(context: ThemedReactContext): SelectableTextView {
+    return SelectableTextView(context)
+  }
+
+  @ReactProp(name = "menuOptions")
+  override fun setMenuOptions(view: SelectableTextView, menuOptions: ReadableArray?) {
+    if (menuOptions != null) {
+      val options = Array(menuOptions.size()) { i ->
+        menuOptions.getString(i) ?: ""
+      }
+      view.setMenuOptions(options)
+    }
+  }
+
+  override fun getExportedCustomDirectEventTypeConstants(): Map<String, Any>? {
+    return MapBuilder.builder<String, Any>()
+      .put("topSelection", MapBuilder.of("registrationName", "onSelection"))
+      .build()
+  }
+
+  companion object {
+    const val NAME = "SelectableTextView"
+  }
+}

package/ios/SelectableTextView.h

@@ -0,0 +1,16 @@
+#import <React/RCTViewComponentView.h>
+#import <UIKit/UIKit.h>
+
+#ifndef SelectableTextViewNativeComponent_h
+#define SelectableTextViewNativeComponent_h
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface SelectableTextView : RCTViewComponentView <UITextViewDelegate>
+@property (nonatomic, strong) UITextView *textView;
+@property (nonatomic, strong) NSArray<NSString *> *menuOptions;
+@end
+
+NS_ASSUME_NONNULL_END
+
+#endif /* SelectableTextViewNativeComponent_h */

package/ios/SelectableTextView.mm

@@ -0,0 +1,367 @@
+#import "SelectableTextView.h"
+
+#import <react/renderer/components/SelectableTextViewSpec/ComponentDescriptors.h>
+#import <react/renderer/components/SelectableTextViewSpec/EventEmitters.h>
+#import <react/renderer/components/SelectableTextViewSpec/Props.h>
+#import <react/renderer/components/SelectableTextViewSpec/RCTComponentViewHelpers.h>
+
+#import "RCTFabricComponentsPlugins.h"
+#import <React/RCTConversions.h>
+
+using namespace facebook::react;
+
+@class SelectableTextView;
+
+@interface SelectableUITextView : UITextView
+@property (nonatomic, weak) SelectableTextView *parentSelectableTextView;
+@end
+
+@implementation SelectableUITextView
+
+- (BOOL)canPerformAction:(SEL)action withSender:(id)sender
+{
+    if (self.parentSelectableTextView) {
+        return [self.parentSelectableTextView canPerformAction:action withSender:sender];
+    }
+    return [super canPerformAction:action withSender:sender];
+}
+
+- (NSMethodSignature *)methodSignatureForSelector:(SEL)aSelector
+{
+    if (self.parentSelectableTextView) {
+        NSMethodSignature *signature = [self.parentSelectableTextView methodSignatureForSelector:aSelector];
+        if (signature) {
+            return signature;
+        }
+    }
+    return [super methodSignatureForSelector:aSelector];
+}
+
+- (void)forwardInvocation:(NSInvocation *)anInvocation
+{
+    if (self.parentSelectableTextView) {
+        [self.parentSelectableTextView forwardInvocation:anInvocation];
+    } else {
+        [super forwardInvocation:anInvocation];
+    }
+}
+
+- (void)copy:(id)sender
+{
+    // Bloqueado
+}
+
+@end
+
+@interface SelectableTextView () <RCTSelectableTextViewViewProtocol, UITextViewDelegate>
+- (void)unhideAllViews:(UIView *)view;
+@end
+
+@implementation SelectableTextView {
+    std::vector<std::string> _menuOptionsVector;
+    SelectableUITextView *_customTextView;
+    NSArray<NSString *> *_menuOptions;
+}
+
++ (ComponentDescriptorProvider)componentDescriptorProvider
+{
+    return concreteComponentDescriptorProvider<SelectableTextViewComponentDescriptor>();
+}
+
+- (instancetype)initWithFrame:(CGRect)frame
+{
+  if (self = [super initWithFrame:frame]) {
+    static const auto defaultProps = std::make_shared<const SelectableTextViewProps>();
+    _props = defaultProps;
+
+    _customTextView = [[SelectableUITextView alloc] init];
+    _customTextView.parentSelectableTextView = self;
+    _customTextView.delegate = self;
+    _customTextView.editable = NO;
+    _customTextView.selectable = YES;
+    _customTextView.scrollEnabled = NO;
+    _customTextView.backgroundColor = [UIColor clearColor];
+    _customTextView.textContainerInset = UIEdgeInsetsZero;
+    _customTextView.textContainer.lineFragmentPadding = 0;
+    _customTextView.userInteractionEnabled = YES;
+    
+    _customTextView.allowsEditingTextAttributes = NO;
+    _customTextView.dataDetectorTypes = UIDataDetectorTypeNone;
+    
+    _customTextView.text = @"";
+    _menuOptions = @[];
+    
+    self.contentView = _customTextView;
+    self.userInteractionEnabled = YES;
+  }
+
+  return self;
+}
+
+- (void)updateLayoutMetrics:(const facebook::react::LayoutMetrics &)layoutMetrics
+           oldLayoutMetrics:(const facebook::react::LayoutMetrics &)oldLayoutMetrics {
+    [super updateLayoutMetrics:layoutMetrics oldLayoutMetrics:oldLayoutMetrics];
+    
+    CGRect frame = RCTCGRectFromRect(layoutMetrics.getContentFrame());
+    _customTextView.frame = frame;
+}
+
+- (void)unhideAllViews:(UIView *)view {
+    if (view != _customTextView && view != self) {
+        view.hidden = NO;
+    }
+    for (UIView *subview in view.subviews) {
+        [self unhideAllViews:subview];
+    }
+}
+
+- (void)unmountChildComponentView:(UIView<RCTComponentViewProtocol> *)childComponentView index:(NSInteger)index
+{
+    [self unhideAllViews:childComponentView];
+    [super unmountChildComponentView:childComponentView index:index];
+}
+
+- (void)prepareForRecycle {
+    [super prepareForRecycle];
+    
+    [[UIMenuController sharedMenuController] hideMenuFromView:_customTextView];
+    [UIMenuController sharedMenuController].menuItems = nil;
+    
+    _customTextView.text = nil;
+    _customTextView.selectedTextRange = nil;
+    _menuOptions = @[];
+    _menuOptionsVector.clear();
+    
+    [self unhideAllViews:self];
+}
+
+- (void)dealloc {
+    [[NSNotificationCenter defaultCenter] removeObserver:self];
+    [UIMenuController sharedMenuController].menuItems = nil;
+}
+
+- (void)updateProps:(Props::Shared const &)props oldProps:(Props::Shared const &)oldProps
+{
+    const auto &oldViewProps = *std::static_pointer_cast<SelectableTextViewProps const>(_props);
+    const auto &newViewProps = *std::static_pointer_cast<SelectableTextViewProps const>(props);
+
+    if (oldViewProps.menuOptions != newViewProps.menuOptions) {
+        _menuOptionsVector = newViewProps.menuOptions;
+        
+        NSMutableArray<NSString *> *options = [[NSMutableArray alloc] init];
+        for (const auto& option : _menuOptionsVector) {
+            [options addObject:[NSString stringWithUTF8String:option.c_str()]];
+        }
+        _menuOptions = options;
+    }
+
+    [super updateProps:props oldProps:oldProps];
+}
+
+- (void)mountChildComponentView:(UIView<RCTComponentViewProtocol> *)childComponentView index:(NSInteger)index
+{
+    [super mountChildComponentView:childComponentView index:index];
+}
+
+- (void)layoutSubviews
+{
+    [super layoutSubviews];
+    [self updateTextViewContent];
+}
+
+- (void)updateTextViewContent
+{
+    NSMutableAttributedString *combinedAttributedText = [[NSMutableAttributedString alloc] init];
+    [self extractStyledTextFromView:self intoAttributedString:combinedAttributedText hideViews:YES];
+    _customTextView.attributedText = combinedAttributedText;
+}
+
+- (void)extractStyledTextFromView:(UIView *)view intoAttributedString:(NSMutableAttributedString *)attributedString hideViews:(BOOL)hideViews
+{
+    BOOL foundText = NO;
+    
+    if ([view respondsToSelector:@selector(attributedText)]) {
+        NSAttributedString *attributedText = [view performSelector:@selector(attributedText)];
+        if (attributedText && attributedText.length > 0) {
+            [attributedString appendAttributedString:attributedText];
+            foundText = YES;
+        }
+    }
+    else if ([view isKindOfClass:[UILabel class]]) {
+        UILabel *label = (UILabel *)view;
+        if (label.attributedText && label.attributedText.length > 0) {
+            [attributedString appendAttributedString:label.attributedText];
+            foundText = YES;
+        } else if (label.text && label.text.length > 0) {
+            NSAttributedString *plainText = [[NSAttributedString alloc] initWithString:label.text];
+            [attributedString appendAttributedString:plainText];
+            foundText = YES;
+        }
+    }
+    else if ([view respondsToSelector:@selector(text)]) {
+        NSString *text = [view performSelector:@selector(text)];
+        if (text && text.length > 0) {
+            NSAttributedString *plainText = [[NSAttributedString alloc] initWithString:text];
+            [attributedString appendAttributedString:plainText];
+            foundText = YES;
+        }
+    }
+    
+    if (foundText && hideViews && view != _customTextView && view != self) {
+        view.hidden = YES;
+    }
+    
+    for (UIView *subview in view.subviews) {
+        if (subview != _customTextView && subview != self.contentView) {
+            [self extractStyledTextFromView:subview intoAttributedString:attributedString hideViews:hideViews];
+        }
+    }
+}
+
+#pragma mark - UITextViewDelegate
+
+// ====================================================================
+// A NOVA API DO IOS 16+ (Estável, Rápida e Imune a Crashes)
+// ====================================================================
+- (UIMenu *)textView:(UITextView *)textView editMenuForTextInRange:(NSRange)range suggestedActions:(NSArray<UIMenuElement *> *)suggestedActions API_AVAILABLE(ios(16.0)) {
+    NSMutableArray<UIMenuElement *> *customActions = [[NSMutableArray alloc] init];
+
+    for (NSString *option in _menuOptions) {
+        // Mapeia o botão diretamente para nossa função sem precisar de hacks de string
+        UIAction *action = [UIAction actionWithTitle:option image:nil identifier:nil handler:^(__kindof UIAction * _Nonnull action) {
+            [self handleMenuSelection:option];
+        }];
+        [customActions addObject:action];
+    }
+
+    // Retorna APENAS o nosso menu customizado, esmagando as opções padrões da Apple
+    return [UIMenu menuWithTitle:@"" children:customActions];
+}
+
+- (void)textViewDidChangeSelection:(UITextView *)textView
+{
+    if (@available(iOS 16.0, *)) {
+        // No iOS 16+, a Apple cuida da exibição do menu automaticamente via delegate
+        return;
+    } else {
+        // Fallback legado para iPhones antigos (iOS 15 ou menor)
+        if (textView.selectedRange.length > 0 && _menuOptions.count > 0) {
+            dispatch_async(dispatch_get_main_queue(), ^{
+                [self showCustomMenu];
+            });
+        } else {
+            [[UIMenuController sharedMenuController] hideMenuFromView:_customTextView];
+        }
+    }
+}
+
+// Fallback apenas para iOS 15 e inferiores
+- (void)showCustomMenu
+{
+    if (![_customTextView canBecomeFirstResponder]) return;
+    
+    [_customTextView becomeFirstResponder];
+    
+    UIMenuController *menuController = [UIMenuController sharedMenuController];
+    menuController.menuItems = nil;
+    
+    NSMutableArray<UIMenuItem *> *menuItems = [[NSMutableArray alloc] init];
+    
+    for (NSString *option in _menuOptions) {
+        NSString *clean1 = [option stringByReplacingOccurrencesOfString:@" " withString:@"_"];
+        NSRegularExpression *regex = [NSRegularExpression regularExpressionWithPattern:@"[^a-zA-Z0-9_]" options:0 error:nil];
+        NSString *selectorName = [regex stringByReplacingMatchesInString:clean1 options:0 range:NSMakeRange(0, clean1.length) withTemplate:@"_"];
+        
+        SEL action = NSSelectorFromString([NSString stringWithFormat:@"customAction_%@:", selectorName]);
+        UIMenuItem *menuItem = [[UIMenuItem alloc] initWithTitle:option action:action];
+        [menuItems addObject:menuItem];
+    }
+    
+    menuController.menuItems = menuItems;
+    [menuController update];
+    
+    CGRect selectedRect = [_customTextView firstRectForRange:_customTextView.selectedTextRange];
+    
+    if (!CGRectIsEmpty(selectedRect)) {
+        CGRect targetRect = [_customTextView convertRect:selectedRect toView:_customTextView];
+        [menuController showMenuFromView:_customTextView rect:targetRect];
+    }
+}
+
+- (BOOL)canBecomeFirstResponder
+{
+    return YES;
+}
+
+- (BOOL)canPerformAction:(SEL)action withSender:(id)sender
+{
+    NSString *selectorName = NSStringFromSelector(action);
+    if ([selectorName hasPrefix:@"customAction_"] && [selectorName hasSuffix:@":"]) {
+        return YES;
+    }
+    return NO;
+}
+
+- (NSMethodSignature *)methodSignatureForSelector:(SEL)aSelector
+{
+    NSString *selectorName = NSStringFromSelector(aSelector);
+    if ([selectorName hasPrefix:@"customAction_"] && [selectorName hasSuffix:@":"]) {
+        return [NSMethodSignature signatureWithObjCTypes:"v@:@"];
+    }
+    return [super methodSignatureForSelector:aSelector];
+}
+
+- (void)forwardInvocation:(NSInvocation *)anInvocation
+{
+    NSString *selectorName = NSStringFromSelector(anInvocation.selector);
+    
+    if ([selectorName hasPrefix:@"customAction_"] && [selectorName hasSuffix:@":"]) {
+        NSString *cleanedOption = [selectorName substringWithRange:NSMakeRange(13, selectorName.length - 14)];
+        
+        NSString *originalOption = nil;
+        for (NSString *option in _menuOptions) {
+            NSString *clean1 = [option stringByReplacingOccurrencesOfString:@" " withString:@"_"];
+            NSRegularExpression *regex = [NSRegularExpression regularExpressionWithPattern:@"[^a-zA-Z0-9_]" options:0 error:nil];
+            NSString *testSelectorName = [regex stringByReplacingMatchesInString:clean1 options:0 range:NSMakeRange(0, clean1.length) withTemplate:@"_"];
+            
+            if ([testSelectorName isEqualToString:cleanedOption]) {
+                originalOption = option;
+                break;
+            }
+        }
+        
+        if (originalOption) {
+            [self handleMenuSelection:originalOption];
+        }
+    } else {
+        [super forwardInvocation:anInvocation];
+    }
+}
+
+- (void)handleMenuSelection:(NSString *)selectedOption
+{
+    NSRange selectedRange = _customTextView.selectedRange;
+    NSString *selectedText = @"";
+    
+    if (selectedRange.location != NSNotFound && selectedRange.length > 0) {
+        selectedText = [_customTextView.text substringWithRange:selectedRange];
+    }
+    
+    _customTextView.selectedRange = NSMakeRange(0, 0);
+    [[UIMenuController sharedMenuController] hideMenuFromView:_customTextView];
+    
+    if (auto eventEmitter = std::static_pointer_cast<const SelectableTextViewEventEmitter>(_eventEmitter)) {
+        SelectableTextViewEventEmitter::OnSelection selectionEvent = {
+            .chosenOption = std::string([selectedOption UTF8String]),
+            .highlightedText = std::string([selectedText UTF8String])
+        };
+        eventEmitter->onSelection(selectionEvent);
+    }
+}
+
+Class<RCTComponentViewProtocol> SelectableTextViewCls(void)
+{
+    return SelectableTextView.class;
+}
+
+@end

package/lib/module/SelectableTextView.js

@@ -0,0 +1,43 @@
+"use strict";
+
+import React, { useRef, useEffect } from 'react';
+import { Platform, findNodeHandle, DeviceEventEmitter } from 'react-native';
+import SelectableTextViewNativeComponent from './SelectableTextViewNativeComponent';
+import { jsx as _jsx } from "react/jsx-runtime";
+export const SelectableTextView = ({
+  children,
+  menuOptions,
+  onSelection,
+  style
+}) => {
+  const viewRef = useRef(null);
+  useEffect(() => {
+    if (Platform.OS === 'android' && onSelection) {
+      const subscription = DeviceEventEmitter.addListener('SelectableTextSelection', eventData => {
+        const viewTag = findNodeHandle(viewRef.current);
+        if (viewTag === eventData.viewTag) {
+          onSelection({
+            chosenOption: eventData.chosenOption,
+            highlightedText: eventData.highlightedText
+          });
+        }
+      });
+      return () => subscription.remove();
+    }
+    return () => {};
+  }, [onSelection]);
+  const handleSelection = event => {
+    if (Platform.OS === 'ios' && onSelection) {
+      console.log('SelectableTextView - Direct event received:', event.nativeEvent);
+      onSelection(event.nativeEvent);
+    }
+  };
+  return /*#__PURE__*/_jsx(SelectableTextViewNativeComponent, {
+    ref: viewRef,
+    style: style,
+    menuOptions: menuOptions,
+    onSelection: Platform.OS === 'ios' ? handleSelection : undefined,
+    children: children
+  });
+};
+//# sourceMappingURL=SelectableTextView.js.map

package/lib/module/SelectableTextView.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["React","useRef","useEffect","Platform","findNodeHandle","DeviceEventEmitter","SelectableTextViewNativeComponent","jsx","_jsx","SelectableTextView","children","menuOptions","onSelection","style","viewRef","OS","subscription","addListener","eventData","viewTag","current","chosenOption","highlightedText","remove","handleSelection","event","console","log","nativeEvent","ref","undefined"],"sourceRoot":"../../src","sources":["SelectableTextView.tsx"],"mappings":";;AAAA,OAAOA,KAAK,IAAIC,MAAM,EAAEC,SAAS,QAAQ,OAAO;AAEhD,SAASC,QAAQ,EAAEC,cAAc,EAAEC,kBAAkB,QAAQ,cAAc;AAC3E,OAAOC,iCAAiC,MAEjC,qCAAqC;AAAC,SAAAC,GAAA,IAAAC,IAAA;AAS7C,OAAO,MAAMC,kBAAqD,GAAGA,CAAC;EAClEC,QAAQ;EACRC,WAAW;EACXC,WAAW;EACXC;AACJ,CAAC,KAAK;EACF,MAAMC,OAAO,GAAGb,MAAM,CAAM,IAAI,CAAC;EAEjCC,SAAS,CAAC,MAAM;IACZ,IAAIC,QAAQ,CAACY,EAAE,KAAK,SAAS,IAAIH,WAAW,EAAE;MAC1C,MAAMI,YAAY,GAAGX,kBAAkB,CAACY,WAAW,CAC/C,yBAAyB,EACxBC,SAIA,IAAK;QACF,MAAMC,OAAO,GAAGf,cAAc,CAACU,OAAO,CAACM,OAAO,CAAC;QAC/C,IAAID,OAAO,KAAKD,SAAS,CAACC,OAAO,EAAE;UAC/BP,WAAW,CAAC;YACRS,YAAY,EAAEH,SAAS,CAACG,YAAY;YACpCC,eAAe,EAAEJ,SAAS,CAACI;UAC/B,CAAC,CAAC;QACN;MACJ,CACJ,CAAC;MAED,OAAO,MAAMN,YAAY,CAACO,MAAM,CAAC,CAAC;IACtC;IACA,OAAO,MAAM,CAAE,CAAC;EACpB,CAAC,EAAE,CAACX,WAAW,CAAC,CAAC;EAEjB,MAAMY,eAAe,GAAIC,KAA2C,IAAK;IACrE,IAAItB,QAAQ,CAACY,EAAE,KAAK,KAAK,IAAIH,WAAW,EAAE;MACtCc,OAAO,CAACC,GAAG,CACP,6CAA6C,EAC7CF,KAAK,CAACG,WACV,CAAC;MACDhB,WAAW,CAACa,KAAK,CAACG,WAAW,CAAC;IAClC;EACJ,CAAC;EAED,oBACIpB,IAAA,CAACF,iCAAiC;IAC9BuB,GAAG,EAAEf,OAAQ;IACbD,KAAK,EAAEA,KAAM;IACbF,WAAW,EAAEA,WAAY;IACzBC,WAAW,EAAET,QAAQ,CAACY,EAAE,KAAK,KAAK,GAAGS,eAAe,GAAGM,SAAU;IAAApB,QAAA,EAEhEA;EAAQ,CACsB,CAAC;AAE5C,CAAC","ignoreList":[]}

package/lib/module/SelectableTextViewNativeComponent.ts

@@ -0,0 +1,14 @@
+import { codegenNativeComponent, type ViewProps } from 'react-native';
+import type { DirectEventHandler } from 'react-native/Libraries/Types/CodegenTypesNamespace';
+
+export interface SelectionEvent {
+    chosenOption: string;
+    highlightedText: string;
+}
+
+interface NativeProps extends ViewProps {
+    menuOptions: readonly string[];
+    onSelection?: DirectEventHandler<SelectionEvent>;
+}
+
+export default codegenNativeComponent<NativeProps>('SelectableTextView');

package/lib/module/index.js

@@ -0,0 +1,4 @@
+"use strict";
+
+export { SelectableTextView } from "./SelectableTextView.js";
+//# sourceMappingURL=index.js.map

package/lib/module/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["SelectableTextView"],"sourceRoot":"../../src","sources":["index.tsx"],"mappings":";;AAAA,SAASA,kBAAkB,QAAQ,yBAAsB","ignoreList":[]}

package/lib/module/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/lib/typescript/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/lib/typescript/src/SelectableTextView.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+import type { ViewStyle } from 'react-native';
+import { type SelectionEvent } from './SelectableTextViewNativeComponent';
+interface SelectableTextViewProps {
+    children: React.ReactNode;
+    menuOptions: string[];
+    onSelection?: (event: SelectionEvent) => void;
+    style?: ViewStyle;
+}
+export declare const SelectableTextView: React.FC<SelectableTextViewProps>;
+export {};
+//# sourceMappingURL=SelectableTextView.d.ts.map

package/lib/typescript/src/SelectableTextView.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SelectableTextView.d.ts","sourceRoot":"","sources":["../../../src/SelectableTextView.tsx"],"names":[],"mappings":"AAAA,OAAO,KAA4B,MAAM,OAAO,CAAC;AACjD,OAAO,KAAK,EAAE,SAAS,EAAwB,MAAM,cAAc,CAAC;AAEpE,OAA0C,EACtC,KAAK,cAAc,EACtB,MAAM,qCAAqC,CAAC;AAE7C,UAAU,uBAAuB;IAC7B,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC;IAC1B,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,WAAW,CAAC,EAAE,CAAC,KAAK,EAAE,cAAc,KAAK,IAAI,CAAC;IAC9C,KAAK,CAAC,EAAE,SAAS,CAAC;CACrB;AAED,eAAO,MAAM,kBAAkB,EAAE,KAAK,CAAC,EAAE,CAAC,uBAAuB,CAoDhE,CAAC"}

package/lib/typescript/src/SelectableTextViewNativeComponent.d.ts

@@ -0,0 +1,13 @@
+import { type ViewProps } from 'react-native';
+import type { DirectEventHandler } from 'react-native/Libraries/Types/CodegenTypesNamespace';
+export interface SelectionEvent {
+    chosenOption: string;
+    highlightedText: string;
+}
+interface NativeProps extends ViewProps {
+    menuOptions: readonly string[];
+    onSelection?: DirectEventHandler<SelectionEvent>;
+}
+declare const _default: import("react-native/types_generated/Libraries/Utilities/codegenNativeComponent").NativeComponentType<NativeProps>;
+export default _default;
+//# sourceMappingURL=SelectableTextViewNativeComponent.d.ts.map

package/lib/typescript/src/SelectableTextViewNativeComponent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SelectableTextViewNativeComponent.d.ts","sourceRoot":"","sources":["../../../src/SelectableTextViewNativeComponent.ts"],"names":[],"mappings":"AAAA,OAAO,EAA0B,KAAK,SAAS,EAAE,MAAM,cAAc,CAAC;AACtE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,oDAAoD,CAAC;AAE7F,MAAM,WAAW,cAAc;IAC3B,YAAY,EAAE,MAAM,CAAC;IACrB,eAAe,EAAE,MAAM,CAAC;CAC3B;AAED,UAAU,WAAY,SAAQ,SAAS;IACnC,WAAW,EAAE,SAAS,MAAM,EAAE,CAAC;IAC/B,WAAW,CAAC,EAAE,kBAAkB,CAAC,cAAc,CAAC,CAAC;CACpD;;AAED,wBAAyE"}

package/lib/typescript/src/index.d.ts

@@ -0,0 +1,2 @@
+export { SelectableTextView } from './SelectableTextView';
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC"}

package/package.json

@@ -0,0 +1,170 @@
+{
+  "name": "@thiagobueno/rn-selectable-text",
+  "version": "1.0.0",
+  "type": "module",
+  "description": "A library for custom text selection menus",
+  "main": "./lib/module/index.js",
+  "types": "./lib/typescript/src/index.d.ts",
+  "exports": {
+    ".": {
+      "source": "./src/index.tsx",
+      "types": "./lib/typescript/src/index.d.ts",
+      "default": "./lib/module/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "src",
+    "lib",
+    "android",
+    "ios",
+    "cpp",
+    "*.podspec",
+    "react-native.config.js",
+    "!ios/build",
+    "!android/build",
+    "!android/gradle",
+    "!android/gradlew",
+    "!android/gradlew.bat",
+    "!android/local.properties",
+    "!**/__tests__",
+    "!**/__fixtures__",
+    "!**/__mocks__",
+    "!**/.*"
+  ],
+  "scripts": {
+    "example": "yarn workspace rn-selectable-text-example",
+    "test": "jest",
+    "typecheck": "tsc",
+    "lint": "eslint \"**/*.{js,ts,tsx}\"",
+    "clean": "del-cli android/build example/android/build example/android/app/build example/ios/build lib",
+    "prepare": "bob build",
+    "release": "release-it --only-version"
+  },
+  "keywords": [
+    "react-native",
+    "ios",
+    "android"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/thiagobueno/rn-selectable-text.git"
+  },
+  "author": "Thiago Bueno (https://github.com/thiagobueno)",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/thiagobueno/rn-selectable-text/issues"
+  },
+  "homepage": "https://github.com/thiagobueno/rn-selectable-text#readme",
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/"
+  },
+  "devDependencies": {
+    "@commitlint/config-conventional": "^19.8.1",
+    "@eslint/compat": "^1.3.2",
+    "@eslint/eslintrc": "^3.3.1",
+    "@eslint/js": "^9.35.0",
+    "@evilmartians/lefthook": "^1.12.3",
+    "@react-native-community/cli": "20.0.1",
+    "@react-native/babel-preset": "0.81.1",
+    "@react-native/eslint-config": "^0.81.1",
+    "@release-it/conventional-changelog": "^10.0.1",
+    "@types/jest": "^29.5.14",
+    "@types/react": "^19.1.0",
+    "commitlint": "^19.8.1",
+    "del-cli": "^6.0.0",
+    "eslint": "^9.35.0",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-prettier": "^5.5.4",
+    "jest": "^29.7.0",
+    "prettier": "^3.6.2",
+    "react": "19.1.0",
+    "react-native": "0.81.1",
+    "react-native-builder-bob": "^0.40.13",
+    "release-it": "^19.0.4",
+    "turbo": "^2.5.6",
+    "typescript": "^5.9.2"
+  },
+  "peerDependencies": {
+    "react": "*",
+    "react-native": "*"
+  },
+  "workspaces": [
+    "example"
+  ],
+  "packageManager": "yarn@3.6.1",
+  "jest": {
+    "preset": "react-native",
+    "modulePathIgnorePatterns": [
+      "<rootDir>/example/node_modules",
+      "<rootDir>/lib/"
+    ]
+  },
+  "commitlint": {
+    "extends": [
+      "@commitlint/config-conventional"
+    ]
+  },
+  "release-it": {
+    "git": {
+      "commitMessage": "chore: release ${version}",
+      "tagName": "v${version}"
+    },
+    "npm": {
+      "publish": true
+    },
+    "github": {
+      "release": true
+    },
+    "plugins": {
+      "@release-it/conventional-changelog": {
+        "preset": {
+          "name": "angular"
+        }
+      }
+    }
+  },
+  "prettier": {
+    "quoteProps": "consistent",
+    "singleQuote": true,
+    "tabWidth": 2,
+    "trailingComma": "es5",
+    "useTabs": false
+  },
+  "react-native-builder-bob": {
+    "source": "src",
+    "output": "lib",
+    "targets": [
+      [
+        "module",
+        {
+          "esm": true
+        }
+      ],
+      [
+        "typescript",
+        {
+          "project": "tsconfig.build.json"
+        }
+      ]
+    ]
+  },
+  "codegenConfig": {
+    "name": "SelectableTextViewSpec",
+    "type": "all",
+    "jsSrcsDir": "src",
+    "android": {
+      "javaPackageName": "com.selectabletext"
+    },
+    "ios": {
+      "componentProvider": {
+        "SelectableTextView": "SelectableTextView"
+      }
+    }
+  },
+  "create-react-native-library": {
+    "languages": "kotlin-objc",
+    "type": "fabric-view",
+    "version": "0.54.2"
+  }
+}

package/rn-selectable-text.podspec

@@ -0,0 +1,21 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::Spec.new do |s|
+  s.name         = "rn-selectable-text"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.homepage     = package["homepage"]
+  s.license      = package["license"]
+  s.authors      = package["author"]
+
+  s.platforms    = { :ios => min_ios_version_supported }
+  s.source       = { :git => "https://github.com/thiagobueno/rn-selectable-text.git", :tag => "#{s.version}" }
+
+  s.source_files = "ios/**/*.{h,m,mm,cpp}"
+  s.private_header_files = "ios/**/*.h"
+
+
+  install_modules_dependencies(s)
+end

package/src/SelectableTextView.tsx

@@ -0,0 +1,67 @@
+import React, { useRef, useEffect } from 'react';
+import type { ViewStyle, NativeSyntheticEvent } from 'react-native';
+import { Platform, findNodeHandle, DeviceEventEmitter } from 'react-native';
+import SelectableTextViewNativeComponent, {
+    type SelectionEvent,
+} from './SelectableTextViewNativeComponent';
+
+interface SelectableTextViewProps {
+    children: React.ReactNode;
+    menuOptions: string[];
+    onSelection?: (event: SelectionEvent) => void;
+    style?: ViewStyle;
+}
+
+export const SelectableTextView: React.FC<SelectableTextViewProps> = ({
+    children,
+    menuOptions,
+    onSelection,
+    style,
+}) => {
+    const viewRef = useRef<any>(null);
+
+    useEffect(() => {
+        if (Platform.OS === 'android' && onSelection) {
+            const subscription = DeviceEventEmitter.addListener(
+                'SelectableTextSelection',
+                (eventData: {
+                    viewTag: number;
+                    chosenOption: string;
+                    highlightedText: string;
+                }) => {
+                    const viewTag = findNodeHandle(viewRef.current);
+                    if (viewTag === eventData.viewTag) {
+                        onSelection({
+                            chosenOption: eventData.chosenOption,
+                            highlightedText: eventData.highlightedText,
+                        });
+                    }
+                }
+            );
+
+            return () => subscription.remove();
+        }
+        return () => { };
+    }, [onSelection]);
+
+    const handleSelection = (event: NativeSyntheticEvent<SelectionEvent>) => {
+        if (Platform.OS === 'ios' && onSelection) {
+            console.log(
+                'SelectableTextView - Direct event received:',
+                event.nativeEvent
+            );
+            onSelection(event.nativeEvent);
+        }
+    };
+
+    return (
+        <SelectableTextViewNativeComponent
+            ref={viewRef}
+            style={style}
+            menuOptions={menuOptions}
+            onSelection={Platform.OS === 'ios' ? handleSelection : undefined}
+        >
+            {children}
+        </SelectableTextViewNativeComponent>
+    );
+};

package/src/SelectableTextViewNativeComponent.ts

@@ -0,0 +1,14 @@
+import { codegenNativeComponent, type ViewProps } from 'react-native';
+import type { DirectEventHandler } from 'react-native/Libraries/Types/CodegenTypesNamespace';
+
+export interface SelectionEvent {
+    chosenOption: string;
+    highlightedText: string;
+}
+
+interface NativeProps extends ViewProps {
+    menuOptions: readonly string[];
+    onSelection?: DirectEventHandler<SelectionEvent>;
+}
+
+export default codegenNativeComponent<NativeProps>('SelectableTextView');

package/src/index.tsx

@@ -0,0 +1 @@
+export { SelectableTextView } from './SelectableTextView';