react-native-advanced-text 0.1.25 → 0.1.27

package/android/src/main/java/com/advancedtext/AdvancedTextView.kt

@@ -1,316 +1,637 @@
-package com.advancedtext
-
-import android.content.Context
-import android.graphics.Color
-import android.text.SpannableString
-import android.text.Spanned
-import android.text.TextPaint
-import android.text.method.LinkMovementMethod
-import android.text.style.ClickableSpan
-import android.text.style.BackgroundColorSpan
-import android.text.style.ForegroundColorSpan
-import android.util.AttributeSet
-import android.util.Log
-import android.view.ActionMode
-import android.view.Menu
-import android.view.MenuItem
-import android.view.View
-import android.widget.TextView
-import com.facebook.react.bridge.Arguments
-import com.facebook.react.bridge.ReactContext
-import com.facebook.react.uimanager.events.RCTEventEmitter
-import android.text.Selection
-
-class AdvancedTextView : TextView {
-
-    private val TAG = "AdvancedTextView"
-
-    private var highlightedWords: List<HighlightedWord> = emptyList()
-    private var menuOptions: List<String> = emptyList()
-    private var indicatorWordIndex: Int = -1
-    private var lastSelectedText: String = ""
-    private var customActionMode: ActionMode? = null
-    private var currentText: String = ""
-    private var textColor: String = "#000000"
-    private var fontSize: Float = 16f
-    private var fontWeight: String = "normal"
-    private var textAlign: String = "left"
-    private var fontFamily: String = "sans-serif"
-
-    private var wordPositions: List<WordPosition> = emptyList()
-
-    constructor(context: Context?) : super(context) { init() }
-    constructor(context: Context?, attrs: AttributeSet?) : super(context, attrs) { init() }
-    constructor(context: Context?, attrs: AttributeSet?, defStyleAttr: Int) : super(context, attrs, defStyleAttr) { init() }
-
-    private fun init() {
-        Log.d(TAG, "AdvancedTextView initialized")
-
-        textSize = 16f
-        setPadding(16, 16, 16, 16)
-        movementMethod = LinkMovementMethod.getInstance()
-        setTextIsSelectable(true)
-
-
-        customSelectionActionModeCallback = object : ActionMode.Callback {
-            override fun onCreateActionMode(mode: ActionMode?, menu: Menu?): Boolean {
-                customActionMode = mode
-                return true
-            }
+#import "AdvancedTextView.h"
+
+#import <react/renderer/components/AdvancedTextViewSpec/ComponentDescriptors.h>
+#import <react/renderer/components/AdvancedTextViewSpec/EventEmitters.h>
+#import <react/renderer/components/AdvancedTextViewSpec/Props.h>
+#import <react/renderer/components/AdvancedTextViewSpec/RCTComponentViewHelpers.h>
+
+#import "RCTFabricComponentsPlugins.h"
+
+using namespace facebook::react;
+
+
+@class AdvancedTextView;
+
+@interface AdvancedTextView () <RCTAdvancedTextViewViewProtocol, UIGestureRecognizerDelegate, UITextViewDelegate>
+
+@property (nonatomic, strong) NSMutableArray<NSDictionary *> *wordRanges;
+@property (nonatomic, strong) NSMutableDictionary<NSNumber *, UIColor *> *highlightColors;
+@property (nonatomic, strong) NSArray<NSString *> *menuOptions;
+@property (nonatomic, assign) NSInteger indicatorWordIndex;
+@property (nonatomic, assign) CGFloat fontSize;
+@property (nonatomic, strong) NSString *fontWeight;
+@property (nonatomic, strong) UIColor *textColor;
+@property (nonatomic, strong) NSString *textAlign;
+@property (nonatomic, strong) NSString *fontFamily;
+
+- (void)handleCustomMenuAction:(UIMenuItem *)sender;
+
+@end
+
+
+@interface CustomTextView : UITextView
+@property (nonatomic, weak) AdvancedTextView *parentView;
+@end
+
+@implementation CustomTextView
+
+- (BOOL)canPerformAction:(SEL)action withSender:(id)sender
+{
+    NSLog(@"[CustomTextView] canPerformAction: %@", NSStringFromSelector(action));
+
+    if (action == @selector(handleCustomMenuAction:)) {
+        NSLog(@"[CustomTextView] ✅ Allowing custom action");
+        return YES;
+    }
+
+    NSLog(@"[CustomTextView] ❌ Blocking system action: %@", NSStringFromSelector(action));
+    return NO;
+}
+
+- (void)handleCustomMenuAction:(UIMenuItem *)sender
+{
+    if (self.parentView) {
+        [self.parentView handleCustomMenuAction:sender];
+    }
+}
+
+@end
+
+
 
-            override fun onPrepareActionMode(mode: ActionMode?, menu: Menu?): Boolean {
-                menu?.clear()
+@interface AdvancedTextView () <RCTAdvancedTextViewViewProtocol, UIGestureRecognizerDelegate, UITextViewDelegate>
 
-                val selectionStart = selectionStart
-                val selectionEnd = selectionEnd
+@property (nonatomic, strong) CustomTextView *textView;
 
-                if (selectionStart >= 0 && selectionEnd >= 0 && selectionStart != selectionEnd) {
-                    lastSelectedText = text.subSequence(selectionStart, selectionEnd).toString()
+@end
 
-                    menuOptions.forEachIndexed { index, option ->
-                        menu?.add(0, index, index, option)
-                    }
+@implementation AdvancedTextView
+
++ (ComponentDescriptorProvider)componentDescriptorProvider
+{
+    NSLog(@"[AdvancedTextView] componentDescriptorProvider called");
+    return concreteComponentDescriptorProvider<AdvancedTextViewComponentDescriptor>();
+}
+
+- (instancetype)initWithFrame:(CGRect)frame
+{
+    NSLog(@"[AdvancedTextView] initWithFrame called");
+    if (self = [super initWithFrame:frame]) {
+        @try {
+            static const auto defaultProps = std::make_shared<const AdvancedTextViewProps>();
+            _props = defaultProps;
+
+            _wordRanges = [NSMutableArray array];
+            _highlightColors = [NSMutableDictionary dictionary];
+            _indicatorWordIndex = -1;
+            _fontSize = 16.0;
+            _fontWeight = @"normal";
+            _textColor = [UIColor labelColor];
+            _textAlign = @"left";
+            _fontFamily = @"System";
+
+            [self setupTextView];
+            [self setupGestureRecognizers];
+
+            NSLog(@"[AdvancedTextView] Initialization successful");
+        } @catch (NSException *exception) {
+            NSLog(@"[AdvancedTextView] Exception in init: %@", exception);
+            @throw;
+        }
+    }
 
-                    sendSelectionEvent(lastSelectedText, "selection")
-                    return true
+    return self;
+}
+
+- (void)setupTextView
+{
+    NSLog(@"[AdvancedTextView] setupTextView called");
+    @try {
+        _textView = [[CustomTextView alloc] initWithFrame:self.bounds];
+        _textView.parentView = self;
+        _textView.editable = NO;
+        _textView.selectable = YES;
+        _textView.scrollEnabled = YES;
+        _textView.backgroundColor = [UIColor clearColor];
+        _textView.textContainerInset = UIEdgeInsetsMake(8, 8, 8, 8);
+        _textView.font = [UIFont systemFontOfSize:16];
+        _textView.textColor = [UIColor labelColor];
+        _textView.delegate = self;
+
+        self.contentView = _textView;
+        NSLog(@"[AdvancedTextView] TextView setup successful");
+    } @catch (NSException *exception) {
+        NSLog(@"[AdvancedTextView] Exception in setupTextView: %@", exception);
+        @throw;
+    }
+}
+
+- (void)setupGestureRecognizers
+{
+    NSLog(@"[AdvancedTextView] setupGestureRecognizers called");
+    @try {
+        UITapGestureRecognizer *tapGesture = [[UITapGestureRecognizer alloc]
+                                              initWithTarget:self
+                                              action:@selector(handleTap:)];
+        tapGesture.delegate = self;
+        [_textView addGestureRecognizer:tapGesture];
+
+        NSLog(@"[AdvancedTextView] Gesture recognizers setup successful");
+    } @catch (NSException *exception) {
+        NSLog(@"[AdvancedTextView] Exception in setupGestureRecognizers: %@", exception);
+        @throw;
+    }
+}
+
+- (void)updateProps:(Props::Shared const &)props oldProps:(Props::Shared const &)oldProps
+{
+    NSLog(@"[AdvancedTextView] updateProps called");
+    @try {
+        const auto &oldViewProps = *std::static_pointer_cast<AdvancedTextViewProps const>(_props);
+        const auto &newViewProps = *std::static_pointer_cast<AdvancedTextViewProps const>(props);
+
+        BOOL textChanged = NO;
+        BOOL highlightsChanged = NO;
+        BOOL menuChanged = NO;
+        BOOL indicatorChanged = NO;
+        BOOL styleChanged = NO;
+
+        if (oldViewProps.fontSize != newViewProps.fontSize && newViewProps.fontSize) {
+            NSLog(@"[AdvancedTextView] Updating fontSize to: %f", newViewProps.fontSize);
+            _fontSize = static_cast<CGFloat>(newViewProps.fontSize);
+            styleChanged = YES;
+        }
+
+        if (oldViewProps.textAlign != newViewProps.textAlign && !newViewProps.textAlign.empty()) {
+            NSLog(@"[AdvancedTextView] Updating textAlign to: %s", newViewProps.textAlign.c_str());
+            _textAlign = [NSString stringWithUTF8String:newViewProps.textAlign.c_str()];
+            styleChanged = YES;
+        }
+
+        if (oldViewProps.fontWeight != newViewProps.fontWeight && !newViewProps.fontWeight.empty()) {
+            NSLog(@"[AdvancedTextView] Updating fontWeight to: %s", newViewProps.fontWeight.c_str());
+            _fontWeight = [NSString stringWithUTF8String:newViewProps.fontWeight.c_str()];
+            styleChanged = YES;
+        }
+
+        if (oldViewProps.fontFamily != newViewProps.fontFamily && !newViewProps.fontFamily.empty()) {
+            NSLog(@"[AdvancedTextView] Updating fontFamily to: %s", newViewProps.fontFamily.c_str());
+            _fontFamily = [NSString stringWithUTF8String:newViewProps.fontFamily.c_str()];
+            styleChanged = YES;
+        }
+
+        if (oldViewProps.color != newViewProps.color && !newViewProps.color.empty()) {
+            NSLog(@"[AdvancedTextView] Updating color to: %s", newViewProps.color.c_str());
+            NSString *colorStr = [NSString stringWithUTF8String:newViewProps.color.c_str()];
+            _textColor = [self hexStringToColor:colorStr];
+            styleChanged = YES;
+        }
+
+        if (oldViewProps.text != newViewProps.text) {
+            textChanged = YES;
+            NSLog(@"[AdvancedTextView] Text changed");
+        }
+
+        if (oldViewProps.highlightedWords.size() != newViewProps.highlightedWords.size()) {
+            highlightsChanged = YES;
+        } else {
+            for (size_t i = 0; i < oldViewProps.highlightedWords.size(); i++) {
+                const auto &oldHW = oldViewProps.highlightedWords[i];
+                const auto &newHW = newViewProps.highlightedWords[i];
+                if (oldHW.index != newHW.index || oldHW.highlightColor != newHW.highlightColor) {
+                    highlightsChanged = YES;
+                    break;
                 }
-                return false
             }
+        }
 
-            override fun onActionItemClicked(mode: ActionMode?, item: MenuItem?): Boolean {
-                item?.let {
-                    val menuItemText = it.title.toString()
-                    sendSelectionEvent(lastSelectedText, menuItemText)
-                    mode?.finish()
-                    return true
+        if (oldViewProps.menuOptions.size() != newViewProps.menuOptions.size()) {
+            menuChanged = YES;
+        } else {
+            for (size_t i = 0; i < oldViewProps.menuOptions.size(); i++) {
+                if (oldViewProps.menuOptions[i] != newViewProps.menuOptions[i]) {
+                    menuChanged = YES;
+                    break;
                 }
-                return false
             }
+        }
 
-            override fun onDestroyActionMode(mode: ActionMode?) {
-                customActionMode = null
-            }
+        if (oldViewProps.indicatorWordIndex != newViewProps.indicatorWordIndex) {
+            indicatorChanged = YES;
         }
-    }
 
+        if (textChanged) {
+            NSString *text = [NSString stringWithUTF8String:newViewProps.text.c_str()];
+            [self updateTextContent:text];
+        }
 
+        if (highlightsChanged) {
+            [self updateHighlightedWords:newViewProps.highlightedWords];
+        }
 
-    fun setAdvancedText(text: String) {
-        if (currentText == text) {
-            Log.d(TAG, "Text unchanged, skipping update")
-            return
+        if (menuChanged) {
+            [self updateMenuOptions:newViewProps.menuOptions];
         }
 
-        Log.d(TAG, "setAdvancedText: length=${text.length}")
-        currentText = text
-        calculateWordPositions(text)
-        updateTextWithHighlights()
-    }
+        if (indicatorChanged) {
+            _indicatorWordIndex = newViewProps.indicatorWordIndex;
+            [self updateTextAppearance];
+        }
 
-    fun setAdvancedTextColor(colorInt: Int) {
-          textColor = String.format("#%06X", 0xFFFFFF and colorInt)
-          updateTextWithHighlights()
+        if (styleChanged) {
+            NSLog(@"[AdvancedTextView] Style properties changed, updating appearance");
+            [self updateTextAppearance];
+        }
+
+        [super updateProps:props oldProps:oldProps];
+        NSLog(@"[AdvancedTextView] updateProps completed successfully");
+    } @catch (NSException *exception) {
+        NSLog(@"[AdvancedTextView] Exception in updateProps: %@", exception.reason);
+        @throw;
     }
+}
 
+- (void)updateTextContent:(NSString *)text
+{
+    NSLog(@"[AdvancedTextView] updateTextContent called with text length: %lu",
+          (unsigned long)text.length);
+    @try {
+        if (!text) {
+            NSLog(@"[AdvancedTextView] Text is nil, skipping update");
+            return;
+        }
 
-    fun setAdvancedTextSize(size: Float) {
-        if (fontSize == size) return
-        fontSize = size
-        updateTextWithHighlights() // ensures size change is applied with highlights
-    }
+        _textView.text = text;
 
-    fun setAdvancedFontWeight(weight: String) {
-        if (fontWeight == weight) return
-        fontWeight = weight
-    }
+        [_wordRanges removeAllObjects];
+
+        NSRange searchRange = NSMakeRange(0, text.length);
+        NSCharacterSet *whitespaceSet = [NSCharacterSet whitespaceAndNewlineCharacterSet];
+
+        NSInteger wordIndex = 0;
+        while (searchRange.location < text.length) {
+            while (searchRange.location < text.length &&
+                   [whitespaceSet characterIsMember:[text characterAtIndex:searchRange.location]]) {
+                searchRange.location++;
+                searchRange.length = text.length - searchRange.location;
+            }
 
-    fun setAdvancedTextAlign(align: String) {
-        if (textAlign == align) return
-        textAlign = align
-        when (align) {
-            "left" -> textAlignment = View.TEXT_ALIGNMENT_TEXT_START
-            "center" -> textAlignment = View.TEXT_ALIGNMENT_CENTER
-            "right" -> textAlignment = View.TEXT_ALIGNMENT_TEXT_END
-            else -> textAlignment = View.TEXT_ALIGNMENT_TEXT_START
+            if (searchRange.location >= text.length) break;
+
+            NSUInteger wordStart = searchRange.location;
+            while (searchRange.location < text.length &&
+                   ![whitespaceSet characterIsMember:[text characterAtIndex:searchRange.location]]) {
+                searchRange.location++;
+            }
+
+            NSRange wordRange = NSMakeRange(wordStart, searchRange.location - wordStart);
+            NSString *word = [text substringWithRange:wordRange];
+
+            [_wordRanges addObject:@{
+                @"word": word,
+                @"range": [NSValue valueWithRange:wordRange],
+                @"index": @(wordIndex)
+            }];
+
+            wordIndex++;
+            searchRange.length = text.length - searchRange.location;
         }
-    }
 
-    fun setAdvancedFontFamily(family: String) {
-        if (fontFamily == family) return
-        fontFamily = family
-        typeface = Typeface.create(family, Typeface.NORMAL)
+        NSLog(@"[AdvancedTextView] Parsed %ld words", (long)_wordRanges.count);
+        [self updateTextAppearance];
+    } @catch (NSException *exception) {
+        NSLog(@"[AdvancedTextView] Exception in updateTextContent: %@", exception);
+        @throw;
     }
+}
 
-    fun setMenuOptions(menuOptions: List<String>) {
-        if (this.menuOptions == menuOptions) return
-        this.menuOptions = menuOptions
-    }
+- (void)updateHighlightedWords:(const std::vector<AdvancedTextViewHighlightedWordsStruct> &)highlightedWords
+{
+    NSLog(@"[AdvancedTextView] updateHighlightedWords called with %zu highlights",
+          highlightedWords.size());
+    @try {
+        [_highlightColors removeAllObjects];
+
+        for (const auto &hw : highlightedWords) {
+            NSInteger index = hw.index;
+            NSString *colorString = [NSString stringWithUTF8String:hw.highlightColor.c_str()];
+            UIColor *color = [self hexStringToColor:colorString];
 
-    fun setHighlightedWords(highlightedWords: List<HighlightedWord>) {
-        if (this.highlightedWords == highlightedWords) return
-        this.highlightedWords = highlightedWords
-        updateTextWithHighlights()
+            if (color) {
+                _highlightColors[@(index)] = color;
+            }
+        }
+
+        [self updateTextAppearance];
+    } @catch (NSException *exception) {
+        NSLog(@"[AdvancedTextView] Exception in updateHighlightedWords: %@", exception);
+        @throw;
     }
+}
 
-    fun setIndicatorWordIndex(index: Int) {
-        if (this.indicatorWordIndex == index) return
-        this.indicatorWordIndex = index
-        updateTextWithHighlights()
+- (void)updateMenuOptions:(const std::vector<std::string> &)options
+{
+    NSLog(@"[AdvancedTextView] updateMenuOptions called with %zu options", options.size());
+    @try {
+        NSMutableArray *menuArray = [NSMutableArray array];
+        for (const auto &option : options) {
+            NSString *optionStr = [NSString stringWithUTF8String:option.c_str()];
+            [menuArray addObject:optionStr];
+            NSLog(@"[AdvancedTextView] Added menu option: %@", optionStr);
+        }
+        _menuOptions = [menuArray copy];
+    } @catch (NSException *exception) {
+        NSLog(@"[AdvancedTextView] Exception in updateMenuOptions: %@", exception);
+        @throw;
     }
+}
 
-    private fun calculateWordPositions(text: String) {
-        if (text.isEmpty()) {
-            wordPositions = emptyList()
-            return
+- (void)updateTextAppearance
+{
+    @try {
+        if (!_textView.text || _textView.text.length == 0) {
+            return;
         }
 
-        val positions = mutableListOf<WordPosition>()
-        val regex = "\\S+".toRegex()
+        NSMutableAttributedString *attributedString = [[NSMutableAttributedString alloc]
+                                                        initWithString:_textView.text];
 
-        regex.findAll(text).forEachIndexed { index, match ->
-            positions.add(WordPosition(
-                index = index,
-                start = match.range.first,
-                end = match.range.last + 1,
-                word = match.value
-            ))
-        }
 
-        wordPositions = positions
-        Log.d(TAG, "Calculated ${wordPositions.size} word positions")
-    }
+        UIFont *font = nil;
 
-    private fun updateTextWithHighlights() {
-        if (currentText.isEmpty()) {
-            Log.d(TAG, "No text available, skipping")
-            return
+        if (_fontFamily && _fontFamily.length > 0) {
+            font = [UIFont fontWithName:_fontFamily size:_fontSize > 0 ? _fontSize : 16.0];
         }
 
-        val spannableString = SpannableString(currentText)
+        if (!font) {
+            if (_fontWeight && [_fontWeight.lowercaseString isEqualToString:@"bold"]) {
+                font = [UIFont boldSystemFontOfSize:_fontSize > 0 ? _fontSize : 16.0];
+            } else if (_fontWeight && [_fontWeight.lowercaseString isEqualToString:@"italic"]) {
+                font = [UIFont italicSystemFontOfSize:_fontSize > 0 ? _fontSize : 16.0];
+            } else {
+                font = [UIFont systemFontOfSize:_fontSize > 0 ? _fontSize : 16.0];
+            }
+        }
 
-        wordPositions.forEach { wordPos ->
-            highlightedWords.find { it.index == wordPos.index }?.let { highlightedWord ->
-                val color = parseColor(highlightedWord.highlightColor)
-                spannableString.setSpan(
-                    BackgroundColorSpan(color),
-                    wordPos.start,
-                    wordPos.end,
-                    Spanned.SPAN_EXCLUSIVE_EXCLUSIVE
-                )
+        [attributedString addAttribute:NSFontAttributeName
+                                 value:font
+                                 range:NSMakeRange(0, attributedString.length)];
+
+
+        UIColor *color = _textColor ?: [UIColor labelColor];
+        [attributedString addAttribute:NSForegroundColorAttributeName
+                                 value:color
+                                 range:NSMakeRange(0, attributedString.length)];
+
+
+        for (NSDictionary *wordInfo in _wordRanges) {
+            NSNumber *index = wordInfo[@"index"];
+            NSValue *rangeValue = wordInfo[@"range"];
+            NSRange range = [rangeValue rangeValue];
+
+            if (range.location + range.length > attributedString.length) {
+                continue;
             }
 
-            if (wordPos.index == indicatorWordIndex) {
-                spannableString.setSpan(
-                    ForegroundColorSpan(Color.parseColor(textColor)),
-                    wordPos.start,
-                    wordPos.end,
-                    Spanned.SPAN_EXCLUSIVE_EXCLUSIVE
-                )
+            UIColor *highlightColor = _highlightColors[index];
+            if (highlightColor) {
+                [attributedString addAttribute:NSBackgroundColorAttributeName
+                                         value:highlightColor
+                                         range:range];
             }
 
-            spannableString.setSpan(
-                WordClickableSpan(wordPos.index, wordPos.word),
-                wordPos.start,
-                wordPos.end,
-                Spanned.SPAN_EXCLUSIVE_EXCLUSIVE
-            )
+            if (_indicatorWordIndex >= 0 && [index integerValue] == _indicatorWordIndex) {
+                UIColor *indicatorColor = [[UIColor systemBlueColor] colorWithAlphaComponent:0.3];
+                [attributedString addAttribute:NSBackgroundColorAttributeName
+                                         value:indicatorColor
+                                         range:range];
+            }
         }
 
-         textAlignment = when (textAlign) {
-            "left" -> View.TEXT_ALIGNMENT_TEXT_START
-            "center" -> View.TEXT_ALIGNMENT_CENTER
-            "right" -> View.TEXT_ALIGNMENT_TEXT_END
-            else -> View.TEXT_ALIGNMENT_TEXT_START
+        _textView.attributedText = attributedString;
+
+        if (_textAlign) {
+            if ([_textAlign.lowercaseString isEqualToString:@"center"]) {
+                _textView.textAlignment = NSTextAlignmentCenter;
+            } else if ([_textAlign.lowercaseString isEqualToString:@"right"]) {
+                _textView.textAlignment = NSTextAlignmentRight;
+            } else {
+                _textView.textAlignment = NSTextAlignmentLeft;
+            }
+        } else {
+            _textView.textAlignment = NSTextAlignmentLeft;
         }
 
-        setTextSize(fontSize)
+    } @catch (NSException *exception) {
+        NSLog(@"[AdvancedTextView] Exception in updateTextAppearance: %@", exception.reason);
+    }
+}
+
 
-        typeface = when (fontWeight) {
-            "bold" -> Typeface.create(fontFamily, Typeface.BOLD)
-            "italic" -> Typeface.create(fontFamily, Typeface.ITALIC)
-            else -> Typeface.create(fontFamily, Typeface.NORMAL)
-        }
+- (void)handleTap:(UITapGestureRecognizer *)gesture
+{
+    @try {
+        if (gesture.state != UIGestureRecognizerStateEnded) return;
+
+        CGPoint location = [gesture locationInView:_textView];
+        NSInteger wordIndex = [self wordIndexAtPoint:location];
+
+        _textView.selectedTextRange = nil;
 
-        post {
-            setText(spannableString, BufferType.SPANNABLE)
-            Log.d(TAG, "Text updated with ${wordPositions.size} spans")
+        if (wordIndex >= 0 && wordIndex < _wordRanges.count) {
+            NSDictionary *wordInfo = _wordRanges[wordIndex];
+            NSString *word = wordInfo[@"word"];
+
+            [self emitWordPressEvent:word index:wordIndex];
         }
+    } @catch (NSException *exception) {
+        NSLog(@"[AdvancedTextView] Exception in handleTap: %@", exception);
     }
+}
+
+#pragma mark - UITextViewDelegate
+
+- (void)textViewDidChangeSelection:(UITextView *)textView
+{
+    NSString *selectedText = [textView.text substringWithRange:textView.selectedRange];
+
+    if (selectedText.length > 0) {
+        NSLog(@"[AdvancedTextView] Selected text: %@", selectedText);
 
-    private fun parseColor(colorString: String): Int {
-        return try {
-            Color.parseColor(colorString)
-        } catch (e: IllegalArgumentException) {
-            Log.e(TAG, "Invalid color: $colorString, using yellow")
-            Color.YELLOW
+        if (_menuOptions && _menuOptions.count > 0) {
+            [self setupCustomMenuItems];
         }
     }
+}
 
-    private fun sendSelectionEvent(selectedText: String, eventType: String) {
-        try {
-            val reactContext = context as? ReactContext ?: return
-            val event = Arguments.createMap().apply {
-                putString("selectedText", selectedText)
-                putString("event", eventType)
-            }
+- (void)setupCustomMenuItems
+{
+    NSLog(@"[AdvancedTextView] Setting up %lu custom menu items", (unsigned long)_menuOptions.count);
 
-            reactContext.getJSModule(RCTEventEmitter::class.java)
-                .receiveEvent(id, "onSelection", event)
-        } catch (e: Exception) {
-            Log.e(TAG, "Error sending selection event", e)
-        }
+    UIMenuController *menuController = [UIMenuController sharedMenuController];
+    NSMutableArray *customItems = [NSMutableArray array];
+
+    for (NSString *option in _menuOptions) {
+        UIMenuItem *item = [[UIMenuItem alloc] initWithTitle:option
+                                                      action:@selector(handleCustomMenuAction:)];
+        [customItems addObject:item];
+        NSLog(@"[AdvancedTextView] Created menu item: %@", option);
     }
 
-    private inner class WordClickableSpan(
-    private val wordIndex: Int,
-    private val word: String
-    ) : ClickableSpan() {
+    menuController.menuItems = customItems;
+}
 
-        override fun onClick(widget: View) {
-            Log.d(TAG, "WordClickableSpan onClick triggered: '$word' (index=$wordIndex)")
 
-            widget.post {
-                sendWordPressEvent(word, wordIndex)
+- (void)handleCustomMenuAction:(UIMenuItem *)sender
+{
+    NSLog(@"[AdvancedTextView] Custom menu action: %@", sender.title);
+
+    NSString *selectedText = [_textView.text substringWithRange:_textView.selectedRange];
+
+    [self emitSelectionEvent:selectedText menuOption:sender.title];
+
+    dispatch_async(dispatch_get_main_queue(), ^{
+        self->_textView.selectedTextRange = nil;
+        NSLog(@"[AdvancedTextView] Selection cleared");
+    });
+}
+
+- (NSInteger)wordIndexAtPoint:(CGPoint)point
+{
+    @try {
+        if (!_textView.layoutManager || !_textView.textContainer) {
+            return -1;
+        }
+
+        point.x -= _textView.textContainerInset.left;
+        point.y -= _textView.textContainerInset.top;
+
+        NSLayoutManager *layoutManager = _textView.layoutManager;
+        NSTextContainer *textContainer = _textView.textContainer;
+
+        NSUInteger characterIndex = [layoutManager characterIndexForPoint:point
+                                                           inTextContainer:textContainer
+                                  fractionOfDistanceBetweenInsertionPoints:nil];
+
+        for (NSDictionary *wordInfo in _wordRanges) {
+            NSValue *rangeValue = wordInfo[@"range"];
+            NSRange range = [rangeValue rangeValue];
+
+            if (NSLocationInRange(characterIndex, range)) {
+                return [wordInfo[@"index"] integerValue];
             }
         }
 
-        override fun updateDrawState(ds: TextPaint) {
-            super.updateDrawState(ds)
-            ds.isUnderlineText = false
-            ds.color = Color.parseColor(textColor)
+        return -1;
+    } @catch (NSException *exception) {
+        return -1;
+    }
+}
+
+- (void)setFontSize:(CGFloat)fontSize {
+    _fontSize = fontSize;
+    [self updateTextAppearance];
+}
+
+- (void)setFontWeight:(NSString *)fontWeight {
+    _fontWeight = fontWeight;
+    [self updateTextAppearance];
+}
+
+- (void)setTextColor:(UIColor *)textColor {
+    _textColor = textColor;
+    [self updateTextAppearance];
+}
+
+- (void)setTextAlign:(NSString *)textAlign {
+    _textAlign = textAlign;
+    [self updateTextAppearance];
+}
+
+- (void)setFontFamily:(NSString *)fontFamily {
+    _fontFamily = fontFamily;
+    [self updateTextAppearance];
+}
+
+- (void)emitWordPressEvent:(NSString *)word index:(NSInteger)index
+{
+    NSLog(@"[AdvancedTextView] emitWordPressEvent: %@ at index: %ld", word, (long)index);
+    @try {
+        if (_eventEmitter) {
+            auto emitter = std::static_pointer_cast<const AdvancedTextViewEventEmitter>(_eventEmitter);
+
+            AdvancedTextViewEventEmitter::OnWordPress event;
+            event.word = [word UTF8String];
+            event.index = static_cast<int>(index);
+
+            emitter->onWordPress(event);
         }
+    } @catch (NSException *exception) {
+        NSLog(@"[AdvancedTextView] Exception in emitWordPressEvent: %@", exception);
     }
+}
 
-    private fun sendWordPressEvent(word: String, index: Int) {
-        try {
-            val reactContext = context as? ReactContext ?: return
-            val event = Arguments.createMap().apply {
-                putString("word", word)
-                putInt("index", index)
-            }
+- (void)emitSelectionEvent:(NSString *)selectedText menuOption:(NSString *)option
+{
+    NSLog(@"[AdvancedTextView] emitSelectionEvent: %@ with option: %@", selectedText, option);
+    @try {
+        if (_eventEmitter) {
+            auto emitter = std::static_pointer_cast<const AdvancedTextViewEventEmitter>(_eventEmitter);
 
-            reactContext.getJSModule(RCTEventEmitter::class.java)
-                .receiveEvent(id, "onWordPress", event)
-        } catch (e: Exception) {
-            Log.e(TAG, "Error sending word press event", e)
+            AdvancedTextViewEventEmitter::OnSelection event;
+            event.selectedText = [selectedText UTF8String];
+            event.event = [option UTF8String];
+
+            emitter->onSelection(event);
         }
+    } @catch (NSException *exception) {
+        NSLog(@"[AdvancedTextView] Exception in emitSelectionEvent: %@", exception);
+    }
+}
+
+- (void)layoutSubviews
+{
+    @try {
+        [super layoutSubviews];
+        _textView.frame = self.bounds;
+    } @catch (NSException *exception) {
+        NSLog(@"[AdvancedTextView] Exception in layoutSubviews: %@", exception);
     }
+}
 
-    fun clearSelection() {
-        (text as? android.text.Spannable)?.let {
-            Selection.removeSelection(it)
+- (UIColor *)hexStringToColor:(NSString *)stringToConvert
+{
+    @try {
+        if (!stringToConvert || [stringToConvert length] == 0) {
+            return nil;
         }
+
+        NSString *noHashString = [stringToConvert stringByReplacingOccurrencesOfString:@"#" withString:@""];
+        NSScanner *stringScanner = [NSScanner scannerWithString:noHashString];
+
+        unsigned hex;
+        if (![stringScanner scanHexInt:&hex]) {
+            return nil;
+        }
+
+        int r = (hex >> 16) & 0xFF;
+        int g = (hex >> 8) & 0xFF;
+        int b = (hex) & 0xFF;
+
+        return [UIColor colorWithRed:r / 255.0f green:g / 255.0f blue:b / 255.0f alpha:1.0f];
+    } @catch (NSException *exception) {
+        return nil;
     }
+}
+
+Class<RCTComponentViewProtocol> AdvancedTextViewCls(void)
+{
+    return AdvancedTextView.class;
+}
 
-    data class WordPosition(
-        val index: Int,
-        val start: Int,
-        val end: Int,
-        val word: String
-    )
+- (void)dealloc
+{
+    NSLog(@"[AdvancedTextView] dealloc called");
 }
 
-data class HighlightedWord(
-    val index: Int,
-    val highlightColor: String
-)
+@end

package/android/src/main/java/com/advancedtext/AdvancedTextViewManager.kt

@@ -83,11 +83,11 @@ class AdvancedTextViewManager : SimpleViewManager<AdvancedTextView>() {
         view?.setIndicatorWordIndex(if (index >= 0) index else -1)
     }
 
-    @ReactProp(name = "color", customType = "Color")
-    fun setColor(view: AdvancedTextView?, color: Int?) {
+    @ReactProp(name = "color")
+    fun setColor(view: AdvancedTextView?, color: String?) {
         android.util.Log.d(NAME, "setColor called with: $color")
         if (color != null) {
-            view?.setAdvancedTextColor(color)
+            view?.setAdvancedTextColor(Color.parseColor(color))
         }
     }
 

package/lib/module/AdvancedTextViewNativeComponent.ts

@@ -1,26 +1,26 @@
-/* eslint-disable prettier/prettier */
-import type { ViewProps } from 'react-native';
-import { codegenNativeComponent } from 'react-native';
-// @ts-ignore
-import type { DirectEventHandler, Int32 } from 'react-native/Libraries/Types/CodegenTypes';
-
-interface HighlightedWord {
-  index: Int32;
-  highlightColor: string;
-}
-
-export interface NativeProps extends ViewProps {
-  text: string;
-  highlightedWords?: ReadonlyArray<HighlightedWord>;
-  menuOptions?: ReadonlyArray<string>;
-  onWordPress?: DirectEventHandler<{ word: string; index: Int32 }>;
-  onSelection?: DirectEventHandler<{ selectedText: string; event: string }>;
-  indicatorWordIndex?: Int32;
-  fontSize?: Int32;
-  fontWeight?: string;
-  color?: string;
-  textAlign?: string;
-  fontFamily?: string;
-}
-
-export default codegenNativeComponent<NativeProps>('AdvancedTextView');
+/* eslint-disable prettier/prettier */
+import type { ViewProps } from 'react-native';
+import { codegenNativeComponent } from 'react-native';
+// @ts-ignore
+import type { DirectEventHandler, Int32 } from 'react-native/Libraries/Types/CodegenTypes';
+
+interface HighlightedWord {
+  index: Int32;
+  highlightColor: string;
+}
+
+export interface NativeProps extends ViewProps {
+  text: string;
+  highlightedWords?: ReadonlyArray<HighlightedWord>;
+  menuOptions?: ReadonlyArray<string>;
+  onWordPress?: DirectEventHandler<{ word: string; index: Int32 }>;
+  onSelection?: DirectEventHandler<{ selectedText: string; event: string }>;
+  indicatorWordIndex?: Int32;
+  fontSize?: Int32;
+  fontWeight?: string;
+  color?: string;
+  textAlign?: string;
+  fontFamily?: string;
+}
+
+export default codegenNativeComponent<NativeProps>('AdvancedTextView');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-advanced-text",
-  "version": "0.1.25",
+  "version": "0.1.27",
   "description": " Advanced text component for React Native with custom select options.",
   "main": "./lib/module/index.js",
   "types": "./lib/typescript/src/index.d.ts",

package/src/AdvancedTextViewNativeComponent.ts

@@ -1,26 +1,26 @@
-/* eslint-disable prettier/prettier */
-import type { ViewProps } from 'react-native';
-import { codegenNativeComponent } from 'react-native';
-// @ts-ignore
-import type { DirectEventHandler, Int32 } from 'react-native/Libraries/Types/CodegenTypes';
-
-interface HighlightedWord {
-  index: Int32;
-  highlightColor: string;
-}
-
-export interface NativeProps extends ViewProps {
-  text: string;
-  highlightedWords?: ReadonlyArray<HighlightedWord>;
-  menuOptions?: ReadonlyArray<string>;
-  onWordPress?: DirectEventHandler<{ word: string; index: Int32 }>;
-  onSelection?: DirectEventHandler<{ selectedText: string; event: string }>;
-  indicatorWordIndex?: Int32;
-  fontSize?: Int32;
-  fontWeight?: string;
-  color?: string;
-  textAlign?: string;
-  fontFamily?: string;
-}
-
-export default codegenNativeComponent<NativeProps>('AdvancedTextView');
+/* eslint-disable prettier/prettier */
+import type { ViewProps } from 'react-native';
+import { codegenNativeComponent } from 'react-native';
+// @ts-ignore
+import type { DirectEventHandler, Int32 } from 'react-native/Libraries/Types/CodegenTypes';
+
+interface HighlightedWord {
+  index: Int32;
+  highlightColor: string;
+}
+
+export interface NativeProps extends ViewProps {
+  text: string;
+  highlightedWords?: ReadonlyArray<HighlightedWord>;
+  menuOptions?: ReadonlyArray<string>;
+  onWordPress?: DirectEventHandler<{ word: string; index: Int32 }>;
+  onSelection?: DirectEventHandler<{ selectedText: string; event: string }>;
+  indicatorWordIndex?: Int32;
+  fontSize?: Int32;
+  fontWeight?: string;
+  color?: string;
+  textAlign?: string;
+  fontFamily?: string;
+}
+
+export default codegenNativeComponent<NativeProps>('AdvancedTextView');