@datadog/mobile-react-native-session-replay 2.14.0 → 2.14.2

package/README.md

@@ -127,6 +127,21 @@ yarn android
 
 The `datadog-generate-sr-assets` CLI utility scans your codebase for SVG elements and pre-generates optimized assets that will be included in your native builds.
 
+#### CLI Options
+
+The `datadog-generate-sr-assets` command supports the following options:
+
+```sh
+npx datadog-generate-sr-assets [options]
+```
+
+| Option | Alias | Description | Example |
+|--------|-------|-------------|---------|
+| `--ignore <pattern>` | `-i` | Additional glob patterns to ignore during scanning. Can be specified multiple times. | `npx datadog-generate-sr-assets --ignore "**/legacy/**" --ignore "**/vendor/**"` |
+| `--verbose` | `-v` | Enable verbose output for debugging. | `npx datadog-generate-sr-assets --verbose` |
+| `--path <path>` | `-p` | Path to the root directory to scan. Defaults to the current working directory. | `npx datadog-generate-sr-assets --path ./src` |
+| `--followSymlinks` | | Follow symbolic links during directory traversal. Default: false (symlinks are ignored). | `npx datadog-generate-sr-assets --followSymlinks` |
+
 **Note for CI/CD**: If you use continuous integration for your builds, make sure to include these steps in your CI pipeline. The workflow should be: `yarn install` → `npx datadog-generate-sr-assets` → `pod install` (for iOS) → build your app. This ensures SVG assets are properly generated before the native build process.
 
 ### Development Workflow

package/ios/Sources/RCTTextExtractor.h

