@datadog/mobile-react-native-session-replay 2.6.0 → 2.6.2

package/android/src/test/kotlin/com/datadog/reactnative/sessionreplay/{ReactTextPropertiesResolverTest.kt → utils/text/TextViewUtilsTest.kt}

@@ -4,20 +4,30 @@
  * Copyright 2016-Present Datadog, Inc.
  */
 
-package com.datadog.reactnative.sessionreplay
+package com.datadog.reactnative.sessionreplay.utils.text
 
+import android.content.res.Resources
+import android.graphics.Typeface
+import android.text.Spannable
+import android.text.style.ForegroundColorSpan
+import android.util.DisplayMetrics
 import android.widget.TextView
+import com.datadog.android.api.InternalLogger
 import com.datadog.android.sessionreplay.model.MobileSegment
-import com.datadog.reactnative.sessionreplay.ReactTextPropertiesResolver.Companion.COLOR_FIELD_NAME
-import com.datadog.reactnative.sessionreplay.ReactTextPropertiesResolver.Companion.FONT_FAMILY_FIELD_NAME
-import com.datadog.reactnative.sessionreplay.ReactTextPropertiesResolver.Companion.IS_COLOR_SET_FIELD_NAME
-import com.datadog.reactnative.sessionreplay.ReactTextPropertiesResolver.Companion.MONOSPACE_FAMILY_NAME
-import com.datadog.reactnative.sessionreplay.ReactTextPropertiesResolver.Companion.TEXT_ATTRIBUTES_FIELD_NAME
+import com.datadog.android.sessionreplay.recorder.MappingContext
+import com.datadog.android.sessionreplay.recorder.SystemInformation
+import com.datadog.reactnative.sessionreplay.ShadowNodeWrapper
 import com.datadog.reactnative.sessionreplay.ShadowNodeWrapper.Companion.UI_IMPLEMENTATION_FIELD_NAME
 import com.datadog.reactnative.sessionreplay.utils.DrawableUtils
 import com.datadog.reactnative.sessionreplay.utils.ReflectionUtils
 import com.datadog.reactnative.sessionreplay.utils.formatAsRgba
+import com.datadog.reactnative.sessionreplay.utils.text.TextViewUtils.Companion.COLOR_FIELD_NAME
+import com.datadog.reactnative.sessionreplay.utils.text.TextViewUtils.Companion.FONT_FAMILY_FIELD_NAME
+import com.datadog.reactnative.sessionreplay.utils.text.TextViewUtils.Companion.IS_COLOR_SET_FIELD_NAME
+import com.datadog.reactnative.sessionreplay.utils.text.TextViewUtils.Companion.MONOSPACE_FAMILY_NAME
+import com.datadog.reactnative.sessionreplay.utils.text.TextViewUtils.Companion.TEXT_ATTRIBUTES_FIELD_NAME
 import com.datadog.reactnative.tools.unit.forge.ForgeConfigurator
+import com.facebook.react.bridge.NativeModule
 import com.facebook.react.bridge.ReactContext
 import com.facebook.react.uimanager.ReactShadowNode
 import com.facebook.react.uimanager.UIImplementation
@@ -34,7 +44,11 @@ import org.junit.jupiter.api.BeforeEach
 import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.extension.ExtendWith
 import org.junit.jupiter.api.extension.Extensions
+import org.mockito.ArgumentMatchers.anyInt
 import org.mockito.Mock
+import org.mockito.Mockito.doReturn
+import org.mockito.Mockito.mock
+import org.mockito.Mockito.spy
 import org.mockito.junit.jupiter.MockitoExtension
 import org.mockito.junit.jupiter.MockitoSettings
 import org.mockito.kotlin.any
@@ -48,9 +62,7 @@ import org.mockito.quality.Strictness
 )
 @MockitoSettings(strictness = Strictness.LENIENT)
 @ForgeConfiguration(ForgeConfigurator::class)
