@depup/react-native 0.84.1-depup.3 → 0.85.0-depup.1

package/ReactAndroid/src/main/java/com/facebook/react/views/scroll/VirtualViewContainerStateClassic.kt

@@ -33,52 +33,29 @@ internal class VirtualViewContainerStateClassic(scrollView: ViewGroup) :
         (-prerenderRect.height() * prerenderRatio).toInt(),
     )
 
-    if (hysteresisRatio > 0.0) {
-      hysteresisRect.set(prerenderRect)
-      hysteresisRect.inset(
-          (-visibleRect.width() * hysteresisRatio).toInt(),
-          (-visibleRect.height() * hysteresisRatio).toInt(),
-      )
-    }
-
     val virtualViewsIt =
         if (virtualView != null) listOf(virtualView) else virtualViews.toMutableSet()
     virtualViewsIt.forEach { vv ->
       val rect = vv.containerRelativeRect
 
-      var mode: VirtualViewMode? = VirtualViewMode.Hidden
+      var mode: VirtualViewMode = VirtualViewMode.Hidden
       var thresholdRect = emptyRect
       when {
         rectsOverlap(rect, visibleRect) -> {
           thresholdRect = visibleRect
-          if (onWindowFocusChangeListener != null) {
-            if (scrollView.hasWindowFocus()) {
-              mode = VirtualViewMode.Visible
-            } else {
-              mode = VirtualViewMode.Prerender
-            }
-          } else {
-            mode = VirtualViewMode.Visible
-          }
+          mode = VirtualViewMode.Visible
         }
         rectsOverlap(rect, prerenderRect) -> {
           mode = VirtualViewMode.Prerender
           thresholdRect = prerenderRect
         }
-        (hysteresisRatio > 0.0 && rectsOverlap(rect, hysteresisRect)) -> {
-          mode = null
-        }
       }
 
-      if (mode != null) {
-        vv.onModeChange(mode, thresholdRect)
-        debugLog(
-            "updateModes",
-            {
-              "virtualView=${vv.virtualViewID} mode=$mode  rect=$rect thresholdRect=$thresholdRect"
-            },
-        )
-      }
+      vv.onModeChange(mode, thresholdRect)
+      debugLog(
+          "updateModes",
+          { "virtualView=${vv.virtualViewID} mode=$mode  rect=$rect thresholdRect=$thresholdRect" },
+      )
     }
   }
 }

package/ReactAndroid/src/main/java/com/facebook/react/views/scroll/VirtualViewContainerStateExperimental.kt

@@ -24,8 +24,8 @@ internal class VirtualViewContainerStateExperimental(scrollView: ViewGroup) :
       }
   override val virtualViews = IntervalTree(horizontal)
 
-  // set of all VirtualViews that are in hysteresis, prerender, or visible range
-  var HPV: MutableSet<String> = mutableSetOf()
+  // set of all VirtualViews that are in prerender or visible ranges
+  var PV: MutableSet<String> = mutableSetOf()
   // set of all VirtualViews that are in prerender (not in viewport)
   var P: MutableSet<String> = mutableSetOf()
   // set of all VirtualViews that are in viewport
@@ -51,7 +51,7 @@ internal class VirtualViewContainerStateExperimental(scrollView: ViewGroup) :
 
   override fun remove(virtualView: VirtualView) {
     super.remove(virtualView)
-    HPV.remove(virtualView.virtualViewID)
+    PV.remove(virtualView.virtualViewID)
     P.remove(virtualView.virtualViewID)
     V.remove(virtualView.virtualViewID)
   }
