react-native-advanced-text 0.2.16 → 0.2.17

package/README.md

@@ -52,6 +52,15 @@ import { AdvancedText } from "react-native-advanced-text";
 />
 ```
 
+## Word gestures
+
+| Prop | Fires on | Notes |
+| --- | --- | --- |
+| `onWordPress` | a tap on a word | `{ word, index }` |
+| `onWordDoublePress` | a double tap on a word | `{ word, index }`. A double tap never selects text. While this is set, a single tap waits out the double-tap delay (~300 ms) before `onWordPress`, so a double tap doesn't also fire it. |
+| `onWordLongPress` | a long press on a word | `{ word, index }`. Text selection still starts as usual. |
+| `onSelection` | the selection menu | `{ selectedText, event, startWordIndex, endWordIndex }`: the menu option, and the first and last word index the selection touches (`-1` if none). |
+
 ## Underlined words
 
 An entry in `highlightedWords` with `underline: true` draws a line under the

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

@@ -24,6 +24,7 @@ import android.view.Menu
 import android.view.MenuItem
 import android.view.View
 import android.view.MotionEvent
+import android.view.ViewConfiguration
 import android.view.accessibility.AccessibilityNodeInfo
 import android.widget.TextView
 import com.facebook.react.bridge.Arguments
@@ -40,6 +41,8 @@ class AdvancedTextView : TextView {
     private var highlightedWords: List<HighlightedWord> = emptyList()
     private var menuOptions: List<String> = emptyList()
     private var lastSelectedText: String = ""
+    // First and last word index the selection touches, -1 for none.
+    private var lastSelectedWords: Pair<Int, Int> = -1 to -1
     private var customActionMode: ActionMode? = null
     private var currentText: String = ""
     private var textColor: String = "#000000"
@@ -68,6 +71,23 @@ class AdvancedTextView : TextView {
     private val rangeBounds = RectF()
     private val underlineBounds = RectF()
 
+    // Double taps are only told apart while the app handles them
+    // (onWordDoublePress); otherwise a tap fires onWordPress at once.
+    private var wordDoublePressEnabled = false
+    private val doubleTapTimeout = ViewConfiguration.getDoubleTapTimeout().toLong()
+    private var doubleTapSlopSquare = 0
+    private var lastTapUpTime = 0L
+    private var lastTapUpX = 0f
+    private var lastTapUpY = 0f
+    // From a double tap's second touch down to its up. The TextView never sees
+    // those events, so it can't select the word as it would on a double tap.
+    private var handlingDoubleTap = false
+    // A tap's onWordPress, held back while a second tap could still come.
+    private var pendingWordPress: Runnable? = null
+    private var lastDownX = 0f
+    private var lastDownY = 0f
+    private var longPressed = false
+
     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() }
@@ -93,6 +113,19 @@ class AdvancedTextView : TextView {
 
         movementMethod = SmartMovementMethod
 
+        val slop = ViewConfiguration.get(context).scaledDoubleTapSlop
+        doubleTapSlopSquare = slop * slop
+
+        // Reports the word, then returns false so the TextView still starts a
+        // selection as usual.
+        setOnLongClickListener {
+            longPressed = true
+            wordAt(lastDownX, lastDownY)?.let {
+                sendWordEvent("onWordLongPress", it.word, it.index)
+            }
+            false
+        }
+
         customSelectionActionModeCallback = object : ActionMode.Callback {
             override fun onCreateActionMode(mode: ActionMode?, menu: Menu?): Boolean {
                 customActionMode = mode
@@ -107,6 +140,7 @@ class AdvancedTextView : TextView {
 
                 if (selectionStart >= 0 && selectionEnd >= 0 && selectionStart != selectionEnd) {
                     lastSelectedText = text.subSequence(selectionStart, selectionEnd).toString()
+                    lastSelectedWords = wordIndexRange(selectionStart, selectionEnd)
 
                     menuOptions.forEachIndexed { index, option ->
                         menu?.add(0, index, index, option)
@@ -525,6 +559,8 @@ class AdvancedTextView : TextView {
             val event = Arguments.createMap().apply {
                 putString("selectedText", selectedText)
                 putString("event", eventType)
+                putInt("startWordIndex", lastSelectedWords.first)
+                putInt("endWordIndex", lastSelectedWords.second)
             }
 
             reactContext.getJSModule(RCTEventEmitter::class.java)
@@ -541,7 +577,18 @@ class AdvancedTextView : TextView {
 
         override fun onClick(widget: View) {
             Log.d(TAG, "Word clicked: '$word' (index=$wordIndex)")
-            sendWordPressEvent(word, wordIndex)
+            if (!wordDoublePressEnabled) {
+                sendWordEvent("onWordPress", word, wordIndex)
+                return
+            }
+            // Wait to see whether this is the first tap of a double tap.
+            cancelPendingWordPress()
+            val press = Runnable {
+                pendingWordPress = null
+                sendWordEvent("onWordPress", word, wordIndex)
+            }
+            pendingWordPress = press
+            postDelayed(press, doubleTapTimeout)
         }
 
         // Skips super, which would paint the word in the link color and
@@ -551,7 +598,8 @@ class AdvancedTextView : TextView {
         }
     }
 
-    private fun sendWordPressEvent(word: String, index: Int) {
+    // onWordPress, onWordDoublePress or onWordLongPress.
+    private fun sendWordEvent(eventName: String, word: String, index: Int) {
         try {
             val reactContext = context as? ReactContext ?: return
             val event = Arguments.createMap().apply {
@@ -560,10 +608,102 @@ class AdvancedTextView : TextView {
             }
 
             reactContext.getJSModule(RCTEventEmitter::class.java)
-                .receiveEvent(id, "onWordPress", event)
+                .receiveEvent(id, eventName, event)
         } catch (e: Exception) {
-            Log.e(TAG, "Error sending word press event", e)
+            Log.e(TAG, "Error sending $eventName event", e)
+        }
+    }
+
+    fun setWordDoublePressEnabled(enabled: Boolean) {
+        if (wordDoublePressEnabled == enabled) return
+        wordDoublePressEnabled = enabled
+        lastTapUpTime = 0L
+        // A tap held back for a double tap fires now instead of being lost.
+        pendingWordPress?.let {
+            removeCallbacks(it)
+            it.run()
+        }
+    }
+
+    override fun onTouchEvent(event: MotionEvent): Boolean {
+        when (event.actionMasked) {
+            MotionEvent.ACTION_DOWN -> {
+                lastDownX = event.x
+                lastDownY = event.y
+                longPressed = false
+                if (wordDoublePressEnabled && isSecondTap(event)) {
+                    cancelPendingWordPress()
+                    handlingDoubleTap = true
+                    return true
+                }
+            }
+            MotionEvent.ACTION_UP -> if (handlingDoubleTap) {
+                handlingDoubleTap = false
+                lastTapUpTime = 0L
+                wordAt(event.x, event.y)?.let {
+                    sendWordEvent("onWordDoublePress", it.word, it.index)
+                }
+                return true
+            }
+            MotionEvent.ACTION_CANCEL -> if (handlingDoubleTap) {
+                handlingDoubleTap = false
+                lastTapUpTime = 0L
+                return true
+            }
+        }
+        if (handlingDoubleTap) return true
+
+        val handled = super.onTouchEvent(event)
+        if (event.actionMasked == MotionEvent.ACTION_UP) {
+            // A long press isn't the first tap of a double tap.
+            if (longPressed) {
+                lastTapUpTime = 0L
+            } else {
+                lastTapUpTime = event.eventTime
+                lastTapUpX = event.x
+                lastTapUpY = event.y
+            }
         }
+        return handled
+    }
+
+    override fun onDetachedFromWindow() {
+        cancelPendingWordPress()
+        super.onDetachedFromWindow()
+    }
+
+    private fun isSecondTap(down: MotionEvent): Boolean {
+        if (lastTapUpTime == 0L || down.eventTime - lastTapUpTime > doubleTapTimeout) {
+            return false
+        }
+        val dx = down.x - lastTapUpX
+        val dy = down.y - lastTapUpY
+        return dx * dx + dy * dy < doubleTapSlopSquare
+    }
+
+    private fun cancelPendingWordPress() {
+        pendingWordPress?.let { removeCallbacks(it) }
+        pendingWordPress = null
+    }
+
+    // The word under a point in view coordinates, or null for blank space,
+    // including the space past the end of a line.
+    private fun wordAt(x: Float, y: Float): WordPosition? {
+        val currentLayout = layout ?: return null
+        val line = currentLayout.getLineForVertical((y - totalPaddingTop + scrollY).toInt())
+        val lineX = x - totalPaddingLeft + scrollX
+        if (lineX < currentLayout.getLineLeft(line) || lineX > currentLayout.getLineRight(line)) {
+            return null
+        }
+        val offset = getOffsetForPosition(x, y)
+        return wordPositions.find { offset >= it.start && offset <= it.end }
+    }
+
+    // First and last word text[start, end) touches, or -1 to -1 for none.
+    private fun wordIndexRange(start: Int, end: Int): Pair<Int, Int> {
+        val touched = wordPositions.filter { it.start < end && it.end > start }
+        if (touched.isEmpty()) return -1 to -1
+        return touched.first().index to touched.last().index
     }
 
     fun clearSelection() {

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

@@ -161,9 +161,16 @@ class AdvancedTextViewManager : SimpleViewManager<AdvancedTextView>() {
         view?.setAdvancedLetterSpacing(letterSpacing)
     }
 
+    @ReactProp(name = "wordDoublePressEnabled")
+    fun setWordDoublePressEnabled(view: AdvancedTextView?, enabled: Boolean) {
+        view?.setWordDoublePressEnabled(enabled)
+    }
+
     override fun getExportedCustomDirectEventTypeConstants(): Map<String, Any> {
         return mapOf(
             "onWordPress" to mapOf("registrationName" to "onWordPress"),
+            "onWordDoublePress" to mapOf("registrationName" to "onWordDoublePress"),
+            "onWordLongPress" to mapOf("registrationName" to "onWordLongPress"),
             "onSelection" to mapOf("registrationName" to "onSelection")
         )
     }

package/ios/AdvancedTextView.mm

@@ -91,6 +91,11 @@ static UIFont *ATResolveFont(NSString *family, CGFloat size)
 @interface AdvancedTextView () <RCTAdvancedTextViewViewProtocol, UIGestureRecognizerDelegate, UITextViewDelegate>
 
 @property (nonatomic, strong) CustomTextView *textView;
+@property (nonatomic, strong) UITapGestureRecognizer *singleTapGesture;
+@property (nonatomic, strong) UITapGestureRecognizer *doubleTapGesture;
+@property (nonatomic, strong) UILongPressGestureRecognizer *longPressGesture;
+// On while the app handles double taps (onWordDoublePress).
+@property (nonatomic, assign) BOOL wordDoublePressEnabled;
 
 @end
 
@@ -177,6 +182,24 @@ static UIFont *ATResolveFont(NSString *family, CGFloat size)
                                               action:@selector(handleTap:)];
         tapGesture.delegate = self;
         [_textView addGestureRecognizer:tapGesture];
+        _singleTapGesture = tapGesture;
+
+        // Off until the app handles double taps, so taps aren't delayed.
+        UITapGestureRecognizer *doubleTapGesture = [[UITapGestureRecognizer alloc]
+                                                    initWithTarget:self
+                                                    action:@selector(handleDoubleTap:)];
+        doubleTapGesture.numberOfTapsRequired = 2;
+        doubleTapGesture.delegate = self;
+        doubleTapGesture.enabled = NO;
+        [_textView addGestureRecognizer:doubleTapGesture];
+        _doubleTapGesture = doubleTapGesture;
+
+        UILongPressGestureRecognizer *longPressGesture = [[UILongPressGestureRecognizer alloc]
+                                                          initWithTarget:self
+                                                          action:@selector(handleLongPress:)];
+        longPressGesture.delegate = self;
+        [_textView addGestureRecognizer:longPressGesture];
+        _longPressGesture = longPressGesture;
 
         NSLog(@"[AdvancedTextView] Gesture recognizers setup successful");
     } @catch (NSException *exception) {
@@ -228,6 +251,11 @@ static UIFont *ATResolveFont(NSString *family, CGFloat size)
             styleChanged = YES;
         }
 
+        if (oldViewProps.wordDoublePressEnabled != newViewProps.wordDoublePressEnabled) {
+            _wordDoublePressEnabled = newViewProps.wordDoublePressEnabled;
+            _doubleTapGesture.enabled = _wordDoublePressEnabled;
+        }
+
         if (oldViewProps.text != newViewProps.text) {
             textChanged = YES;
             NSLog(@"[AdvancedTextView] Text changed");
@@ -693,6 +721,89 @@ static UIFont *ATResolveFont(NSString *family, CGFloat size)
     }
 }
 
+- (void)handleDoubleTap:(UITapGestureRecognizer *)gesture
+{
+    @try {
+        if (gesture.state != UIGestureRecognizerStateEnded) return;
+
+        // In case the text view selected anything before giving way.
+        _textView.selectedTextRange = nil;
+
+        NSInteger wordIndex = [self wordIndexAtPoint:[gesture locationInView:_textView]];
+        if (wordIndex >= 0 && wordIndex < _wordRanges.count) {
+            [self emitWordEvent:@"doublePress" word:_wordRanges[wordIndex][@"word"] index:wordIndex];
+        }
+    } @catch (NSException *exception) {
+        NSLog(@"[AdvancedTextView] Exception in handleDoubleTap: %@", exception);
+    }
+}
+
+// Only reports the word: the text view's own long press still starts a selection.
+- (void)handleLongPress:(UILongPressGestureRecognizer *)gesture
+{
+    @try {
+        if (gesture.state != UIGestureRecognizerStateBegan) return;
+
+        NSInteger wordIndex = [self wordIndexAtPoint:[gesture locationInView:_textView]];
+        if (wordIndex >= 0 && wordIndex < _wordRanges.count) {
+            [self emitWordEvent:@"longPress" word:_wordRanges[wordIndex][@"word"] index:wordIndex];
+        }
+    } @catch (NSException *exception) {
+        NSLog(@"[AdvancedTextView] Exception in handleLongPress: %@", exception);
+    }
+}
+
+#pragma mark - UIGestureRecognizerDelegate
+
+// While double taps are handled, a single tap waits to see whether a second
+// one follows, so a double tap doesn't also fire onWordPress.
+- (BOOL)gestureRecognizer:(UIGestureRecognizer *)gestureRecognizer
+    shouldRequireFailureOfGestureRecognizer:(UIGestureRecognizer *)otherGestureRecognizer
+{
+    return _wordDoublePressEnabled &&
+        gestureRecognizer == _singleTapGesture &&
+        otherGestureRecognizer == _doubleTapGesture;
+}
+
+// The text view's own double tap selects the word. It waits for ours, which
+// wins on every double tap, so a double tap never selects text.
+- (BOOL)gestureRecognizer:(UIGestureRecognizer *)gestureRecognizer
+    shouldBeRequiredToFailByGestureRecognizer:(UIGestureRecognizer *)otherGestureRecognizer
+{
+    if (!_wordDoublePressEnabled || gestureRecognizer != _doubleTapGesture) {
+        return NO;
+    }
+    if (![otherGestureRecognizer isKindOfClass:[UITapGestureRecognizer class]]) {
+        return NO;
+    }
+    return ((UITapGestureRecognizer *)otherGestureRecognizer).numberOfTapsRequired >= 2;
+}
+
+// The long press runs alongside the text view's own, which starts the selection.
+- (BOOL)gestureRecognizer:(UIGestureRecognizer *)gestureRecognizer
+    shouldRecognizeSimultaneouslyWithGestureRecognizer:(UIGestureRecognizer *)otherGestureRecognizer
+{
+    return gestureRecognizer == _longPressGesture || otherGestureRecognizer == _longPressGesture;
+}
+
+// The first and last word a character range touches, or -1 for none.
+- (void)wordIndexesForRange:(NSRange)range first:(NSInteger *)first last:(NSInteger *)last
+{
+    *first = -1;
+    *last = -1;
+    for (NSDictionary *wordInfo in _wordRanges) {
+        NSRange wordRange = [wordInfo[@"range"] rangeValue];
+        if (NSIntersectionRange(wordRange, range).length == 0) {
+            continue;
+        }
+        NSInteger index = [wordInfo[@"index"] integerValue];
+        if (*first < 0) {
+            *first = index;
+        }
+        *last = index;
+    }
+}
+
 #pragma mark - UITextViewDelegate
 
 - (void)textViewDidChangeSelection:(UITextView *)textView
@@ -815,6 +926,29 @@ static UIFont *ATResolveFont(NSString *family, CGFloat size)
     }
 }
 
+// onWordDoublePress ("doublePress") or onWordLongPress ("longPress").
+- (void)emitWordEvent:(NSString *)type word:(NSString *)word index:(NSInteger)index
+{
+    @try {
+        if (!_eventEmitter) return;
+        auto emitter = std::static_pointer_cast<const AdvancedTextViewEventEmitter>(_eventEmitter);
+
+        if ([type isEqualToString:@"doublePress"]) {
+            AdvancedTextViewEventEmitter::OnWordDoublePress event;
+            event.word = [word UTF8String];
+            event.index = static_cast<int>(index);
+            emitter->onWordDoublePress(event);
+        } else {
+            AdvancedTextViewEventEmitter::OnWordLongPress event;
+            event.word = [word UTF8String];
+            event.index = static_cast<int>(index);
+            emitter->onWordLongPress(event);
+        }
+    } @catch (NSException *exception) {
+        NSLog(@"[AdvancedTextView] Exception in emitWordEvent: %@", exception);
+    }
+}
+
 - (void)emitSelectionEvent:(NSString *)selectedText menuOption:(NSString *)option
 {
     NSLog(@"[AdvancedTextView] emitSelectionEvent: %@ with option: %@", selectedText, option);
@@ -822,9 +956,15 @@ static UIFont *ATResolveFont(NSString *family, CGFloat size)
         if (_eventEmitter) {
             auto emitter = std::static_pointer_cast<const AdvancedTextViewEventEmitter>(_eventEmitter);
 
+            NSInteger firstWord = -1;
+            NSInteger lastWord = -1;
+            [self wordIndexesForRange:_textView.selectedRange first:&firstWord last:&lastWord];
+
             AdvancedTextViewEventEmitter::OnSelection event;
             event.selectedText = [selectedText UTF8String];
             event.event = [option UTF8String];
+            event.startWordIndex = static_cast<int>(firstWord);
+            event.endWordIndex = static_cast<int>(lastWord);
 
             emitter->onSelection(event);
         }

package/lib/module/AdvancedText.js

@@ -9,6 +9,8 @@ export const AdvancedText = ({
   highlightedWords,
   menuOptions,
   onWordPress,
+  onWordDoublePress,
+  onWordLongPress,
   onSelection,
   ...restProps
 }) => {
@@ -19,7 +21,12 @@ export const AdvancedText = ({
     highlightedWords: highlightedWords,
     menuOptions: menuOptions,
     onWordPress: onWordPress,
+    onWordDoublePress: onWordDoublePress,
+    onWordLongPress: onWordLongPress,
     onSelection: onSelection
+    // Only apps that handle double taps pay the single-tap delay.
+    ,
+    wordDoublePressEnabled: !!onWordDoublePress
   });
 };
 //# sourceMappingURL=AdvancedText.js.map

package/lib/module/AdvancedText.js.map

@@ -1 +1 @@
-{"version":3,"names":["React","AdvancedTextViewNativeComponent","jsx","_jsx","AdvancedText","text","style","highlightedWords","menuOptions","onWordPress","onSelection","restProps"],"sourceRoot":"../../src","sources":["AdvancedText.tsx"],"mappings":";;AAAA,OAAOA,KAAK,MAAM,OAAO;AACzB,OAAOC,+BAA+B,MAE/B,mCAAmC;AAAC,SAAAC,GAAA,IAAAC,IAAA;AAE3C,OAAO,MAAMC,YAAmC,GAAGA,CAAC;EAClDC,IAAI;EACJC,KAAK;EACLC,gBAAgB;EAChBC,WAAW;EACXC,WAAW;EACXC,WAAW;EACX,GAAGC;AACL,CAAC,KAAK;EACJ,oBACER,IAAA,CAACF,+BAA+B;IAAA,GAC1BU,SAAS;IACbL,KAAK,EAAEA,KAAM;IACbD,IAAI,EAAEA,IAAK;IACXE,gBAAgB,EAAEA,gBAAiB;IACnCC,WAAW,EAAEA,WAAY;IACzBC,WAAW,EAAEA,WAAY;IACzBC,WAAW,EAAEA;EAAY,CAC1B,CAAC;AAEN,CAAC","ignoreList":[]}
+{"version":3,"names":["React","AdvancedTextViewNativeComponent","jsx","_jsx","AdvancedText","text","style","highlightedWords","menuOptions","onWordPress","onWordDoublePress","onWordLongPress","onSelection","restProps","wordDoublePressEnabled"],"sourceRoot":"../../src","sources":["AdvancedText.tsx"],"mappings":";;AAAA,OAAOA,KAAK,MAAM,OAAO;AACzB,OAAOC,+BAA+B,MAE/B,mCAAmC;AAAC,SAAAC,GAAA,IAAAC,IAAA;AAE3C,OAAO,MAAMC,YAAmC,GAAGA,CAAC;EAClDC,IAAI;EACJC,KAAK;EACLC,gBAAgB;EAChBC,WAAW;EACXC,WAAW;EACXC,iBAAiB;EACjBC,eAAe;EACfC,WAAW;EACX,GAAGC;AACL,CAAC,KAAK;EACJ,oBACEV,IAAA,CAACF,+BAA+B;IAAA,GAC1BY,SAAS;IACbP,KAAK,EAAEA,KAAM;IACbD,IAAI,EAAEA,IAAK;IACXE,gBAAgB,EAAEA,gBAAiB;IACnCC,WAAW,EAAEA,WAAY;IACzBC,WAAW,EAAEA,WAAY;IACzBC,iBAAiB,EAAEA,iBAAkB;IACrCC,eAAe,EAAEA,eAAgB;IACjCC,WAAW,EAAEA;IACb;IAAA;IACAE,sBAAsB,EAAE,CAAC,CAACJ;EAAkB,CAC7C,CAAC;AAEN,CAAC","ignoreList":[]}

package/lib/module/AdvancedTextViewNativeComponent.ts

@@ -18,7 +18,21 @@ export interface NativeProps extends ViewProps {
   highlightedWords?: ReadonlyArray<HighlightedWord>;
   menuOptions?: ReadonlyArray<string>;
   onWordPress?: DirectEventHandler<{ word: string; index: Int32 }>;
-  onSelection?: DirectEventHandler<{ selectedText: string; event: string }>;
+  // A double tap on a word. It never selects text.
+  onWordDoublePress?: DirectEventHandler<{ word: string; index: Int32 }>;
+  // A long press on a word. Text selection still starts as usual.
+  onWordLongPress?: DirectEventHandler<{ word: string; index: Int32 }>;
+  // startWordIndex/endWordIndex: the first and last word the selection
+  // touches, or -1 when it touches none.
+  onSelection?: DirectEventHandler<{
+    selectedText: string;
+    event: string;
+    startWordIndex: Int32;
+    endWordIndex: Int32;
+  }>;
+  // Set by AdvancedText when onWordDoublePress is given. While on, a single
+  // tap waits out the double-tap delay before firing onWordPress.
+  wordDoublePressEnabled?: boolean;
   fontSize?: Int32;
   fontWeight?: string;
   color?: string;

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

@@ -1 +1 @@
-{"version":3,"file":"AdvancedText.d.ts","sourceRoot":"","sources":["../../../src/AdvancedText.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,OAAwC,EACtC,KAAK,WAAW,EACjB,MAAM,mCAAmC,CAAC;AAE3C,eAAO,MAAM,YAAY,EAAE,KAAK,CAAC,EAAE,CAAC,WAAW,CAoB9C,CAAC"}
+{"version":3,"file":"AdvancedText.d.ts","sourceRoot":"","sources":["../../../src/AdvancedText.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,OAAwC,EACtC,KAAK,WAAW,EACjB,MAAM,mCAAmC,CAAC;AAE3C,eAAO,MAAM,YAAY,EAAE,KAAK,CAAC,EAAE,CAAC,WAAW,CA0B9C,CAAC"}

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

@@ -14,10 +14,21 @@ export interface NativeProps extends ViewProps {
         word: string;
         index: Int32;
     }>;
+    onWordDoublePress?: DirectEventHandler<{
+        word: string;
+        index: Int32;
+    }>;
+    onWordLongPress?: DirectEventHandler<{
+        word: string;
+        index: Int32;
+    }>;
     onSelection?: DirectEventHandler<{
         selectedText: string;
         event: string;
+        startWordIndex: Int32;
+        endWordIndex: Int32;
     }>;
+    wordDoublePressEnabled?: boolean;
     fontSize?: Int32;
     fontWeight?: string;
     color?: string;

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

@@ -1 +1 @@
-{"version":3,"file":"AdvancedTextViewNativeComponent.d.ts","sourceRoot":"","sources":["../../../src/AdvancedTextViewNativeComponent.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAG9C,OAAO,KAAK,EAAE,kBAAkB,EAAE,KAAK,EAAG,KAAK,EAAG,MAAM,2CAA2C,CAAC;AAEpG,UAAU,eAAe;IACvB,KAAK,EAAE,KAAK,CAAC;IACb,cAAc,EAAE,MAAM,CAAC;IACvB,YAAY,CAAC,EAAE,KAAK,CAAC;IAGrB,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAED,MAAM,WAAW,WAAY,SAAQ,SAAS;IAC5C,IAAI,EAAE,MAAM,CAAC;IACb,gBAAgB,CAAC,EAAE,aAAa,CAAC,eAAe,CAAC,CAAC;IAClD,WAAW,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IACpC,WAAW,CAAC,EAAE,kBAAkB,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,KAAK,CAAA;KAAE,CAAC,CAAC;IACjE,WAAW,CAAC,EAAE,kBAAkB,CAAC;QAAE,YAAY,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC1E,QAAQ,CAAC,EAAE,KAAK,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,KAAK,CAAC;IACnB,aAAa,CAAC,EAAE,KAAK,CAAC;IACtB,kBAAkB,CAAC,EAAE,KAAK,CAAC;IAC3B,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;;AAED,wBAAuE"}
+{"version":3,"file":"AdvancedTextViewNativeComponent.d.ts","sourceRoot":"","sources":["../../../src/AdvancedTextViewNativeComponent.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAG9C,OAAO,KAAK,EAAE,kBAAkB,EAAE,KAAK,EAAG,KAAK,EAAG,MAAM,2CAA2C,CAAC;AAEpG,UAAU,eAAe;IACvB,KAAK,EAAE,KAAK,CAAC;IACb,cAAc,EAAE,MAAM,CAAC;IACvB,YAAY,CAAC,EAAE,KAAK,CAAC;IAGrB,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAED,MAAM,WAAW,WAAY,SAAQ,SAAS;IAC5C,IAAI,EAAE,MAAM,CAAC;IACb,gBAAgB,CAAC,EAAE,aAAa,CAAC,eAAe,CAAC,CAAC;IAClD,WAAW,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IACpC,WAAW,CAAC,EAAE,kBAAkB,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,KAAK,CAAA;KAAE,CAAC,CAAC;IAEjE,iBAAiB,CAAC,EAAE,kBAAkB,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,KAAK,CAAA;KAAE,CAAC,CAAC;IAEvE,eAAe,CAAC,EAAE,kBAAkB,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,KAAK,CAAA;KAAE,CAAC,CAAC;IAGrE,WAAW,CAAC,EAAE,kBAAkB,CAAC;QAC/B,YAAY,EAAE,MAAM,CAAC;QACrB,KAAK,EAAE,MAAM,CAAC;QACd,cAAc,EAAE,KAAK,CAAC;QACtB,YAAY,EAAE,KAAK,CAAC;KACrB,CAAC,CAAC;IAGH,sBAAsB,CAAC,EAAE,OAAO,CAAC;IACjC,QAAQ,CAAC,EAAE,KAAK,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,KAAK,CAAC;IACnB,aAAa,CAAC,EAAE,KAAK,CAAC;IACtB,kBAAkB,CAAC,EAAE,KAAK,CAAC;IAC3B,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;;AAED,wBAAuE"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-advanced-text",
-  "version": "0.2.16",
+  "version": "0.2.17",
   "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/AdvancedText.tsx

@@ -9,6 +9,8 @@ export const AdvancedText: React.FC<NativeProps> = ({
   highlightedWords,
   menuOptions,
   onWordPress,
+  onWordDoublePress,
+  onWordLongPress,
   onSelection,
   ...restProps
 }) => {
@@ -20,7 +22,11 @@ export const AdvancedText: React.FC<NativeProps> = ({
       highlightedWords={highlightedWords}
       menuOptions={menuOptions}
       onWordPress={onWordPress}
+      onWordDoublePress={onWordDoublePress}
+      onWordLongPress={onWordLongPress}
       onSelection={onSelection}
+      // Only apps that handle double taps pay the single-tap delay.
+      wordDoublePressEnabled={!!onWordDoublePress}
     />
   );
 };

package/src/AdvancedTextViewNativeComponent.ts

@@ -18,7 +18,21 @@ export interface NativeProps extends ViewProps {
   highlightedWords?: ReadonlyArray<HighlightedWord>;
   menuOptions?: ReadonlyArray<string>;
   onWordPress?: DirectEventHandler<{ word: string; index: Int32 }>;
-  onSelection?: DirectEventHandler<{ selectedText: string; event: string }>;
+  // A double tap on a word. It never selects text.
+  onWordDoublePress?: DirectEventHandler<{ word: string; index: Int32 }>;
+  // A long press on a word. Text selection still starts as usual.
+  onWordLongPress?: DirectEventHandler<{ word: string; index: Int32 }>;
+  // startWordIndex/endWordIndex: the first and last word the selection
+  // touches, or -1 when it touches none.
+  onSelection?: DirectEventHandler<{
+    selectedText: string;
+    event: string;
+    startWordIndex: Int32;
+    endWordIndex: Int32;
+  }>;
+  // Set by AdvancedText when onWordDoublePress is given. While on, a single
+  // tap waits out the double-tap delay before firing onWordPress.
+  wordDoublePressEnabled?: boolean;
   fontSize?: Int32;
   fontWeight?: string;
   color?: string;