react-native-tvos 0.74.5-0 → 0.75.2-0rc0

package/ReactAndroid/src/main/java/com/facebook/react/uimanager/style/BorderRadiusStyle.kt

@@ -0,0 +1,146 @@
+/*
+ * 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.
+ */
+
+package com.facebook.react.uimanager.style
+
+import android.content.Context
+import android.util.LayoutDirection
+import com.facebook.react.modules.i18nmanager.I18nUtil
+import com.facebook.react.uimanager.LengthPercentage
+
+/** Represents the collection of possible border radius style properties. */
+public enum class BorderRadiusProp {
+  BORDER_RADIUS,
+  BORDER_TOP_LEFT_RADIUS,
+  BORDER_TOP_RIGHT_RADIUS,
+  BORDER_BOTTOM_RIGHT_RADIUS,
+  BORDER_BOTTOM_LEFT_RADIUS,
+  BORDER_TOP_START_RADIUS,
+  BORDER_TOP_END_RADIUS,
+  BORDER_BOTTOM_START_RADIUS,
+  BORDER_BOTTOM_END_RADIUS,
+  BORDER_END_END_RADIUS,
+  BORDER_END_START_RADIUS,
+  BORDER_START_END_RADIUS,
+  BORDER_START_START_RADIUS,
+}
+
+/** Represents all logical properties and shorthands for border radius. */
+public data class BorderRadiusStyle(
+    var uniform: LengthPercentage? = null,
+    var topLeft: LengthPercentage? = null,
+    var topRight: LengthPercentage? = null,
+    var bottomLeft: LengthPercentage? = null,
+    var bottomRight: LengthPercentage? = null,
+    var topStart: LengthPercentage? = null,
+    var topEnd: LengthPercentage? = null,
+    var bottomStart: LengthPercentage? = null,
+    var bottomEnd: LengthPercentage? = null,
+    var startStart: LengthPercentage? = null,
+    var startEnd: LengthPercentage? = null,
+    var endStart: LengthPercentage? = null,
+    var endEnd: LengthPercentage? = null
+) {
+  public constructor(properties: List<Pair<BorderRadiusProp, LengthPercentage>>) : this() {
+    properties.forEach { (k, v) -> set(k, v) }
+  }
+
+  public fun set(property: BorderRadiusProp, value: LengthPercentage?) {
+    when (property) {
+      BorderRadiusProp.BORDER_RADIUS -> uniform = value
+      BorderRadiusProp.BORDER_TOP_LEFT_RADIUS -> topLeft = value
+      BorderRadiusProp.BORDER_TOP_RIGHT_RADIUS -> topRight = value
+      BorderRadiusProp.BORDER_BOTTOM_LEFT_RADIUS -> bottomLeft = value
+      BorderRadiusProp.BORDER_BOTTOM_RIGHT_RADIUS -> bottomRight = value
+      BorderRadiusProp.BORDER_TOP_START_RADIUS -> topStart = value
+      BorderRadiusProp.BORDER_TOP_END_RADIUS -> topEnd = value
+      BorderRadiusProp.BORDER_BOTTOM_START_RADIUS -> bottomStart = value
+      BorderRadiusProp.BORDER_BOTTOM_END_RADIUS -> bottomEnd = value
+      BorderRadiusProp.BORDER_START_START_RADIUS -> startStart = value
+      BorderRadiusProp.BORDER_START_END_RADIUS -> startEnd = value
+      BorderRadiusProp.BORDER_END_START_RADIUS -> endStart = value
+      BorderRadiusProp.BORDER_END_END_RADIUS -> endEnd = value
+    }
+  }
+
+  public fun get(property: BorderRadiusProp): LengthPercentage? {
+    return when (property) {
+      BorderRadiusProp.BORDER_RADIUS -> uniform
+      BorderRadiusProp.BORDER_TOP_LEFT_RADIUS -> topLeft
+      BorderRadiusProp.BORDER_TOP_RIGHT_RADIUS -> topRight
+      BorderRadiusProp.BORDER_BOTTOM_LEFT_RADIUS -> bottomLeft
+      BorderRadiusProp.BORDER_BOTTOM_RIGHT_RADIUS -> bottomRight
+      BorderRadiusProp.BORDER_TOP_START_RADIUS -> topStart
+      BorderRadiusProp.BORDER_TOP_END_RADIUS -> topEnd
+      BorderRadiusProp.BORDER_BOTTOM_START_RADIUS -> bottomStart
+      BorderRadiusProp.BORDER_BOTTOM_END_RADIUS -> bottomEnd
+      BorderRadiusProp.BORDER_START_START_RADIUS -> startStart
+      BorderRadiusProp.BORDER_START_END_RADIUS -> startEnd
+      BorderRadiusProp.BORDER_END_START_RADIUS -> endStart
+      BorderRadiusProp.BORDER_END_END_RADIUS -> endEnd
+    }
+  }
+
+  public fun hasRoundedBorders(): Boolean {
+    return uniform != null ||
+        topLeft != null ||
+        topRight != null ||
+        bottomLeft != null ||
+        bottomRight != null ||
+        topStart != null ||
+        topEnd != null ||
+        bottomStart != null ||
+        bottomEnd != null ||
+        startStart != null ||
+        startEnd != null ||
+        endStart != null ||
+        endEnd != null
+  }
+
+  public fun resolve(
+      layoutDirection: Int,
+      context: Context,
+      width: Float,
+      height: Float,
+  ): ComputedBorderRadius {
+    return when (layoutDirection) {
+      LayoutDirection.LTR ->
+          ComputedBorderRadius(
+              topLeft =
+                  (startStart ?: topStart ?: topLeft ?: uniform)?.resolve(width, height) ?: 0f,
+              topRight = (endStart ?: topEnd ?: topRight ?: uniform)?.resolve(width, height) ?: 0f,
+              bottomLeft =
+                  (startEnd ?: bottomStart ?: bottomLeft ?: uniform)?.resolve(width, height) ?: 0f,
+              bottomRight =
+                  (endEnd ?: bottomEnd ?: bottomRight ?: uniform)?.resolve(width, height) ?: 0f,
+          )
+      LayoutDirection.RTL ->
+          if (I18nUtil.instance.doLeftAndRightSwapInRTL(context)) {
+            ComputedBorderRadius(
+                topLeft = (endStart ?: topEnd ?: topRight ?: uniform)?.resolve(width, height) ?: 0f,
+                topRight =
+                    (startStart ?: topStart ?: topLeft ?: uniform)?.resolve(width, height) ?: 0f,
+                bottomLeft =
+                    (endEnd ?: bottomStart ?: bottomRight ?: uniform)?.resolve(width, height) ?: 0f,
+                bottomRight =
+                    (startEnd ?: bottomEnd ?: bottomLeft ?: uniform)?.resolve(width, height) ?: 0f,
+            )
+          } else {
+            ComputedBorderRadius(
+                topLeft = (endStart ?: topEnd ?: topLeft ?: uniform)?.resolve(width, height) ?: 0f,
+                topRight =
+                    (startStart ?: topStart ?: topRight ?: uniform)?.resolve(width, height) ?: 0f,
+                bottomLeft =
+                    (endEnd ?: bottomStart ?: bottomLeft ?: uniform)?.resolve(width, height) ?: 0f,
+                bottomRight =
+                    (startEnd ?: bottomEnd ?: bottomRight ?: uniform)?.resolve(width, height) ?: 0f,
+            )
+          }
+      else -> throw IllegalArgumentException("Expected?.resolved layout direction")
+    }
+  }
+}