@@ -63,57 +63,38 @@ internal class VirtualViewContainerStateExperimental(scrollView: ViewGroup) :
   private fun updateMode(virtualView: VirtualView) {
     val rect = virtualView.containerRelativeRect
 
-    var mode: VirtualViewMode? = VirtualViewMode.Hidden
+    var mode: VirtualViewMode = VirtualViewMode.Hidden
     var thresholdRect = emptyRect
     when {
       rectsOverlap(rect, visibleRect) -> {
         thresholdRect = visibleRect
-        if (onWindowFocusChangeListener != null) {
-          if (scrollView.hasWindowFocus()) {
-            mode = VirtualViewMode.Visible
-          } else {
-            mode = VirtualViewMode.Prerender
-          }
-        } else {
-          mode = VirtualViewMode.Visible
-        }
+        mode = VirtualViewMode.Visible
       }
       rectsOverlap(rect, prerenderRect) -> {
         mode = VirtualViewMode.Prerender
         thresholdRect = prerenderRect
       }
-      (hysteresisRatio > 0.0 && rectsOverlap(rect, hysteresisRect)) -> {
-        mode = null
-      }
     }
 
-    if (mode != null) {
-      virtualView.onModeChange(mode, thresholdRect)
-    }
+    virtualView.onModeChange(mode, thresholdRect)
 
     // move the virtualView into the correct set(s)
-    when {
-      mode == VirtualViewMode.Visible -> {
-        HPV.add(virtualView.virtualViewID)
+    when (mode) {
+      VirtualViewMode.Visible -> {
+        PV.add(virtualView.virtualViewID)
         P.remove(virtualView.virtualViewID)
         V.add(virtualView.virtualViewID)
       }
 
-      mode == VirtualViewMode.Prerender -> {
-        HPV.add(virtualView.virtualViewID)
+      VirtualViewMode.Prerender -> {
+        PV.add(virtualView.virtualViewID)
         P.add(virtualView.virtualViewID)
         V.remove(virtualView.virtualViewID)
       }
 
-      mode == VirtualViewMode.Hidden -> {
+      VirtualViewMode.Hidden -> {
         // remove from all sets
-        HPV.remove(virtualView.virtualViewID)
-        P.remove(virtualView.virtualViewID)
-        V.remove(virtualView.virtualViewID)
-      }
-
-      else -> { // hysteresis
-        HPV.add(virtualView.virtualViewID)
+        PV.remove(virtualView.virtualViewID)
         P.remove(virtualView.virtualViewID)
         V.remove(virtualView.virtualViewID)
       }
@@ -125,27 +106,25 @@ internal class VirtualViewContainerStateExperimental(scrollView: ViewGroup) :
    * n), where m = size of the prerender window in terms of index
    */
   private fun updateModesAll() {
-    // collect V', PV', HPV' sets
+    // collect V' and PV' sets
     val VPrime = virtualViews.query(visibleRect)
     val PVPrime = virtualViews.query(prerenderRect)
-    val HPVPrime = virtualViews.query(hysteresisRect)
 
-    debugLog("updateModes", { "V: ${V}, P: ${P}, HPV: ${HPV}" })
+    debugLog("updateModes", { "V: ${V}, P: ${P}, PV: ${PV}" })
 
     /** Perform utility set differences: */
     // P'=PV'-V'
     val PPrime = PVPrime.minus(VPrime)
 
-    debugLog("updateModes", { "V': ${VPrime}, P': ${PPrime}, HPV': ${HPVPrime}" })
+    debugLog("updateModes", { "V': ${VPrime}, P': ${PPrime}, PV': ${PVPrime}" })
 
     /** Get useful set differences */
     // V'-V - update to visible
     val toVisible = VPrime.minus(V)
     // P'-P - update to prerender
     val toPrerender = PPrime.minus(P)
-    // ignore H' - we don't care about VVs in hysteresis
-    // HPV-HPV' - update to hidden
-    val toHidden = HPV.minus(HPVPrime)
+    // PV-PV' - update to hidden
+    val toHidden = PV.minus(PVPrime)
 
     debugLog("updateModes", { "toV: ${toVisible}, toP: ${toPrerender}, toH: ${toHidden}" })
 
@@ -160,10 +139,10 @@ internal class VirtualViewContainerStateExperimental(scrollView: ViewGroup) :
       virtualViews.getVirtualView(vvID)?.onModeChange(VirtualViewMode.Hidden, emptyRect)
     }
 
-    /** update old sets - V, P, and HPV */
+    /** update old sets - V, P, and PV */
     V = VPrime
     P = PPrime.toMutableSet()
-    HPV = HPVPrime.toMutableSet()
+    PV = PVPrime.toMutableSet()
   }
 }
 

package/ReactAndroid/src/main/java/com/facebook/react/views/scroll/generate-nested-scroll-view.js

@@ -0,0 +1,270 @@
+#!/usr/bin/env node
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ * @noflow
+ * @oncall react_native
+ */
+
+/**
+ * Generates ReactNestedScrollView.java and ReactNestedScrollViewManager.kt from
+ * ReactScrollView.java and ReactScrollViewManager.kt respectively.
+ *
+ * This script creates variants that use NestedScrollView instead of ScrollView
+ * for experimentation purposes.
+ *
+ * Usage:
+ *     node generate-nested-scroll-view.js [--verify]
+ *
+ * Options:
+ *     --verify    Check if generated files are up-to-date (exit 1 if not)
+ */
+
+'use strict';
+
+const crypto = require('crypto');
+const fs = require('fs');
+const path = require('path');
+
+// SignedSource token - this placeholder gets replaced with the actual hash
+// Use string concatenation to avoid marking THIS script as generated
+const SIGNING_TOKEN = '<<SignedSource::*O*zOeWoEQle#+L!plEphiEmie@IsG>>';
+const GENERATED_ANNOTATION = '@' + 'generated';
+
+/**
+ * Sign the file content by replacing the signing token with a SignedSource hash.
+ */
+function signFileContent(content) {
+  // Compute MD5 hash with the token in place
+  const md5Hash = crypto
+    .createHash('md5')
+    .update(content, 'utf8')
+    .digest('hex');
+
+  // Replace the token with the actual signature
+  return content.replace(SIGNING_TOKEN, `SignedSource<<${md5Hash}>>`);
+}
+
+/**
+ * Get the signing token placeholder to embed in the file.
+ */
+function getSigningToken() {
+  return SIGNING_TOKEN;
+}
+
+/**
+ * Generate the header comment for a generated file.
+ */
+function generatedHeader(sourceFile) {
+  return `/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * ${GENERATED_ANNOTATION} ${getSigningToken()}
+ */
+
+/**
+ * THIS FILE IS GENERATED - DO NOT EDIT DIRECTLY
+ * Source: ${sourceFile}
+ * Run: node generate-nested-scroll-view.js
+ */
+
+`;
+}
+
+// Regex pattern for replacing ReactScrollView with ReactNestedScrollView
+// Excludes: Helper, CommandHelper, Accessible, Accessibility, ScrollState
+const REACT_SCROLL_VIEW_PATTERN =
+  /ReactScrollView(?!Helper|CommandHelper|Accessible|Accessibility|ScrollState)/g;
+
+// Regex pattern for matching the original copyright header
+const COPYRIGHT_HEADER_PATTERN = /\/\*\s*\n\s*\* Copyright.*?\*\/\s*\n/s;
+
+/**
+ * Replace ReactScrollView with ReactNestedScrollView in content.
+ */
+function replaceClassNames(content) {
+  return content.replace(REACT_SCROLL_VIEW_PATTERN, 'ReactNestedScrollView');
+}
+
+/**
+ * Replace the original copyright header with the generated header.
+ */
+function replaceCopyrightHeader(content, sourceFile) {
+  return content.replace(COPYRIGHT_HEADER_PATTERN, generatedHeader(sourceFile));
+}
+
+/**
+ * Transform ReactScrollView.java to ReactNestedScrollView.java
+ */
+function transformScrollView(content) {
+  // Replace import
+  content = content.replace(
+    'import android.widget.ScrollView;',
+    'import androidx.core.widget.NestedScrollView;',
+  );
+
+  // Replace standalone ScrollView with NestedScrollView (not when part of another word)
+  // This handles: "extends ScrollView", "ScrollView.class", etc.
+  // But NOT: ReactScrollView, NestedScrollView, ScrollViewHelper, etc.
+  content = content.replace(
+    /(?<![A-Za-z])ScrollView(?!Helper|Manager|CommandHelper|Interface|Accessible|Accessibility)/g,
+    'NestedScrollView',
+  );
+
+  // Replace ReactScrollView with ReactNestedScrollView
+  content = replaceClassNames(content);
+
+  // Fix visibility differences between ScrollView and NestedScrollView:
+  // NestedScrollView.onAttachedToWindow() is public, not protected
+  content = content.replace(
+    'protected void onAttachedToWindow()',
+    'public void onAttachedToWindow()',
+  );
+
+  // Make the class package-private (remove public) to keep it internal
+  content = content.replace(
+    'public class ReactNestedScrollView',
+    'class ReactNestedScrollView',
+  );
+
+  // Remove original copyright header and add generated header
+  content = replaceCopyrightHeader(content, 'ReactScrollView.java');
+
+  return content;
+}
+
+/**
+ * Transform ReactScrollViewManager.kt to ReactNestedScrollViewManager.kt
+ */
+function transformViewManager(content) {
+  // Replace ReactScrollView with ReactNestedScrollView
+  content = replaceClassNames(content);
+
+  // Keep the same REACT_CLASS name so this is a drop-in replacement for A/B testing
+  // (no JS changes needed - both managers register as "RCTScrollView")
+
+  // Make the class internal to keep it out of the public API
+  content = content.replace(
+    'public open class ReactNestedScrollViewManager',
+    'internal open class ReactNestedScrollViewManager',
+  );
+
+  // Remove original copyright header and add generated header
+  content = replaceCopyrightHeader(content, 'ReactScrollViewManager.kt');
+
+  return content;
+}
+
+/**
+ * Generate a file from source using the given transform function.
+ * Returns true if successful (or if verify mode and files match).
+ */
+function generateFile(sourcePath, outputPath, transformFn, verify) {
+  if (!fs.existsSync(sourcePath)) {
+    console.error(`Error: Source file not found: ${sourcePath}`);
+    return false;
+  }
+
+  const content = fs.readFileSync(sourcePath, 'utf8');
+  const transformed = transformFn(content);
+
+  // Sign the file content (replaces token with MD5 hash)
+  const signed = signFileContent(transformed);
+
+  if (verify) {
+    if (!fs.existsSync(outputPath)) {
+      console.error(`FAIL: Generated file does not exist: ${outputPath}`);
+      return false;
+    }
+
+    const existing = fs.readFileSync(outputPath, 'utf8');
+
+    if (existing !== signed) {
+      const sourceDir =
+        '~/fbsource/xplat/js/react-native-github/packages/react-native/ReactAndroid/src/main/java/com/facebook/react/views/scroll';
+      console.error(
+        `FAIL: ${path.basename(outputPath)} is out of date. ` +
+          `Run 'cd ${sourceDir} && node generate-nested-scroll-view.js' to update.`,
+      );
+      return false;
+    }
+
+    console.log(`OK: ${path.basename(outputPath)} is up-to-date`);
+    return true;
+  }
+
+  fs.writeFileSync(outputPath, signed, 'utf8');
+  console.log(`Generated: ${outputPath}`);
+  return true;
+}
+
+/**
+ * Parse command line arguments.
+ */
+function parseArgs(args) {
+  const result = {
+    verify: false,
+    sourceDir: null,
+  };
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === '--verify') {
+      result.verify = true;
+    } else if (arg === '--source-dir') {
+      if (i + 1 < args.length) {
+        result.sourceDir = args[++i];
+      } else {
+        console.error('Error: --source-dir requires a path argument');
+        process.exit(1);
+      }
+    } else if (arg === '--help' || arg === '-h') {
+      console.log(`Usage: node generate-nested-scroll-view.js [--verify] [--source-dir DIR]
+
+Options:
+    --verify        Check if generated files are up-to-date (exit 1 if not)
+    --source-dir    Directory containing source files (defaults to script directory)`);
+      process.exit(0);
+    }
+  }
+
+  return result;
+}
+
+function main() {
+  const args = parseArgs(process.argv.slice(2));
+
+  // Use provided source dir or fall back to script's directory
+  const sourceDir = args.sourceDir || path.dirname(process.argv[1]);
+
+  const filesToGenerate = [
+    {
+      source: path.join(sourceDir, 'ReactScrollView.java'),
+      output: path.join(sourceDir, 'ReactNestedScrollView.java'),
+      transform: transformScrollView,
+    },
+    {
+      source: path.join(sourceDir, 'ReactScrollViewManager.kt'),
+      output: path.join(sourceDir, 'ReactNestedScrollViewManager.kt'),
+      transform: transformViewManager,
+    },
+  ];
+
+  let success = true;
+  for (const {source, output, transform} of filesToGenerate) {
+    if (!generateFile(source, output, transform, args.verify)) {
+      success = false;
+    }
+  }
+
+  process.exit(success ? 0 : 1);
+}
+
+main();

package/ReactAndroid/src/main/java/com/facebook/react/views/swiperefresh/ReactSwipeRefreshLayout.kt

@@ -17,7 +17,7 @@ import com.facebook.react.uimanager.events.NativeGestureUtil
 import kotlin.math.abs
 
 /** Basic extension of [SwipeRefreshLayout] with ReactNative-specific functionality. */
-public class ReactSwipeRefreshLayout(reactContext: ReactContext) :
+public open class ReactSwipeRefreshLayout(reactContext: ReactContext) :
     SwipeRefreshLayout(reactContext) {
 
   private var didLayout: Boolean = false

package/ReactAndroid/src/main/java/com/facebook/react/views/swiperefresh/SwipeRefreshLayoutManager.kt

@@ -112,7 +112,7 @@ internal open class SwipeRefreshLayoutManager :
 
   override fun addEventEmitters(reactContext: ThemedReactContext, view: ReactSwipeRefreshLayout) {
     view.setOnRefreshListener {
-      val eventDispatcher = UIManagerHelper.getEventDispatcherForReactTag(reactContext, view.id)
+      val eventDispatcher = UIManagerHelper.getEventDispatcher(reactContext)
       eventDispatcher?.dispatchEvent(RefreshEvent(UIManagerHelper.getSurfaceId(view), view.id))
     }
   }

package/ReactAndroid/src/main/java/com/facebook/react/views/switchview/ReactSwitchManager.kt

@@ -5,6 +5,8 @@
  * LICENSE file in the root directory of this source tree.
  */
 
+@file:Suppress("DEPRECATION")
+
 package com.facebook.react.views.switchview
 
 import android.content.Context
@@ -14,6 +16,7 @@ import androidx.annotation.ColorInt
 import com.facebook.react.bridge.ReactContext
 import com.facebook.react.bridge.ReadableMap
 import com.facebook.react.uimanager.BaseViewManager
+import com.facebook.react.uimanager.LayoutShadowNode
 import com.facebook.react.uimanager.PixelUtil
 import com.facebook.react.uimanager.ThemedReactContext
 import com.facebook.react.uimanager.UIManagerHelper
@@ -25,19 +28,16 @@ import com.facebook.react.viewmanagers.AndroidSwitchManagerInterface
 import com.facebook.yoga.YogaMeasureMode
 import com.facebook.yoga.YogaMeasureOutput
 
-@Suppress("DEPRECATION")
 internal class ReactSwitchManager :
-    BaseViewManager<ReactSwitch, ReactSwitchShadowNode>(),
-    AndroidSwitchManagerInterface<ReactSwitch> {
+    BaseViewManager<ReactSwitch, LayoutShadowNode>(), AndroidSwitchManagerInterface<ReactSwitch> {
 
   private val delegate: ViewManagerDelegate<ReactSwitch> = AndroidSwitchManagerDelegate(this)
 
   override fun getName(): String = REACT_CLASS
 
-  override fun createShadowNodeInstance(): ReactSwitchShadowNode = ReactSwitchShadowNode()
+  override fun createShadowNodeInstance(): LayoutShadowNode = LayoutShadowNode()
 
-  override fun getShadowNodeClass(): Class<ReactSwitchShadowNode> =
-      ReactSwitchShadowNode::class.java
+  override fun getShadowNodeClass(): Class<LayoutShadowNode> = LayoutShadowNode::class.java
 
   override fun createViewInstance(context: ThemedReactContext): ReactSwitch =
       ReactSwitch(context).apply { showText = false }
@@ -139,7 +139,7 @@ internal class ReactSwitchManager :
         CompoundButton.OnCheckedChangeListener { buttonView, isChecked ->
           val reactContext = buttonView.context as ReactContext
           val reactTag = buttonView.id
-          UIManagerHelper.getEventDispatcherForReactTag(reactContext, reactTag)
+          UIManagerHelper.getEventDispatcher(reactContext)
               ?.dispatchEvent(
                   ReactSwitchEvent(UIManagerHelper.getSurfaceId(reactContext), reactTag, isChecked)
               )

package/ReactAndroid/src/main/java/com/facebook/react/views/text/PreparedLayout.kt

@@ -20,4 +20,6 @@ internal class PreparedLayout(
     val maximumNumberOfLines: Int,
     val verticalOffset: Float,
     val reactTags: IntArray,
+    val textBreakStrategy: Int,
+    val justificationMode: Int,
 )

package/ReactAndroid/src/main/java/com/facebook/react/views/text/PreparedLayoutTextView.kt

@@ -27,7 +27,9 @@ import com.facebook.proguard.annotations.DoNotStrip
 import com.facebook.react.uimanager.BackgroundStyleApplicator
 import com.facebook.react.uimanager.ReactCompoundView
 import com.facebook.react.uimanager.style.Overflow
+import com.facebook.react.views.text.internal.span.DrawCommandSpan
 import com.facebook.react.views.text.internal.span.ReactFragmentIndexSpan
+import com.facebook.react.views.text.internal.span.ReactLinkSpan
 import kotlin.collections.ArrayList
 import kotlin.math.roundToInt
 
@@ -66,9 +68,7 @@ internal class PreparedLayoutTextView(context: Context) : ViewGroup(context), Re
       }
     }
 
-  // T221698007: This is closest to existing behavior, but does not align with web. We may want to
-  // change in the future if not too breaking.
-  var overflow: Overflow = Overflow.HIDDEN
+  var overflow: Overflow = Overflow.VISIBLE
     set(value) {
       if (field != value) {
         field = value
@@ -84,23 +84,19 @@ internal class PreparedLayoutTextView(context: Context) : ViewGroup(context), Re
     @DoNotStrip get() = preparedLayout?.layout?.text
 
   init {
-    initView()
     // ViewGroup by default says only its children will draw
     setWillNotDraw(false)
   }
 
-  private fun initView() {
+  fun recycleView(): Unit {
+    BackgroundStyleApplicator.reset(this)
+    overflow = Overflow.VISIBLE
     clickableSpans = emptyList()
     selection = null
+    selectionColor = null
     preparedLayout = null
   }
 
-  fun recycleView(): Unit {
-    initView()
-    BackgroundStyleApplicator.reset(this)
-    overflow = Overflow.HIDDEN
-  }
-
   override fun onDraw(canvas: Canvas) {
     if (overflow != Overflow.VISIBLE) {
       BackgroundStyleApplicator.clipToPaddingBox(this, canvas)
@@ -119,11 +115,37 @@ internal class PreparedLayoutTextView(context: Context) : ViewGroup(context), Re
             selectionColor ?: DefaultStyleValuesUtil.getDefaultTextColorHighlight(context)
       }
 
+      val spanned = text as? Spanned
+      val drawCommandSpans =
+          spanned?.getSpans(0, spanned.length, DrawCommandSpan::class.java) ?: emptyArray()
+
+      if (spanned != null) {
+        for (span in drawCommandSpans) {
+          span.onPreDraw(
+              spanned.getSpanStart(span),
+              spanned.getSpanEnd(span),
+              canvas,
+              layout,
+          )
+        }
+      }
+
       if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
         Api34Utils.draw(layout, canvas, selection?.path, selectionPaint)
       } else {
         layout.draw(canvas, selection?.path, selectionPaint, 0)
       }
+
+      if (spanned != null) {
+        for (span in drawCommandSpans) {
+          span.onDraw(
+              spanned.getSpanStart(span),
+              spanned.getSpanEnd(span),
+              canvas,
+              layout,
+          )
+        }
+      }
     }
   }
 
@@ -181,12 +203,12 @@ internal class PreparedLayoutTextView(context: Context) : ViewGroup(context), Re
 
     if (action == MotionEvent.ACTION_UP) {
       clearSelection()
-      clickableSpan.onClick(this)
-    } else if (action == MotionEvent.ACTION_DOWN) {
-      val layout = checkNotNull(preparedLayout).layout
-      val start = (layout.text as Spanned).getSpanStart(clickableSpan)
-      val end = (layout.text as Spanned).getSpanEnd(clickableSpan)
-      setSelection(start, end)
+
+      // This will already get triggered by reactTagForTouch() based hit testing if it is React
+      // managed clickable text. We still want to click any native ClickableSpan (e.g. for URIs).
+      if (clickableSpan !is ReactLinkSpan) {
+        clickableSpan.onClick(this)
+      }
     }
 
     return true

package/ReactAndroid/src/main/java/com/facebook/react/views/text/PreparedLayoutTextViewManager.kt

@@ -108,7 +108,7 @@ internal class PreparedLayoutTextViewManager :
 
   @ReactProp(name = "overflow")
   fun setOverflow(view: PreparedLayoutTextView, overflow: String?): Unit {
-    view.overflow = overflow?.let { Overflow.fromString(it) } ?: Overflow.HIDDEN
+    view.overflow = overflow?.let { Overflow.fromString(it) } ?: Overflow.VISIBLE
   }
 
   @ReactProp(name = "accessible")
@@ -118,8 +118,9 @@ internal class PreparedLayoutTextViewManager :
 
   @ReactProp(name = "selectable", defaultBoolean = false)
   fun setSelectable(view: PreparedLayoutTextView, isSelectable: Boolean): Unit {
-    // T222052152: Implement fine-grained text selection for PreparedLayoutTextView
-    // view.setTextIsSelectable(isSelectable);
+    check(!isSelectable) {
+      "selectable Text should use SelectableTextViewManager instead of PreparedLayoutViewManager"
+    }
   }
 
   @ReactProp(name = "selectionColor", customType = "Color")