react-native-advanced-text 0.1.21 → 0.1.22

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

@@ -1,4 +1,3 @@
-// File: AdvancedTextView.kt
 package com.advancedtext
 
 import android.content.Context
@@ -34,7 +33,6 @@ class AdvancedTextView : TextView {
     private var currentText: String = ""
     private var textColor: String = "#000000"
 
-    // Cache for word positions to avoid recalculating
     private var wordPositions: List<WordPosition> = emptyList()
 
     constructor(context: Context?) : super(context) { init() }
@@ -42,51 +40,52 @@ class AdvancedTextView : TextView {
     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 = ClickableMovementMethod.getInstance()
-    isClickable = false
-    isLongClickable = false
-
-    setTextIsSelectable(true)
-
-    customSelectionActionModeCallback = object : ActionMode.Callback {
-          override fun onCreateActionMode(mode: ActionMode?, menu: Menu?): Boolean {
-              customActionMode = mode
-              return true
-          }
-
-          override fun onPrepareActionMode(mode: ActionMode?, menu: Menu?): Boolean {
-              menu?.clear()
-              val selectionStart = selectionStart
-              val selectionEnd = selectionEnd
-
-              if (selectionStart >= 0 && selectionEnd >= 0 && selectionStart != selectionEnd) {
-                  lastSelectedText = text.subSequence(selectionStart, selectionEnd).toString()
-                  menuOptions.forEachIndexed { index, option ->
-                      menu?.add(0, index, index, option)
-                  }
-                  sendSelectionEvent(lastSelectedText, "selection")
-                  return true
-              }
-              return false
-          }
-
-          override fun onActionItemClicked(mode: ActionMode?, item: MenuItem?): Boolean {
-              item?.let {
-                  sendSelectionEvent(lastSelectedText, it.title.toString())
-                  mode?.finish()
-                  return true
-              }
-              return false
-          }
-
-          override fun onDestroyActionMode(mode: ActionMode?) {
-              customActionMode = null
-          }
+        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
+            }
+
+            override fun onPrepareActionMode(mode: ActionMode?, menu: Menu?): Boolean {
+                menu?.clear()
+
+                val selectionStart = selectionStart
+                val selectionEnd = selectionEnd
+
+                if (selectionStart >= 0 && selectionEnd >= 0 && selectionStart != selectionEnd) {
+                    lastSelectedText = text.subSequence(selectionStart, selectionEnd).toString()
+
+                    menuOptions.forEachIndexed { index, option ->
+                        menu?.add(0, index, index, option)
+                    }
+
+                    sendSelectionEvent(lastSelectedText, "selection")
+                    return true
+                }
+                return false
+            }
+
+            override fun onActionItemClicked(mode: ActionMode?, item: MenuItem?): Boolean {
+                item?.let {
+                    val menuItemText = it.title.toString()
+                    sendSelectionEvent(lastSelectedText, menuItemText)
+                    mode?.finish()
+                    return true
+                }
+                return false
+            }
+
+            override fun onDestroyActionMode(mode: ActionMode?) {
+                customActionMode = null
+            }
         }
     }
 