package/ReactAndroid/src/main/java/com/facebook/react/uimanager/style/ComputedBorderRadius.kt

@@ -0,0 +1,22 @@
+/*
+ * 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.
+ */
+
+package com.facebook.react.uimanager.style
+
+/** Phsysical edge lengths (in DIPs) for a border-radius. */
+public data class ComputedBorderRadius(
+    val topLeft: Float,
+    val topRight: Float,
+    val bottomLeft: Float,
+    val bottomRight: Float,
+) {
+  public fun hasRoundedBorders(): Boolean {
+    return topLeft > 0f || topRight > 0f || bottomLeft > 0f || bottomRight > 0f
+  }
+
+  public constructor() : this(0f, 0f, 0f, 0f)
+}

package/ReactAndroid/src/main/java/com/facebook/react/util/ExceptionDataHelper.kt

@@ -0,0 +1,36 @@
+/*
+ * 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.
+ */
+
+package com.facebook.react.util
+
+import android.util.JsonWriter
+import com.facebook.react.bridge.JsonWriterHelper
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.ReadableType
+import java.io.IOException
+import java.io.StringWriter
+
+public object ExceptionDataHelper {
+
+  public const val EXTRA_DATA_FIELD: String = "extraData"
+
+  @JvmStatic
+  public fun getExtraDataAsJson(metadata: ReadableMap?): String? {
+    if (metadata == null || metadata.getType(EXTRA_DATA_FIELD) == ReadableType.Null) {
+      return null
+    }
+    try {
+      val extraDataWriter = StringWriter()
+      val json = JsonWriter(extraDataWriter)
+      JsonWriterHelper.value(json, metadata.getDynamic(EXTRA_DATA_FIELD))
+      json.close()
+      extraDataWriter.close()
+      return extraDataWriter.toString()
+    } catch (ex: IOException) {}
+    return null
+  }
+}