@@ -0,0 +1,18 @@
+/*
+ * 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"
+
+@class RCTUIManager;
+
+@interface RCTTextExtractor : NSObject
+
+- (nullable RCTTextPropertiesWrapper*)tryToExtractTextPropertiesFromView:(UIView* _Nonnull)view
+                                                           withUIManager:(RCTUIManager* _Nonnull)uiManager;
+
+- (BOOL)isRCTTextView:(UIView* _Nonnull)view;
+
+@end

package/ios/Sources/RCTTextExtractor.mm

@@ -0,0 +1,127 @@
+/*
+ * 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 "RCTTextExtractor.h"
+
+#if !RCT_NEW_ARCH_ENABLED
+#import <React/RCTBridge.h>
+#import <React/RCTUIManager.h>
+#import <React/RCTTextView.h>
+#import <React/RCTTextShadowView.h>
+#import <React/RCTRawTextShadowView.h>
+#import <React/RCTVirtualTextShadowView.h>
+#endif
+
+@implementation RCTTextExtractor
+
+/**
+ * Extracts the text properties from the given UIView when using the old Paper architecture.
+ * Returns nil when using new architecture or if the view is not a RCTTextView.
+ */
+- (nullable RCTTextPropertiesWrapper*)tryToExtractTextPropertiesFromView:(UIView *)view
+                                                           withUIManager:(RCTUIManager *)uiManager {
+#if !RCT_NEW_ARCH_ENABLED
+    if (![view isKindOfClass:[RCTTextView class]]) {
+        return nil;
+    }
+
+    RCTTextView* textView = (RCTTextView*)view;
+    NSNumber* tag = textView.reactTag;
+
+    __block RCTTextShadowView* shadowView = nil;
+    NSTimeInterval timeout = 0.2;
+    dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);
+
+    // We need to access the shadow view from the UIManager queue, but we're currently on the main thread.
+    // Calling `.sync` from the main thread to the UIManager queue is unsafe, because the UIManager queue
+    // may already be executing a layout operation that in turn requires the main thread (e.g. measuring a native view).
+    // That would create a circular dependency and deadlock the app.
+    // To avoid this, we dispatch the work asynchronously to the UIManager queue and wait with a timeout.
+    // This ensures we block only if absolutely necessary, and can fail gracefully if the queue is busy.
+    dispatch_async(uiManager.methodQueue, ^{
+        shadowView = (RCTTextShadowView*)[uiManager shadowViewForReactTag:tag];
+        dispatch_semaphore_signal(semaphore);
+    });
+
+    dispatch_time_t waitTimeout = dispatch_time(DISPATCH_TIME_NOW, (int64_t)(timeout * NSEC_PER_SEC));
+    long waitResult = dispatch_semaphore_wait(semaphore, waitTimeout);
+
+    if (waitResult != 0) { // timeout
+        return nil;
+    }
+
+    if (shadowView == nil || ![shadowView isKindOfClass:[RCTTextShadowView class]]) {
+        return nil;
+    }
+
+    RCTTextPropertiesWrapper* textProperties = [[RCTTextPropertiesWrapper alloc] init];
+
+    // Extract text from subviews
+    NSString* text = [self tryToExtractTextFromSubViews:shadowView.reactSubviews];
+    if (text != nil) {
+        textProperties.text = text;
+    }
+
+    // Extract text attributes
+    if (shadowView.textAttributes.foregroundColor != nil) {
+        textProperties.foregroundColor = shadowView.textAttributes.foregroundColor;
+    }
+
+    textProperties.alignment = shadowView.textAttributes.alignment;
+    textProperties.fontSize = shadowView.textAttributes.fontSize;
+    textProperties.contentRect = shadowView.layoutMetrics.contentFrame;
+
+    return textProperties;
+#else
+    return nil;
+#endif
+}
+
+#if !RCT_NEW_ARCH_ENABLED
+- (nullable NSString*)tryToExtractTextFromSubViews:(NSArray<RCTShadowView*>*)subviews {
+    if (subviews == nil) {
+        return nil;
+    }
+
+    NSMutableArray<NSString*>* textParts = [NSMutableArray array];
+
+    for (RCTShadowView* subview in subviews) {
+        if ([subview isKindOfClass:[RCTRawTextShadowView class]]) {
+            RCTRawTextShadowView* rawTextView = (RCTRawTextShadowView*)subview;
+            if (rawTextView.text != nil) {
+                [textParts addObject:rawTextView.text];
+            }
+        } else if ([subview isKindOfClass:[RCTVirtualTextShadowView class]]) {
+            // We recursively get all subviews for nested Text components
+            RCTVirtualTextShadowView* virtualTextView = (RCTVirtualTextShadowView*)subview;
+            NSString* nestedText = [self tryToExtractTextFromSubViews:virtualTextView.reactSubviews];
+            if (nestedText != nil) {
+                [textParts addObject:nestedText];
+            }
+        }
+    }
+
+    if (textParts.count == 0) {
+        return nil;
+    }
+
+    return [textParts componentsJoinedByString:@""];
+}
+#endif
+
+/**
+ * Checks if the given view is an RCTTextView.
+ * Returns NO when using new architecture or if the view is not a RCTTextView.
+ */
+- (BOOL)isRCTTextView:(UIView *)view {
+#if !RCT_NEW_ARCH_ENABLED
+    return [view isKindOfClass:[RCTTextView class]];
+#else
+    return NO;
+#endif
+}
+
+@end

package/ios/Sources/RCTTextViewRecorder.swift