-internal class ReactTextPropertiesResolverTest {
-    private lateinit var testedResolver: ReactTextPropertiesResolver
-
+internal class TextViewUtilsTest {
     @Mock
     lateinit var mockReactContext: ReactContext
 
@@ -84,10 +96,44 @@ internal class ReactTextPropertiesResolverTest {
     @Mock
     private lateinit var mockShadowNode: ReactShadowNode<out ReactShadowNode<*>>
 
+    @Mock
+    private lateinit var mockLogger: InternalLogger
+
+    @Mock
+    private lateinit var mockMappingContext: MappingContext
+
+    @Mock
+    private lateinit var mockSystemInformation: SystemInformation
+
+    @Mock
+    private lateinit var mockResources: Resources
+
+    @Mock
+    private lateinit var mockDisplayMetrics: DisplayMetrics
+
+    @Mock
+    private lateinit var testedUtils: LegacyTextViewUtils
+
+    @Mock
+    private lateinit var fabricTestedUtils: FabricTextViewUtils
+
     @BeforeEach
     fun `set up`(forge: Forge) {
+        whenever(mockResources.displayMetrics).thenReturn(mockDisplayMetrics)
+        whenever(mockTextView.resources).thenReturn(mockResources)
+        whenever(mockSystemInformation.screenDensity).thenReturn(0f)
+        whenever(mockMappingContext.systemInformation).thenReturn(mockSystemInformation)
+        whenever(mockTextView.text).thenReturn(forge.aString())
+        whenever(mockTextView.typeface).thenReturn(Typeface.SANS_SERIF)
+
+        whenever(mockReactContext.getNativeModule(UIManagerModule::class.java))
+            .thenReturn(mockUiManagerModule)
+
         whenever(
-            mockReflectionUtils.getDeclaredField(mockUiManagerModule, UI_IMPLEMENTATION_FIELD_NAME)
+            mockReflectionUtils.getDeclaredField(
+                eq(mockUiManagerModule),
+                eq(UI_IMPLEMENTATION_FIELD_NAME)
+            )
         ).thenReturn(mockUiImplementation)
 
         whenever(
@@ -101,12 +147,64 @@ internal class ReactTextPropertiesResolverTest {
         }
         whenever(mockReactContext.hasActiveReactInstance()).thenReturn(true)
 
-        testedResolver = ReactTextPropertiesResolver(
-            reactContext = mockReactContext,
-            uiManagerModule = mockUiManagerModule,
-            drawableUtils = mockDrawableUtils,
-            reflectionUtils = mockReflectionUtils
-        )
+        val realUtils =
+            LegacyTextViewUtils(
+                mockReactContext,
+                mockLogger,
+                mockReflectionUtils,
+                mockDrawableUtils
+            )
+
+        val realFabricUtils =
+            FabricTextViewUtils(
+                mockReactContext,
+                mockLogger,
+                mockDrawableUtils
+            )
+
+        testedUtils = spy(realUtils)
+        fabricTestedUtils = spy(realFabricUtils)
+    }
+
+    @Test
+    fun `M return wireframe W map() { even if not TextWireframeType }`(
+        @Mock mockImageWireframe: MobileSegment.Wireframe.ImageWireframe
+    ) {
+        // When
+        val result =
+            testedUtils.mapTextViewToWireframes(
+                wireframes = listOf(mockImageWireframe),
+                view = mockTextView,
+                mappingContext = mockMappingContext
+            )
+
+        // Then
+        assertThat(result).contains(mockImageWireframe)
+    }
+
+    @Test
+    fun `M return textWireframe W map()`(
+        @Mock mockTextWireframe: MobileSegment.Wireframe.TextWireframe
+    ) {
+        // Given
+        doReturn(mockTextWireframe)
+            .whenever(testedUtils)
+            .addReactNativeProperties(
+                originalWireframe = eq(mockTextWireframe),
+                view = eq(mockTextView),
+                pixelDensity = eq(0f)
+            )
+
+        // When
+        val result =
+            testedUtils.mapTextViewToWireframes(
+                wireframes = listOf(mockTextWireframe),
+                view = mockTextView,
+                mappingContext = mockMappingContext
+            )[0] as MobileSegment.Wireframe.TextWireframe
+
+        // Then
+        assertThat(result).isEqualTo(mockTextWireframe)
     }
 
     // region addReactNativeProperties
@@ -118,16 +216,15 @@ internal class ReactTextPropertiesResolverTest {
         whenever(mockUiImplementation.resolveShadowNode(any())).thenReturn(null)
 
         // When
-        val result = testedResolver.addReactNativeProperties(mockWireframe, mockTextView, 0f)
+        val result = testedUtils.addReactNativeProperties(mockWireframe, mockTextView, 0f)
 
         // Then
         assertThat(result).isEqualTo(mockWireframe)
     }
 
     @Test
-    fun `M add drawable properties W addReactNativeProperties() { has reactBackgroundDrawable }`(
-        forge: Forge
-    ) {
+    fun `M add drawable properties W addReactNativeProperties() { has reactBackgroundDrawable }`
+    (forge: Forge) {
         // Given
         val pixelDensity = 0f
         val fakeBorderRadius = forge.aPositiveFloat()
@@ -150,18 +247,20 @@ internal class ReactTextPropertiesResolverTest {
                 backgroundColor = formatAsRgba(fakeBorderColor),
                 opacity = 0f,
                 cornerRadius = fakeBorderRadius.toLong()
-            ) to MobileSegment.ShapeBorder(
-                color = formatAsRgba(fakeBorderColor),
-                width = fakeBorderWidth.toLong()
-            )
+            ) to
+                MobileSegment.ShapeBorder(
+                    color = formatAsRgba(fakeBorderColor),
+                    width = fakeBorderWidth.toLong()
+                )
         )
 
         // When
-        val result = testedResolver.addReactNativeProperties(
-            fakeWireframe,
-            mockTextView,
-            pixelDensity
-        )
+        val result =
+            testedUtils.addReactNativeProperties(
+                fakeWireframe,
+                mockTextView,
+                pixelDensity
+            )
 
         // Then
         assertThat(result.shapeStyle?.cornerRadius).isEqualTo(fakeBorderRadius.toLong())
@@ -178,8 +277,9 @@ internal class ReactTextPropertiesResolverTest {
         whenever(mockTextView.background).thenReturn(null)
 
         // When
-        val result = testedResolver
-            .addReactNativeProperties(fakeWireframe, mockTextView, 0f)
+        val result =
+            testedUtils
+                .addReactNativeProperties(fakeWireframe, mockTextView, 0f)
 
         // Then
         assertThat(result.textStyle.family)
@@ -194,7 +294,7 @@ internal class ReactTextPropertiesResolverTest {
             .thenReturn(null)
 
         // When
-        val result = testedResolver.addReactNativeProperties(fakeWireframe, mockTextView, 0f)
+        val result = testedUtils.addReactNativeProperties(fakeWireframe, mockTextView, 0f)
 
         // Then
         assertThat(result.textStyle.family).isEqualTo(fakeWireframe.textStyle.family)
@@ -212,7 +312,7 @@ internal class ReactTextPropertiesResolverTest {
         whenever(mockTextAttributes.effectiveFontSize).thenReturn(fakeTextSize)
 
         // When
-        val result = testedResolver.addReactNativeProperties(fakeWireframe, mockTextView, 0f)
+        val result = testedUtils.addReactNativeProperties(fakeWireframe, mockTextView, 0f)
 
         // Then
         assertThat(result.textStyle.size).isEqualTo(fakeTextSize.toLong())
@@ -228,7 +328,7 @@ internal class ReactTextPropertiesResolverTest {
             .thenReturn(null)
 
         // When
-        val result = testedResolver.addReactNativeProperties(fakeWireframe, mockTextView, 0f)
+        val result = testedUtils.addReactNativeProperties(fakeWireframe, mockTextView, 0f)
 
         // Then
         assertThat(result.textStyle.size).isEqualTo(fakeWireframe.textStyle.size)
@@ -246,7 +346,7 @@ internal class ReactTextPropertiesResolverTest {
             .thenReturn(fakeTextColor)
 
         // When
-        val result = testedResolver.addReactNativeProperties(fakeWireframe, mockTextView, 0f)
+        val result = testedUtils.addReactNativeProperties(fakeWireframe, mockTextView, 0f)
 
         // Then
         assertThat(result.textStyle.color).isEqualTo(formatAsRgba(fakeTextColor))
@@ -264,7 +364,7 @@ internal class ReactTextPropertiesResolverTest {
             .thenReturn(fakeTextColor)
 
         // When
-        val result = testedResolver.addReactNativeProperties(fakeWireframe, mockTextView, 0f)
+        val result = testedUtils.addReactNativeProperties(fakeWireframe, mockTextView, 0f)
 
         // Then
         assertThat(result.textStyle.color).isEqualTo("#000000FF")
@@ -280,7 +380,7 @@ internal class ReactTextPropertiesResolverTest {
             .thenReturn(null)
 
         // When
-        val result = testedResolver.addReactNativeProperties(fakeWireframe, mockTextView, 0f)
+        val result = testedUtils.addReactNativeProperties(fakeWireframe, mockTextView, 0f)
 
         // Then
         assertThat(result.textStyle.color).isEqualTo(fakeWireframe.textStyle.color)
@@ -294,11 +394,44 @@ internal class ReactTextPropertiesResolverTest {
             .thenReturn(MONOSPACE_FAMILY_NAME)
 
         // When
-        val result = testedResolver.addReactNativeProperties(fakeWireframe, mockTextView, 0f)
+        val result = testedUtils.addReactNativeProperties(fakeWireframe, mockTextView, 0f)
 
         // Then
         assertThat(result.textStyle.family).isNotEqualTo(MONOSPACE_FAMILY_NAME)
     }
 
+    @Test
+    fun `M return fabric textStyle (color) W addReactNativeProperties`() {
+        val mockForegroundColorSpan = mock(ForegroundColorSpan::class.java)
+        whenever(mockForegroundColorSpan.foregroundColor).thenReturn(-1)
+
+        val spannable = mock(Spannable::class.java)
+        doReturn(spannable).whenever(fabricTestedUtils).getFieldFromView(any(), any())
+
+        whenever(spannable.getSpans(anyInt(), anyInt(), eq(ForegroundColorSpan::class.java)))
+            .thenReturn(
+                arrayOf(mockForegroundColorSpan)
+            )
+
+        val result = fabricTestedUtils.addReactNativeProperties(fakeWireframe, mockTextView, 0f)
+        assertThat(result.textStyle.color).isEqualTo("#ffffffff")
+    }
+
+    // endregion
+
+    // region getUiManagerModule
+    @Test
+    fun `M return null W getUiManagerModule() { cannot get uiManagerModule }`() {
+        // Given
+        whenever(mockReactContext.getNativeModule(any<Class<NativeModule>>()))
+            .thenThrow(IllegalStateException())
+
+        // When
+        val uiManagerModule = testedUtils.getUiManagerModule()
+
+        // Then
+        assertThat(uiManagerModule).isNull()
+    }
+
     // endregion
 }

package/ios/Sources/DdSessionReplay.mm

@@ -38,12 +38,12 @@ RCT_REMAP_METHOD(enable, withEnableReplaySampleRate:(double)replaySampleRate
 
 RCT_EXPORT_METHOD(startRecording:(RCTPromiseResolveBlock)resolve withRejecter:(RCTPromiseRejectBlock)reject)
 {
-    [self startRecordingWithResolver:resolve reject:reject];
+    [self startRecording:resolve reject:reject];
 }
 
 RCT_EXPORT_METHOD(stopRecording:(RCTPromiseResolveBlock)resolve withRejecter:(RCTPromiseRejectBlock)reject)
 {
-    [self stopRecordingWithResolver:resolve reject:reject];
+    [self stopRecording:resolve reject:reject];
 }
 
 // Thanks to this guard, we won't compile this code when we build for the old architecture.
@@ -85,11 +85,11 @@ RCT_EXPORT_METHOD(stopRecording:(RCTPromiseResolveBlock)resolve withRejecter:(RC
                                                             reject:reject];
 }
 
-- (void)startRecordingWithResolver:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject {
+- (void)startRecording:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject {
     [self.ddSessionReplayImplementation startRecordingWithResolve:resolve reject:reject];
 }
 
-- (void)stopRecordingWithResolver:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject {
+- (void)stopRecording:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject {
     [self.ddSessionReplayImplementation stopRecordingWithResolve:resolve reject:reject];
 }
 

package/ios/Sources/DdSessionReplayImplementation.swift

@@ -15,17 +15,24 @@ public class DdSessionReplayImplementation: NSObject {
     private lazy var sessionReplay: SessionReplayProtocol = sessionReplayProvider()
     private let sessionReplayProvider: () -> SessionReplayProtocol
     private let uiManager: RCTUIManager
+    private let fabricWrapper: RCTFabricWrapper
     
-    internal init(sessionReplayProvider: @escaping () -> SessionReplayProtocol, uiManager: RCTUIManager) {
+    internal init(
+        sessionReplayProvider: @escaping () -> SessionReplayProtocol,
+        uiManager: RCTUIManager,
+        fabricWrapper: RCTFabricWrapper
+    ) {
         self.sessionReplayProvider = sessionReplayProvider
         self.uiManager = uiManager
+        self.fabricWrapper = fabricWrapper
     }
 
     @objc
     public convenience init(bridge: RCTBridge) {
         self.init(
             sessionReplayProvider: { NativeSessionReplay() },
-            uiManager: bridge.uiManager
+            uiManager: bridge.uiManager,
+            fabricWrapper: RCTFabricWrapper()
         )
     }
 
@@ -44,6 +51,7 @@ public class DdSessionReplayImplementation: NSObject {
         if (customEndpoint != "") {
             customEndpointURL = URL(string: "\(customEndpoint)/api/v2/replay" as String)
         }
+
         var sessionReplayConfiguration = SessionReplay.Configuration(
             replaySampleRate: Float(replaySampleRate),
             textAndInputPrivacyLevel: convertTextAndInputPrivacy(textAndInputPrivacyLevel),
@@ -53,7 +61,9 @@ public class DdSessionReplayImplementation: NSObject {
             customEndpoint: customEndpointURL
         )
                     
-        sessionReplayConfiguration.setAdditionalNodeRecorders([RCTTextViewRecorder(uiManager: self.uiManager)])
+        sessionReplayConfiguration.setAdditionalNodeRecorders([
+            RCTTextViewRecorder(uiManager: uiManager, fabricWrapper: fabricWrapper)
+        ])
 
         if let core = DatadogSDKWrapper.shared.getCoreInstance() {
             sessionReplay.enable(

package/ios/Sources/RCTFabricWrapper.h

@@ -0,0 +1,13 @@
+/*
+ * Unless explicitly stated otherwise all files in this repository are licensed under the Apache License Version 2.0.
+ * This product includes software developed at Datadog (https://www.datadoghq.com/).
+ * Copyright 2016-Present Datadog, Inc.
+ */
+#import <Foundation/Foundation.h>
+#import "RCTTextPropertiesWrapper.h"
+
+@interface RCTFabricWrapper : NSObject
+
+- (nullable RCTTextPropertiesWrapper*)tryToExtractTextPropertiesFromView:(UIView* _Nonnull)view;
+
+@end

package/ios/Sources/RCTFabricWrapper.mm

@@ -0,0 +1,120 @@
+/*
+ * Unless explicitly stated otherwise all files in this repository are licensed under the Apache License Version 2.0.
+ * This product includes software developed at Datadog (https://www.datadoghq.com/).
+ * Copyright 2016-Present Datadog, Inc.
+ */
+
+#import "RCTFabricWrapper.h"
+
+#if RCT_NEW_ARCH_ENABLED
+#import "RCTVersion.h"
+
+#import <React-RCTFabric/React/RCTParagraphComponentView.h>
+#import <React-RCTFabric/React/RCTConversions.h>
+
+#if RCT_VERSION_MINOR > 74
+#import <React-FabricComponents/react/renderer/components/text/ParagraphProps.h>
+#else
+#import <React-Fabric/react/renderer/components/text/ParagraphProps.h>
+#endif
+
+
+namespace rct = facebook::react;
+#endif
+
+@implementation RCTFabricWrapper
+/**
+ * Extracts the text properties from the given UIView when the view is of type RCTParagraphComponentView, returns nil otherwise.
+ */
+- (nullable RCTTextPropertiesWrapper*)tryToExtractTextPropertiesFromView:(UIView *)view {
+    #if RCT_NEW_ARCH_ENABLED
+    if (![view isKindOfClass:[RCTParagraphComponentView class]]) {
+        return nil;
+    }
+
+    // Cast view to RCTParagraphComponentView
+    RCTParagraphComponentView* paragraphComponentView = (RCTParagraphComponentView *)view;
+    if (paragraphComponentView == nil) {
+        return nil;
+    }
+
+    // Retrieve ParagraphProps from shared pointer
+    const rct::ParagraphProps* props = (rct::ParagraphProps*)paragraphComponentView.props.get();
+    if (props == nil) {
+        return nil;
+    }
+
+    // Extract Attributes
+    RCTTextPropertiesWrapper* textPropertiesWrapper = [[RCTTextPropertiesWrapper alloc] init];
+    textPropertiesWrapper.text = [RCTFabricWrapper getTextFromView:paragraphComponentView];
+    textPropertiesWrapper.contentRect = paragraphComponentView.bounds;
+
+    rct::TextAttributes textAttributes = props->textAttributes;
+    textPropertiesWrapper.alignment = [RCTFabricWrapper getAlignmentFromAttributes:textAttributes];
+    textPropertiesWrapper.foregroundColor = [RCTFabricWrapper getForegroundColorFromAttributes:textAttributes];
+    textPropertiesWrapper.fontSize = [RCTFabricWrapper getFontSizeFromAttributes:textAttributes];
+
+    return textPropertiesWrapper;
+    #else
+    return nil;
+    #endif
+}
+
+#if RCT_NEW_ARCH_ENABLED
++ (NSString* _Nonnull)getTextFromView:(RCTParagraphComponentView*)view {
+    if (view == nil || view.attributedText == nil) {
+        return RCTTextPropertiesDefaultText;
+    }
+
+    return view.attributedText.string;
+}
+
++ (NSTextAlignment)getAlignmentFromAttributes:(rct::TextAttributes)textAttributes {
+    const rct::TextAlignment alignment = textAttributes.alignment.has_value() ?
+        textAttributes.alignment.value() :
+        rct::TextAlignment::Natural;
+
+    switch (alignment) {
+        case rct::TextAlignment::Natural:
+            return NSTextAlignmentNatural;
+
+        case rct::TextAlignment::Left:
+            return NSTextAlignmentLeft;
+
+        case rct::TextAlignment::Center:
+            return NSTextAlignmentCenter;
+
+        case rct::TextAlignment::Right:
+            return NSTextAlignmentRight;
+
+        case rct::TextAlignment::Justified:
+            return NSTextAlignmentJustified;
+
+        default:
+            return RCTTextPropertiesDefaultAlignment;
+    }
+}
+
++ (UIColor* _Nonnull)getForegroundColorFromAttributes:(rct::TextAttributes)textAttributes {
+    @try {
+#if RCT_VERSION_MINOR > 73
+        rct::Color color = *textAttributes.foregroundColor;
+        UIColor* uiColor = (__bridge UIColor*)color.getUIColor().get();
+        if (uiColor != nil) {
+            return uiColor;
+        }
+#else
+        return RCTUIColorFromSharedColor(textAttributes.foregroundColor);
+#endif
+    } @catch (NSException *exception) {}
+
+    return RCTTextPropertiesDefaultForegroundColor;
+}
+
++ (CGFloat)getFontSizeFromAttributes:(rct::TextAttributes)textAttributes {
+    // Float is just an alias for CGFloat, but this could change in the future.
+    _Static_assert(sizeof(rct::Float) == sizeof(CGFloat), "Float and CGFloat are expected to have the same size.");
+    return isnan(textAttributes.fontSize) ? RCTTextPropertiesDefaultFontSize : (CGFloat)textAttributes.fontSize;
+}
+#endif
+@end

package/ios/Sources/RCTTextPropertiesWrapper.h

@@ -0,0 +1,23 @@
+/*
+ * Unless explicitly stated otherwise all files in this repository are licensed under the Apache License Version 2.0.
+ * This product includes software developed at Datadog (https://www.datadoghq.com/).
+ * Copyright 2016-Present Datadog, Inc.
+ */
+
+@interface RCTTextPropertiesWrapper : NSObject
+
+extern NSString* const RCTTextPropertiesDefaultText;
+extern NSTextAlignment const RCTTextPropertiesDefaultAlignment;
+extern UIColor* const RCTTextPropertiesDefaultForegroundColor;
+extern CGFloat const RCTTextPropertiesDefaultFontSize;
+extern CGRect const RCTTextPropertiesDefaultContentRect;
+
+@property (nonatomic, strong, nonnull) NSString* text;
+@property (nonatomic, assign) NSTextAlignment alignment;
+@property (nonatomic, strong, nonnull) UIColor* foregroundColor;
+@property (nonatomic, assign) CGFloat fontSize;
+@property (nonatomic, assign) CGRect contentRect;
+
+- (instancetype _Nonnull) init;
+
+@end

package/ios/Sources/RCTTextPropertiesWrapper.mm

@@ -0,0 +1,28 @@
+/*
+ * Unless explicitly stated otherwise all files in this repository are licensed under the Apache License Version 2.0.
+ * This product includes software developed at Datadog (https://www.datadoghq.com/).
+ * Copyright 2016-Present Datadog, Inc.
+ */
+#import "RCTTextPropertiesWrapper.h"
+
+@implementation RCTTextPropertiesWrapper
+
+NSString* const RCTTextPropertiesDefaultText = @"";
+NSTextAlignment const RCTTextPropertiesDefaultAlignment = NSTextAlignmentNatural;
+UIColor* const RCTTextPropertiesDefaultForegroundColor = [UIColor blackColor];
+CGFloat const RCTTextPropertiesDefaultFontSize = 14.0;
+CGRect const RCTTextPropertiesDefaultContentRect = CGRectZero;
+
+- (instancetype)init {
+    self = [super init];
+    if (self) {
+        _text = RCTTextPropertiesDefaultText;
+        _alignment = RCTTextPropertiesDefaultAlignment;
+        _foregroundColor = RCTTextPropertiesDefaultForegroundColor;
+        _fontSize = RCTTextPropertiesDefaultFontSize;
+        _contentRect = RCTTextPropertiesDefaultContentRect;
+    }
+    return self;
+}
+
+@end