package/ReactAndroid/src/main/java/com/facebook/react/util/JSStackTrace.kt

@@ -0,0 +1,67 @@
+/*
+ * 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.
+ */
+
+package com.facebook.react.util
+
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.ReadableType
+import java.util.regex.Pattern
+
+public object JSStackTrace {
+
+  public const val LINE_NUMBER_KEY: String = "lineNumber"
+  public const val FILE_KEY: String = "file"
+  public const val COLUMN_KEY: String = "column"
+  public const val METHOD_NAME_KEY: String = "methodName"
+  private val FILE_ID_PATTERN = Pattern.compile("\\b((?:seg-\\d+(?:_\\d+)?|\\d+)\\.js)")
+
+  @JvmStatic
+  public fun format(message: String, stack: ReadableArray): String {
+    val stringBuilder = StringBuilder(message).append(", stack:\n")
+    for (i in 0 until stack.size()) {
+      val frame = stack.getMap(i)
+      stringBuilder.append(frame.getString(METHOD_NAME_KEY)).append("@").append(parseFileId(frame))
+      if (frame.hasKey(LINE_NUMBER_KEY) &&
+          !frame.isNull(LINE_NUMBER_KEY) &&
+          frame.getType(LINE_NUMBER_KEY) == ReadableType.Number) {
+        stringBuilder.append(frame.getInt(LINE_NUMBER_KEY))
+      } else {
+        stringBuilder.append(-1)
+      }
+      if (frame.hasKey(COLUMN_KEY) &&
+          !frame.isNull(COLUMN_KEY) &&
+          frame.getType(COLUMN_KEY) == ReadableType.Number) {
+        stringBuilder.append(":").append(frame.getInt(COLUMN_KEY))
+      }
+      stringBuilder.append("\n")
+    }
+    return stringBuilder.toString()
+  }
+
+  // Besides a regular bundle (e.g. "bundle.js"), a stack frame can be produced by:
+  // 1) "random access bundle (RAM)", e.g. "1.js", where "1" is a module name
+  // 2) "segment file", e.g. "seg-1.js", where "1" is a segment name
+  // 3) "RAM segment file", e.g. "seg-1_2.js", where "1" is a segment name and "2" is a module name
+  // We are using a special source map format for such cases, so that we could symbolicate
+  // stack traces with a single source map file.
+  // NOTE: The ".js" suffix is kept to avoid ambiguities between "module-id:line" and "line:column".
+  private fun parseFileId(frame: ReadableMap): String {
+    if (frame.hasKey(FILE_KEY) &&
+        !frame.isNull(FILE_KEY) &&
+        frame.getType(FILE_KEY) == ReadableType.String) {
+      val file = frame.getString(FILE_KEY)
+      if (file != null) {
+        val matcher = FILE_ID_PATTERN.matcher(file)
+        if (matcher.find()) {
+          return "${matcher.group(1)}:"
+        }
+      }
+    }
+    return ""
+  }
+}

package/ReactAndroid/src/main/java/com/facebook/react/util/RCTLog.kt

@@ -0,0 +1,25 @@
+/*
+ * 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.
+ */
+
+package com.facebook.react.util
+
+import com.facebook.react.bridge.JavaScriptModule
+
+/**
+ * JS module interface for RCTLog
+ *
+ * The RCTLog module allows for showing native logs in JavaScript.
+ */
+public interface RCTLog : JavaScriptModule {
+  /**
+   * Send a log to JavaScript.
+   *
+   * @param level The level of the log.
+   * @param message The message to log.
+   */
+  public fun logIfNoNativeHook(level: String?, message: String?)
+}