@@ -155,9 +154,7 @@ class AdvancedTextView : TextView {
 
         val spannableString = SpannableString(currentText)
 
-        // Apply spans efficiently
         wordPositions.forEach { wordPos ->
-            // Apply highlights
             highlightedWords.find { it.index == wordPos.index }?.let { highlightedWord ->
                 val color = parseColor(highlightedWord.highlightColor)
                 spannableString.setSpan(
@@ -168,7 +165,6 @@ class AdvancedTextView : TextView {
                 )
             }
 
-            // Apply indicator color
             if (wordPos.index == indicatorWordIndex) {
                 spannableString.setSpan(
                     ForegroundColorSpan(Color.parseColor(textColor)),
@@ -178,7 +174,6 @@ class AdvancedTextView : TextView {
                 )
             }
 
-            // Make words clickable
             spannableString.setSpan(
                 WordClickableSpan(wordPos.index, wordPos.word),
                 wordPos.start,
@@ -187,7 +182,6 @@ class AdvancedTextView : TextView {
             )
         }
 
-        // Use post to ensure UI thread and avoid layout issues
         post {
             setText(spannableString, BufferType.SPANNABLE)
             Log.d(TAG, "Text updated with ${wordPositions.size} spans")
@@ -224,14 +218,11 @@ class AdvancedTextView : TextView {
     ) : ClickableSpan() {
 
         override fun onClick(widget: View) {
-            Log.d(TAG, "Word clicked: '$word' (index=$wordIndex)")
-            val spannable = widget as? TextView
-            spannable?.text?.let {
-                if (it is android.text.Spannable) {
-                    Selection.removeSelection(it)
-                }
+            Log.d(TAG, "WordClickableSpan onClick triggered: '$word' (index=$wordIndex)")
+
+            widget.post {
+                sendWordPressEvent(word, wordIndex)
             }
-            sendWordPressEvent(word, wordIndex)
         }
 
         override fun updateDrawState(ds: TextPaint) {

package/ios/AdvancedTextView.h

@@ -1,14 +1,15 @@
+#ifndef AdvancedTextView_h
+#define AdvancedTextView_h
+
 #import <React/RCTViewComponentView.h>
 #import <UIKit/UIKit.h>
 
-#ifndef AdvancedTextViewNativeComponent_h
-#define AdvancedTextViewNativeComponent_h
-
 NS_ASSUME_NONNULL_BEGIN
 
 @interface AdvancedTextView : RCTViewComponentView
+
 @end
 
 NS_ASSUME_NONNULL_END
 
-#endif /* AdvancedTextViewNativeComponent_h */
+#endif /* AdvancedTextView_h */

package/ios/AdvancedTextView.mm

@@ -9,13 +9,17 @@
 
 using namespace facebook::react;
 
-@interface AdvancedTextView () <RCTAdvancedTextViewViewProtocol>
+@interface AdvancedTextView () <RCTAdvancedTextViewViewProtocol, UIGestureRecognizerDelegate>
+
+@property (nonatomic, strong) UITextView *textView;
+@property (nonatomic, strong) NSMutableArray<NSDictionary *> *wordRanges;
+@property (nonatomic, strong) NSMutableDictionary<NSNumber *, UIColor *> *highlightColors;
+@property (nonatomic, strong) NSArray<NSString *> *menuOptions;
+@property (nonatomic, assign) NSInteger indicatorWordIndex;
 
 @end
 
-@implementation AdvancedTextView {
-    UIView * _view;
-}
+@implementation AdvancedTextView
 
 + (ComponentDescriptorProvider)componentDescriptorProvider
 {
@@ -24,16 +28,49 @@ using namespace facebook::react;
 
 - (instancetype)initWithFrame:(CGRect)frame
 {
-  if (self = [super initWithFrame:frame]) {
-    static const auto defaultProps = std::make_shared<const AdvancedTextViewProps>();
-    _props = defaultProps;
+    if (self = [super initWithFrame:frame]) {
+        static const auto defaultProps = std::make_shared<const AdvancedTextViewProps>();
+        _props = defaultProps;
+
+        _wordRanges = [NSMutableArray array];
+        _highlightColors = [NSMutableDictionary dictionary];
+        _indicatorWordIndex = -1;
+
+        [self setupTextView];
+        [self setupGestureRecognizers];
+    }
+
+    return self;
+}
+
+- (void)setupTextView
+{
+    _textView = [[UITextView alloc] initWithFrame:self.bounds];
+    _textView.editable = NO;
+    _textView.scrollEnabled = YES;
+    _textView.backgroundColor = [UIColor clearColor];
+    _textView.textContainerInset = UIEdgeInsetsMake(8, 8, 8, 8);
+    _textView.font = [UIFont systemFontOfSize:16];
+    _textView.textColor = [UIColor labelColor];
 
-    _view = [[UIView alloc] init];
+    self.contentView = _textView;
+}
 
-    self.contentView = _view;
-  }
+- (void)setupGestureRecognizers
+{
+    // Single tap for word selection
+    UITapGestureRecognizer *tapGesture = [[UITapGestureRecognizer alloc]
+                                          initWithTarget:self
+                                          action:@selector(handleTap:)];
+    tapGesture.delegate = self;
+    [_textView addGestureRecognizer:tapGesture];
 
-  return self;
+    // Long press for context menu
+    UILongPressGestureRecognizer *longPressGesture = [[UILongPressGestureRecognizer alloc]
+                                                      initWithTarget:self
+                                                      action:@selector(handleLongPress:)];
+    longPressGesture.delegate = self;
+    [_textView addGestureRecognizer:longPressGesture];
 }
 
 - (void)updateProps:(Props::Shared const &)props oldProps:(Props::Shared const &)oldProps
@@ -41,26 +78,287 @@ using namespace facebook::react;
     const auto &oldViewProps = *std::static_pointer_cast<AdvancedTextViewProps const>(_props);
     const auto &newViewProps = *std::static_pointer_cast<AdvancedTextViewProps const>(props);
 
-    if (oldViewProps.color != newViewProps.color) {
-        NSString * colorToConvert = [[NSString alloc] initWithUTF8String: newViewProps.color.c_str()];
-        [_view setBackgroundColor:[self hexStringToColor:colorToConvert]];
+    // Update text
+    if (oldViewProps.text != newViewProps.text) {
+        NSString *text = [NSString stringWithUTF8String:newViewProps.text.c_str()];
+        [self updateTextContent:text];
+    }
+
+    // Update highlighted words
+    if (oldViewProps.highlightedWords != newViewProps.highlightedWords) {
+        [self updateHighlightedWords:newViewProps.highlightedWords];
+    }
+
+    // Update menu options
+    if (oldViewProps.menuOptions != newViewProps.menuOptions) {
+        [self updateMenuOptions:newViewProps.menuOptions];
+    }
+
+    // Update indicator word index
+    if (oldViewProps.indicatorWordIndex != newViewProps.indicatorWordIndex) {
+        _indicatorWordIndex = newViewProps.indicatorWordIndex;
+        [self updateTextAppearance];
     }
 
     [super updateProps:props oldProps:oldProps];
 }
 
-Class<RCTComponentViewProtocol> AdvancedTextViewCls(void)
+- (void)updateTextContent:(NSString *)text
 {
-    return AdvancedTextView.class;
+    // Parse text into words and their ranges
+    [_wordRanges removeAllObjects];
+
+    NSRange searchRange = NSMakeRange(0, text.length);
+    NSCharacterSet *whitespaceSet = [NSCharacterSet whitespaceAndNewlineCharacterSet];
+
+    NSInteger wordIndex = 0;
+    while (searchRange.location < text.length) {
+        // Skip whitespace
+        while (searchRange.location < text.length &&
+               [whitespaceSet characterIsMember:[text characterAtIndex:searchRange.location]]) {
+            searchRange.location++;
+            searchRange.length = text.length - searchRange.location;
+        }
+
+        if (searchRange.location >= text.length) break;
+
+        // Find word end
+        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;
+    }
+
+    [self updateTextAppearance];
 }
 
-- hexStringToColor:(NSString *)stringToConvert
+- (void)updateHighlightedWords:(const std::vector<AdvancedTextViewHighlightedWordsStruct> &)highlightedWords
 {
+    [_highlightColors removeAllObjects];
+
+    for (const auto &hw : highlightedWords) {
+        NSInteger index = hw.index;
+        NSString *colorString = [NSString stringWithUTF8String:hw.highlightColor.c_str()];
+        UIColor *color = [self hexStringToColor:colorString];
+
+        if (color) {
+            _highlightColors[@(index)] = color;
+        }
+    }
+
+    [self updateTextAppearance];
+}
+
+- (void)updateMenuOptions:(const std::vector<std::string> &)options
+{
+    NSMutableArray *menuArray = [NSMutableArray array];
+    for (const auto &option : options) {
+        [menuArray addObject:[NSString stringWithUTF8String:option.c_str()]];
+    }
+    _menuOptions = [menuArray copy];
+}
+
+- (void)updateTextAppearance
+{
+    if (_wordRanges.count == 0) return;
+
+    NSMutableAttributedString *attributedString = [[NSMutableAttributedString alloc]
+                                                    initWithString:_textView.text];
+
+    // Apply default attributes
+    [attributedString addAttribute:NSFontAttributeName
+                             value:[UIFont systemFontOfSize:16]
+                             range:NSMakeRange(0, attributedString.length)];
+
+    [attributedString addAttribute:NSForegroundColorAttributeName
+                             value:[UIColor labelColor]
+                             range:NSMakeRange(0, attributedString.length)];
+
+    // Apply highlights
+    for (NSDictionary *wordInfo in _wordRanges) {
+        NSNumber *index = wordInfo[@"index"];
+        NSValue *rangeValue = wordInfo[@"range"];
+        NSRange range = [rangeValue rangeValue];
+
+        UIColor *highlightColor = _highlightColors[index];
+        if (highlightColor) {
+            [attributedString addAttribute:NSBackgroundColorAttributeName
+                                     value:highlightColor
+                                     range:range];
+        }
+
+        // Add indicator (underline or special formatting) for indicated word
+        if (_indicatorWordIndex >= 0 && [index integerValue] == _indicatorWordIndex) {
+            [attributedString addAttribute:NSUnderlineStyleAttributeName
+                                     value:@(NSUnderlineStyleSingle)
+                                     range:range];
+            [attributedString addAttribute:NSUnderlineColorAttributeName
+                                     value:[UIColor systemBlueColor]
+                                     range:range];
+        }
+    }
+
+    _textView.attributedText = attributedString;
+}
+
+- (void)handleTap:(UITapGestureRecognizer *)gesture
+{
+    if (gesture.state != UIGestureRecognizerStateEnded) return;
+
+    CGPoint location = [gesture locationInView:_textView];
+    NSInteger wordIndex = [self wordIndexAtPoint:location];
+
+    if (wordIndex >= 0 && wordIndex < _wordRanges.count) {
+        NSDictionary *wordInfo = _wordRanges[wordIndex];
+        NSString *word = wordInfo[@"word"];
+
+        [self emitWordPressEvent:word index:wordIndex];
+    }
+}
+
+- (void)handleLongPress:(UILongPressGestureRecognizer *)gesture
+{
+    if (gesture.state != UIGestureRecognizerStateBegan) return;
+
+    CGPoint location = [gesture locationInView:_textView];
+    NSInteger wordIndex = [self wordIndexAtPoint:location];
+
+    if (wordIndex >= 0 && wordIndex < _wordRanges.count) {
+        NSDictionary *wordInfo = _wordRanges[wordIndex];
+        NSString *word = wordInfo[@"word"];
+
+        [self showContextMenuForWord:word atIndex:wordIndex location:location];
+    }
+}
+
+- (NSInteger)wordIndexAtPoint:(CGPoint)point
+{
+    // Adjust point for text container insets
+    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];
+
+    // Find which word this character belongs to
+    for (NSDictionary *wordInfo in _wordRanges) {
+        NSValue *rangeValue = wordInfo[@"range"];
+        NSRange range = [rangeValue rangeValue];
+
+        if (NSLocationInRange(characterIndex, range)) {
+            return [wordInfo[@"index"] integerValue];
+        }
+    }
+
+    return -1;
+}
+
+- (void)showContextMenuForWord:(NSString *)word atIndex:(NSInteger)index location:(CGPoint)location
+{
+    if (!_menuOptions || _menuOptions.count == 0) return;
+
+    UIAlertController *alert = [UIAlertController alertControllerWithTitle:word
+                                                                   message:nil
+                                                            preferredStyle:UIAlertControllerStyleActionSheet];
+
+    for (NSString *option in _menuOptions) {
+        UIAlertAction *action = [UIAlertAction actionWithTitle:option
+                                                         style:UIAlertActionStyleDefault
+                                                       handler:^(UIAlertAction * _Nonnull action) {
+            [self emitSelectionEvent:word menuOption:option];
+        }];
+        [alert addAction:action];
+    }
+
+    UIAlertAction *cancelAction = [UIAlertAction actionWithTitle:@"Cancel"
+                                                           style:UIAlertActionStyleCancel
+                                                         handler:nil];
+    [alert addAction:cancelAction];
+
+    // Present from the root view controller
+    UIViewController *rootVC = [self findViewController];
+    if (rootVC) {
+        // For iPad, set up popover presentation
+        if (alert.popoverPresentationController) {
+            alert.popoverPresentationController.sourceView = _textView;
+            alert.popoverPresentationController.sourceRect = CGRectMake(location.x, location.y, 1, 1);
+        }
+
+        [rootVC presentViewController:alert animated:YES completion:nil];
+    }
+}
+
+- (UIViewController *)findViewController
+{
+    UIResponder *responder = self;
+    while (responder) {
+        if ([responder isKindOfClass:[UIViewController class]]) {
+            return (UIViewController *)responder;
+        }
+        responder = [responder nextResponder];
+    }
+    return nil;
+}
+
+- (void)emitWordPressEvent:(NSString *)word index:(NSInteger)index
+{
+    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);
+    }
+}
+
+- (void)emitSelectionEvent:(NSString *)selectedText menuOption:(NSString *)option
+{
+    if (_eventEmitter) {
+        auto emitter = std::static_pointer_cast<const AdvancedTextViewEventEmitter>(_eventEmitter);
+
+        AdvancedTextViewEventEmitter::OnSelection event;
+        event.selectedText = [selectedText UTF8String];
+        event.event = [option UTF8String];
+
+        emitter->onSelection(event);
+    }
+}
+
+- (void)layoutSubviews
+{
+    [super layoutSubviews];
+    _textView.frame = self.bounds;
+}
+
+- (UIColor *)hexStringToColor:(NSString *)stringToConvert
+{
+    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;
@@ -68,4 +366,9 @@ Class<RCTComponentViewProtocol> AdvancedTextViewCls(void)
     return [UIColor colorWithRed:r / 255.0f green:g / 255.0f blue:b / 255.0f alpha:1.0f];
 }
 
+Class<RCTComponentViewProtocol> AdvancedTextViewCls(void)
+{
+    return AdvancedTextView.class;
+}
+
 @end

package/package.json

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

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

@@ -1,59 +0,0 @@
-package com.advancedtext
-
-import android.text.Layout
-import android.text.Selection
-import android.text.Spannable
-import android.text.method.BaseMovementMethod
-import android.text.style.ClickableSpan
-import android.view.MotionEvent
-import android.widget.TextView
-
-class ClickableMovementMethod : BaseMovementMethod() {
-
-    companion object {
-        private var sInstance: ClickableMovementMethod? = null
-
-        fun getInstance(): ClickableMovementMethod {
-            if (sInstance == null) {
-                sInstance = ClickableMovementMethod()
-            }
-            return sInstance!!
-        }
-    }
-
-    override fun canSelectArbitrarily(): Boolean = false
-
-    override fun onTouchEvent(widget: TextView, buffer: Spannable, event: MotionEvent): Boolean {
-        val action = event.actionMasked
-        if (action == MotionEvent.ACTION_UP || action == MotionEvent.ACTION_DOWN) {
-
-            var x = (event.x - widget.totalPaddingLeft + widget.scrollX).toInt()
-            var y = (event.y - widget.totalPaddingTop + widget.scrollY).toInt()
-
-            val layout: Layout = widget.layout
-            val links: Array<ClickableSpan>? = if (y < 0 || y > layout.height) {
-                null
-            } else {
-                val line = layout.getLineForVertical(y)
-                if (x < layout.getLineLeft(line) || x > layout.getLineRight(line)) null
-                else {
-                    val offset = layout.getOffsetForHorizontal(line, x.toFloat())
-                    buffer.getSpans(offset, offset, ClickableSpan::class.java)
-                }
-            }
-
-            if (!links.isNullOrEmpty()) {
-                if (action == MotionEvent.ACTION_UP) links[0].onClick(widget)
-                else Selection.setSelection(buffer, buffer.getSpanStart(links[0]), buffer.getSpanEnd(links[0]))
-                return true
-            } else {
-                Selection.removeSelection(buffer)
-            }
-        }
-        return false
-    }
-
-    override fun initialize(widget: TextView, text: Spannable) {
-        Selection.removeSelection(text)
-    }
-}