@@ -18,10 +18,12 @@ internal class RCTTextViewRecorder: SessionReplayNodeRecorder {
 
     internal let uiManager: RCTUIManager
     internal let fabricWrapper: RCTFabricWrapper
+    private let textExtractor: RCTTextExtractor
 
     internal init(uiManager: RCTUIManager, fabricWrapper: RCTFabricWrapper) {
         self.uiManager = uiManager
         self.fabricWrapper = fabricWrapper
+        self.textExtractor = RCTTextExtractor()
     }
 
     public func semantics(
@@ -30,9 +32,12 @@ internal class RCTTextViewRecorder: SessionReplayNodeRecorder {
         in context: SessionReplayViewTreeRecordingContext
     ) -> SessionReplayNodeSemantics? {
         guard
-            let textProperties = fabricWrapper.tryToExtractTextProperties(from: view) ?? tryToExtractTextProperties(view: view)
+            let textProperties = fabricWrapper.tryToExtractTextProperties(from: view)
+                ?? textExtractor.tryToExtractTextProperties(from: view, with: uiManager)
         else {
-            return view is RCTTextView ? SessionReplayInvisibleElement.constant : nil
+            // Check if this is an RCTTextView that we couldn't extract text from
+            // This check is done in Objective-C to avoid compile-time dependency on RCTTextView
+            return textExtractor.isRCTTextView(view) ? SessionReplayInvisibleElement.constant : nil
         }
 
         let builder = RCTTextViewWireframesBuilder(
@@ -51,73 +56,6 @@ internal class RCTTextViewRecorder: SessionReplayNodeRecorder {
         ])
     }
 
-    internal func tryToExtractTextFromSubViews(
-        subviews: [RCTShadowView]?
-    ) -> String? {
-        guard let subviews = subviews else {
-            return nil
-        }
-
-        return subviews.compactMap { subview in
-            if let sub = subview as? RCTRawTextShadowView {
-                return sub.text
-            }
-            if let sub = subview as? RCTVirtualTextShadowView {
-                // We recursively get all subviews for nested Text components
-                return tryToExtractTextFromSubViews(subviews: sub.reactSubviews())
-            }
-            return nil
-        }.joined()
-    }
-
-    private func tryToExtractTextProperties(view: UIView) -> RCTTextPropertiesWrapper? {
-        guard let textView = view as? RCTTextView else {
-            return nil
-        }
-
-        var shadowView: RCTTextShadowView? = nil
-        let tag = textView.reactTag
-
-        let timeout: TimeInterval = 0.2
-        let semaphore = DispatchSemaphore(value: 0)
-        
-        // We need to access the shadow view from the UIManager queue, but we're currently on the main thread.
-        // Calling `.sync` from the main thread to the UIManager queue is unsafe, because the UIManager queue
-        // may already be executing a layout operation that in turn requires the main thread (e.g. measuring a native view).
-        // That would create a circular dependency and deadlock the app.
-        // To avoid this, we dispatch the work asynchronously to the UIManager queue and wait with a timeout.
-        // This ensures we block only if absolutely necessary, and can fail gracefully if the queue is busy.
-        RCTGetUIManagerQueue().async {
-            shadowView = self.uiManager.shadowView(forReactTag: tag) as? RCTTextShadowView
-            semaphore.signal()
-        }
-        
-        let waitResult = semaphore.wait(timeout: .now() + timeout)
-        if waitResult == .timedOut {
-            return nil
-        }
-
-        guard let shadow = shadowView else {
-            return nil
-        }
-
-        let textProperties = RCTTextPropertiesWrapper()
-
-        // TODO: RUM-2173 check performance is ok
-        if let text = tryToExtractTextFromSubViews(subviews: shadow.reactSubviews()) {
-            textProperties.text = text
-        }
-
-        if let foregroundColor = shadow.textAttributes.foregroundColor {
-            textProperties.foregroundColor = foregroundColor
-        }
-
-        textProperties.alignment = shadow.textAttributes.alignment
-        textProperties.fontSize = shadow.textAttributes.fontSize
-        textProperties.contentRect = shadow.contentFrame
-
-        return textProperties
-    }
 }
 
 internal struct RCTTextViewWireframesBuilder: SessionReplayNodeWireframesBuilder {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@datadog/mobile-react-native-session-replay",
-    "version": "2.14.0",
+    "version": "2.14.2",
     "description": "A client-side React Native module to enable session replay with Datadog",
     "keywords": [
         "datadog",
@@ -96,5 +96,5 @@
     "dependencies": {
         "chokidar": "^4.0.3"
     },
-    "gitHead": "5a2b777da2d65922cc423992feee052f5c2b104f"
+    "gitHead": "1f85e56ea633c9cdee4c970a46356f5f8a1dfc67"
 }