package/ReactAndroid/src/main/java/com/facebook/react/util/RNLog.kt

@@ -0,0 +1,108 @@
+/*
+ * 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.
+ */
+
+package com.facebook.react.util
+
+import android.util.Log
+import com.facebook.common.logging.FLog
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.common.ReactConstants
+
+/** Logging wrapper for FLog with LogBox support. */
+public object RNLog {
+
+  public const val MINIMUM_LEVEL_FOR_UI: Int = Log.WARN
+  public const val LOG: Int = Log.VERBOSE
+  public const val TRACE: Int = Log.DEBUG
+  public const val ADVICE: Int = Log.INFO
+  public const val WARN: Int = Log.WARN
+  public const val ERROR: Int = Log.ERROR
+
+  /**
+   * Log a log level message tagged as React Native to the console.
+   *
+   * @param message The message to log.
+   */
+  @JvmStatic
+  public fun l(message: String) {
+    FLog.i(ReactConstants.TAG, message)
+  }
+
+  /**
+   * Log a trace level message tagged as React Native to the console.
+   *
+   * @param message The message to log.
+   */
+  @JvmStatic
+  public fun t(message: String) {
+    FLog.i(ReactConstants.TAG, message)
+  }
+
+  /**
+   * Log a warning level message tagged as React Native to the console. This warning will not be
+   * shown in LogBox.
+   *
+   * @param message The message to log.
+   */
+  @JvmStatic
+  public fun a(message: String) {
+    FLog.w(ReactConstants.TAG, "(ADVICE)$message")
+  }
+
+  /**
+   * Log a warning level message tagged as React Native to the console and display in the app.
+   *
+   * @param context The React context of the application use to display the warning.
+   * @param message The message to log.
+   */
+  @JvmStatic
+  public fun w(context: ReactContext?, message: String) {
+    logInternal(context, message, WARN)
+    FLog.w(ReactConstants.TAG, message)
+  }
+
+  /**
+   * Log an error level message tagged as React Native to the console and display in the app.
+   *
+   * @param context The React context of the application use to display the error.
+   * @param message The message to log.
+   */
+  @JvmStatic
+  public fun e(context: ReactContext?, message: String) {
+    logInternal(context, message, ERROR)
+    FLog.e(ReactConstants.TAG, message)
+  }
+
+  /**
+   * Log an error level message tagged as React Native to the console. This error will not be shown
+   * in LogBox.
+   *
+   * @param message The message to log.
+   */
+  @JvmStatic
+  public fun e(message: String) {
+    FLog.e(ReactConstants.TAG, message)
+  }
+
+  private fun logInternal(context: ReactContext?, message: String?, level: Int) {
+    if (level >= MINIMUM_LEVEL_FOR_UI) {
+      if (context?.hasActiveReactInstance() == true && message != null) {
+        context.getJSModule(RCTLog::class.java).logIfNoNativeHook(levelToString(level), message)
+      }
+    }
+  }
+
+  private fun levelToString(level: Int): String =
+      when (level) {
+        LOG,
+        TRACE -> "log"
+        ADVICE,
+        WARN -> "warn"
+        ERROR -> "error"
+        else -> "none"
+      }
+}

package/ReactAndroid/src/main/java/com/facebook/react/views/common/ContextUtils.kt

@@ -0,0 +1,43 @@
+/*
+ * 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.
+ */
+
+package com.facebook.react.views.common
+
+import android.content.Context
+import android.content.ContextWrapper
+
+/**
+ * Class containing static methods involving manipulations of Contexts and their related subclasses.
+ */
+public object ContextUtils {
+
+  /**
+   * Returns the nearest context in the chain (as defined by ContextWrapper.getBaseContext()) which
+   * is an instance of the specified type, or null if one could not be found
+   *
+   * @param context Initial context
+   * @param clazz Class instance to look for
+   * @return the first context which is an instance of the specified class, or null if none exists
+   */
+  @JvmStatic
+  public fun <T> findContextOfType(context: Context?, clazz: Class<out T>): T? {
+    var currentContext = context
+    while (!clazz.isInstance(currentContext)) {
+      if (currentContext is ContextWrapper) {
+        val baseContext = currentContext.baseContext
+        if (currentContext === baseContext) {
+          return null
+        } else {
+          currentContext = baseContext
+        }
+      } else {
+        return null
+      }
+    }
+    @Suppress("UNCHECKED_CAST") return currentContext as T?
+  }
+}

package/ReactAndroid/src/main/java/com/facebook/react/views/common/ViewUtils.kt

@@ -0,0 +1,24 @@
+/*
+ * 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.
+ */
+
+package com.facebook.react.views.common
+
+import android.view.View
+import com.facebook.react.R
+
+/** Class containing static methods involving manipulations of Views */
+public object ViewUtils {
+
+  /**
+   * Returns value of testId for the given view, if present
+   *
+   * @param view View to get the testId value for
+   * @return the value of testId if defined for the view, otherwise null
+   */
+  @JvmStatic
+  public fun getTestId(view: View?): String? = view?.getTag(R.id.react_test_id) as? String
+}

package/ReactAndroid/src/main/java/com/facebook/react/views/debuggingoverlay/DebuggingOverlay.kt

@@ -0,0 +1,86 @@
+/*
+ * 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.
+ */
+
+package com.facebook.react.views.debuggingoverlay
+
+import android.content.Context
+import android.graphics.Canvas
+import android.graphics.Paint
+import android.graphics.RectF
+import android.view.View
+import androidx.annotation.UiThread
+import com.facebook.react.bridge.UiThreadUtil
+
+public class DebuggingOverlay(context: Context) : View(context) {
+  private val traceUpdatePaint = Paint()
+  private val traceUpdatesToDisplayMap = hashMapOf<Int, TraceUpdate>()
+  private val traceUpdateIdToCleanupRunnableMap = hashMapOf<Int, Runnable>()
+
+  private val highlightedElementsPaint = Paint()
+  private var highlightedElementsRectangles = mutableListOf<RectF>()
+
+  init {
+    traceUpdatePaint.style = Paint.Style.STROKE
+    traceUpdatePaint.strokeWidth = 6f
+    highlightedElementsPaint.style = Paint.Style.FILL
+    highlightedElementsPaint.color = 0xCCC8E6FF.toInt()
+  }
+
+  @UiThread
+  public fun setTraceUpdates(traceUpdates: List<TraceUpdate>) {
+    for (traceUpdate in traceUpdates) {
+      val traceUpdateId = traceUpdate.id
+      if (traceUpdateIdToCleanupRunnableMap.containsKey(traceUpdateId)) {
+        UiThreadUtil.removeOnUiThread(traceUpdateIdToCleanupRunnableMap[traceUpdateId])
+        traceUpdateIdToCleanupRunnableMap.remove(traceUpdateId)
+      }
+
+      traceUpdatesToDisplayMap[traceUpdateId] = traceUpdate
+    }
+
+    invalidate()
+  }
+
+  @UiThread
+  public fun setHighlightedElementsRectangles(elementsRectangles: MutableList<RectF>) {
+    highlightedElementsRectangles = elementsRectangles
+    invalidate()
+  }
+
+  @UiThread
+  public fun clearElementsHighlights() {
+    highlightedElementsRectangles.clear()
+    invalidate()
+  }
+
+  public override fun onDraw(canvas: Canvas) {
+    super.onDraw(canvas)
+
+    // Draw border outside of the given overlays to be aligned with web trace highlights
+    for (traceUpdate in traceUpdatesToDisplayMap.values) {
+      traceUpdatePaint.color = traceUpdate.color
+      canvas.drawRect(traceUpdate.rectangle, traceUpdatePaint)
+
+      val traceUpdateId = traceUpdate.id
+      val block = Runnable {
+        traceUpdatesToDisplayMap.remove(traceUpdateId)
+        traceUpdateIdToCleanupRunnableMap.remove(traceUpdateId)
+
+        invalidate()
+      }
+
+      if (!traceUpdateIdToCleanupRunnableMap.containsKey(traceUpdateId)) {
+        traceUpdateIdToCleanupRunnableMap[traceUpdateId] = block
+        UiThreadUtil.runOnUiThread(block, 2000)
+      }
+    }
+
+    for (elementRectangle in highlightedElementsRectangles) {
+      canvas.drawRect(elementRectangle, highlightedElementsPaint)
+    }
+  }
+}