cobrowse-sdk-react-native 2.11.0 → 2.12.0

package/android/build.gradle

@@ -30,5 +30,5 @@ android {
 
 dependencies {
     implementation 'com.facebook.react:react-native:+' // support react-native-v0.22-rc+
-    implementation 'io.cobrowse:cobrowse-sdk-android:2.18.1'
+    implementation 'io.cobrowse:cobrowse-sdk-android:2.23.0'
 }

package/android/src/main/java/io/cobrowse/reactnative/CobrowseIO.java

@@ -0,0 +1,22 @@
+package io.cobrowse.reactnative;
+
+import android.app.Activity;
+import android.view.View;
+
+import java.util.List;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+public abstract class CobrowseIO {
+  public interface Delegate {
+  }
+
+  public interface RedactionDelegate extends Delegate {
+    @Nullable
+    List<View> redactedViews(@NonNull final Activity activity);
+
+    @Nullable
+    List<View> unredactedViews(@NonNull final Activity activity);
+  }
+}

package/android/src/main/java/io/cobrowse/reactnative/CobrowseIOModule.java

@@ -4,20 +4,27 @@ import android.app.Activity;
 import android.os.Handler;
 import android.util.Log;
 import android.view.View;
+import android.view.ViewGroup;
+import android.view.ViewParent;
 
 import com.facebook.react.bridge.Promise;
 import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.bridge.ReactContextBaseJavaModule;
 import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.ReadableArray;
 import com.facebook.react.bridge.ReadableMap;
 import com.facebook.react.modules.core.DeviceEventManagerModule;
+import com.facebook.react.uimanager.NativeViewHierarchyManager;
+import com.facebook.react.uimanager.UIBlock;
+import com.facebook.react.uimanager.UIManagerModule;
 
 import java.util.ArrayList;
-import java.util.HashMap;
+import java.util.HashSet;
 import java.util.List;
-import java.util.Map;
+import java.util.Set;
 
 import androidx.annotation.NonNull;
+import androidx.core.util.Predicate;
 import io.cobrowse.CobrowseIO;
 import io.cobrowse.Session;
 import io.cobrowse.CobrowseAccessibilityService;
@@ -27,16 +34,33 @@ public class CobrowseIOModule extends ReactContextBaseJavaModule
     CobrowseIO.SessionLoadDelegate, CobrowseIO.RedactionDelegate,
     CobrowseIO.RemoteControlRequestDelegate {
 
-    private static final String SESSION_LOADED = "session.loaded";
+  private static final String SESSION_LOADED = "session.loaded";
     private static final String SESSION_UPDATED = "session.updated";
     private static final String SESSION_ENDED = "session.ended";
     private static final String SESSION_REQUESTED = "session.requested";
 
+    private final HashSet<Integer> unredactedTags = new HashSet<>();
+    private NativeViewHierarchyManager nodeManager;
+
     CobrowseIOModule(ReactApplicationContext reactContext) {
         super(reactContext);
         CobrowseIO.instance().setDelegate(this);
     }
 
+    private void findNodeManager() {
+        if (nodeManager != null) return;
+        final UIManagerModule uiManager = getReactApplicationContext().getNativeModule(UIManagerModule.class);
+        assert uiManager != null;
+        uiManager.prependUIBlock(new UIBlock() {
+            @Override
+            public void execute(NativeViewHierarchyManager nativeViewHierarchyManager) {
+                nodeManager = nativeViewHierarchyManager;
+            }
+        });
+    }
+
+    public static io.cobrowse.reactnative.CobrowseIO.Delegate delegate;
+
     @NonNull
     public String getName() {
         return "CobrowseIO";
@@ -46,43 +70,141 @@ public class CobrowseIOModule extends ReactContextBaseJavaModule
     public void sessionDidLoad(@NonNull Session session) {
         getReactApplicationContext()
                 .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
-                .emit(SESSION_LOADED, Utility.convert(session));
+                .emit(SESSION_LOADED, Conversion.convert(session));
     }
 
     @Override
     public void sessionDidUpdate(@NonNull Session session) {
         getReactApplicationContext()
                 .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
-                .emit(SESSION_UPDATED, Utility.convert(session));
+                .emit(SESSION_UPDATED, Conversion.convert(session));
     }
 
     @Override
     public void sessionDidEnd(@NonNull Session session) {
         getReactApplicationContext()
                 .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
-                .emit(SESSION_ENDED, Utility.convert(session));
+                .emit(SESSION_ENDED, Conversion.convert(session));
     }
 
     @Override
     public void handleSessionRequest(@NonNull Activity activity, @NonNull Session session) {
         getReactApplicationContext()
                 .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
-                .emit(SESSION_REQUESTED, Utility.convert(session));
+                .emit(SESSION_REQUESTED, Conversion.convert(session));
     }
 
     @Override
     public void handleRemoteControlRequest(@NonNull Activity activity, @NonNull Session session) {
-      // no-op, this will be handed on the JS side via an "updated" event handler
-      // this stub just disables the default native prompt in the SDK
+        // no-op, this will be handed on the JS side via an "updated" event handler
+        // this stub just disables the default native prompt in the SDK
+    }
+    @ReactMethod
+    public void setUnredactedTags(final ReadableArray reactTags, final Promise promise) {
+        synchronized (unredactedTags) {
+            unredactedTags.clear();
+            for (int i = 0; i < reactTags.size(); i++)
+                unredactedTags.add(reactTags.getInt(i));
+            promise.resolve(null);
+        }
+    }
+
+    private Set<View> getUnredactedViews(@NonNull final Activity activity) {
+        synchronized (unredactedTags) {
+            HashSet<View> unredacted = new HashSet<>();
+            for (Integer i : unredactedTags) {
+                try {
+                   unredacted.add(nodeManager.resolveView(i));
+                } catch (Exception e) {
+                   Log.i("CobrowseIO", "Failed to find unredacted view for tag " + i + ", error = " + e.getMessage());
+                }
+            }
+            if (delegate instanceof io.cobrowse.reactnative.CobrowseIO.RedactionDelegate) {
+              List<View> views = ((io.cobrowse.reactnative.CobrowseIO.RedactionDelegate) delegate).unredactedViews(activity);
+              if (views != null) unredacted.addAll(views);
+            }
+            return unredacted;
+        }
+    }
+
+    private Set<View> getRedactedViews(@NonNull final Activity activity) {
+      HashSet<View> redacted = new HashSet<>(RedactedViewManager.redactedViews.keySet());
+      if (delegate instanceof io.cobrowse.reactnative.CobrowseIO.RedactionDelegate) {
+        List<View> views = ((io.cobrowse.reactnative.CobrowseIO.RedactionDelegate) delegate).redactedViews(activity);
+        if (views != null) redacted.addAll(views);
+      }
+      return redacted;
     }
 
     @Override
-    public List<View> redactedViews(@NonNull final Activity activity) {
-        return new ArrayList<>(RedactedViewManager.redactedViews.keySet());
+    public List<View> redactedViews(@NonNull final Activity activity)  {
+      final Set<View> redacted = this.getRedactedViews(activity);
+      final Set<View> unredacted = this.getUnredactedViews(activity);
+
+      // Project all unredactions to the root to get the full set of unredacted nodes
+      HashSet<View> projectedUnredacted = new HashSet<>();
+      for (View view : unredacted) {
+          projectedUnredacted.add(view);
+          projectedUnredacted.addAll(TreeUtils.allParents(view));
+      }
+
+      // Work out which nodes are explicitly redacted but need to be unredacted
+      // due to a nested unredaction tag (these redactions will be moved towards the
+      // leaves of the view hierarchy instead)
+      HashSet<View> redactedProjectedUnredactions = new HashSet<>(redacted);
+      redactedProjectedUnredactions.retainAll(projectedUnredacted);
+
+      // Start to build the set of redactions we should actually apply. We start off with
+      // the set of explicitly redacted nodes
+      HashSet<View> toRedact = new HashSet<>(redacted);
+
+      // remove any redactions that have unredacted decendants (i.e. any that appear in the
+      // projection of the unredaction). These are the redacted nodes we need to move towards
+      // the leaves of the tree
+      toRedact.removeAll(redactedProjectedUnredactions);
+
+      // Work out the set of all nodes that are siblings of any projected unredacted node
+      HashSet<View> projectedUnredactionSiblings = new HashSet<>();
+      for (View view : projectedUnredacted) {
+          ViewParent parent = view.getParent();
+          if (parent instanceof ViewGroup)
+            projectedUnredactionSiblings.addAll(TreeUtils.directChildren((ViewGroup) parent));
+      }
+
+      // Subtract the projected unredactions from the set of all siblings of projected
+      // unredactions. i.e. subtract things that should be definitely unredacted to leave
+      // a set we're not sure yet whether to redact or not
+      HashSet<View> potentiallyRedactedUnredactedSiblings = new HashSet<View>(projectedUnredactionSiblings);
+      potentiallyRedactedUnredactedSiblings.removeAll(projectedUnredacted);
+
+      // for each node we're not sure about yet, check if the closest redacted or unredacted ancestor
+      // is a redacted node, if so this descendant should also be redacted
+      for (View view : potentiallyRedactedUnredactedSiblings) {
+      View closest = TreeUtils.closest(view, new Predicate<View>() {
+          @Override
+          public boolean test(View view) {
+            return redacted.contains(view) || unredacted.contains(view);
+          }
+        });
+        if (redacted.contains(closest)) toRedact.add(view);
+      }
+
+      // Remove any empty ViewGroup from the redacted set, they're often used for wrapping
+      // or sizing other elements, and do not usually need to be redacted
+      // If it's absolutely necessary they are redacted, they can always be replaced with
+      // a <Redacted> tag instead
+      for (View v : new HashSet<>(toRedact)) {
+        if (v instanceof ViewGroup && ((ViewGroup) v).getChildCount() == 0) {
+          toRedact.remove(v);
+        }
+      }
+
+      return new ArrayList<>(toRedact);
     }
 
     @ReactMethod
     public void start() {
+        findNodeManager();
         final Activity activity = getReactApplicationContext().getCurrentActivity();
         if (activity != null)
             activity.runOnUiThread(new Runnable() {
@@ -125,7 +247,7 @@ public class CobrowseIOModule extends ReactContextBaseJavaModule
 
     @ReactMethod
     public void currentSession(final Promise promise) {
-        promise.resolve(Utility.convert(CobrowseIO.instance().currentSession()));
+        promise.resolve(Conversion.convert(CobrowseIO.instance().currentSession()));
     }
 
     @ReactMethod
@@ -137,7 +259,7 @@ public class CobrowseIOModule extends ReactContextBaseJavaModule
                     @Override
                     public void call(Error error, Session session) {
                         if (error != null) promise.reject("cbio_create_session_failed", error);
-                        else promise.resolve(Utility.convert(session));
+                        else promise.resolve(Conversion.convert(session));
                     }
                 });
             }
@@ -153,7 +275,7 @@ public class CobrowseIOModule extends ReactContextBaseJavaModule
                     @Override
                     public void call(Error error, Session session) {
                         if (error != null) promise.reject("cbio_get_session_failed", error);
-                        else promise.resolve(Utility.convert(session));
+                        else promise.resolve(Conversion.convert(session));
                     }
                 });
             }
@@ -174,7 +296,7 @@ public class CobrowseIOModule extends ReactContextBaseJavaModule
                     @Override
                     public void call(Error error, Session session) {
                         if (error != null) promise.reject("cbio_activate_session_failed", error);
-                        else promise.resolve(Utility.convert(session));
+                        else promise.resolve(Conversion.convert(session));
                     }
                 });
             }
@@ -231,7 +353,7 @@ public class CobrowseIOModule extends ReactContextBaseJavaModule
                 if (options.hasKey("remote_control")) {
                     String remoteControl = options.getString("remote_control");
 
-                    current.setRemoteControl(Utility.remoteControl(remoteControl), new io.cobrowse.Callback<Error, Session>() {
+                    current.setRemoteControl(Conversion.remoteControl(remoteControl), new io.cobrowse.Callback<Error, Session>() {
                         @Override
                         public void call(Error error, Session session) {
                             if (error != null) promise.reject("cbio_remote_control_failed", error);
@@ -253,4 +375,5 @@ public class CobrowseIOModule extends ReactContextBaseJavaModule
     public void accessibilityServiceIsRunning(final Promise promise) {
         promise.resolve(CobrowseAccessibilityService.isRunning(getReactApplicationContext()));
     }
+
 }

package/android/src/main/java/io/cobrowse/reactnative/{Utility.java → Conversion.java}

@@ -7,7 +7,7 @@ import io.cobrowse.Agent;
 import io.cobrowse.Session;
 import io.cobrowse.Session.RemoteControlState;
 
-final class Utility {
+final class Conversion {
 
     static WritableMap convert(Session session) {
         WritableMap map = Arguments.createMap();
@@ -16,7 +16,7 @@ final class Utility {
         map.putString("state", session.state());
         map.putString("id", session.id());
         map.putBoolean("full_device", session.fullDevice());
-        map.putString("remote_control", Utility.remoteControl(session.remoteControl()));
+        map.putString("remote_control", Conversion.remoteControl(session.remoteControl()));
 
         Agent agent = session.agent();
         if (agent != null) {

package/android/src/main/java/io/cobrowse/reactnative/TreeUtils.java

@@ -0,0 +1,43 @@
+package io.cobrowse.reactnative;
+
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.ViewParent;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+import androidx.core.util.Predicate;
+
+class TreeUtils {
+
+    public static Set<View> directChildren(View root) {
+        HashSet<View> children = new HashSet<>();
+        if (root instanceof ViewGroup) {
+            ViewGroup viewGroup = (ViewGroup) root;
+            for (int i = 0; i < viewGroup.getChildCount(); i++) {
+                children.add(viewGroup.getChildAt(i));
+            }
+        }
+        return children;
+    }
+
+    public static List<View> allParents(View root) {
+        ArrayList<View> parents = new ArrayList<>();
+        ViewParent target = root.getParent();
+        while (target != null) {
+            if (target instanceof View) parents.add(0, (View) target);
+            target = target.getParent();
+        }
+        return parents;
+    }
+
+    public static View closest(View root, Predicate<View> predicate) {
+      if (predicate.test(root)) return root;
+      ViewParent parent = root.getParent();
+      if (parent instanceof ViewGroup) return closest((ViewGroup)parent, predicate);
+      return null;
+    }
+}

package/cobrowse-sdk-react-native.podspec

@@ -11,8 +11,7 @@ Pod::Spec.new do |s|
   s.homepage      = package["homepage"]
   s.source        = { :git => 'https://github.com/cobrowseio/cobrowse-sdk-react-native.git' }
   s.platform      = :ios, '9.0'
-
-  s.dependency      'CobrowseIO/Framework', '2.17.1'
+  s.dependency      'CobrowseIO/XCFramework', '2.21.2'
   s.dependency      'React'
   s.source_files =  'ios/*.{h,m}'
 end

package/ios/RCTCBIOTreeUtils.h

@@ -0,0 +1,9 @@
+#import <Foundation/Foundation.h>
+
+@interface RCTCBIOTreeUtils : NSObject
+
++(NSArray*) allParents: (UIView*) root;
+
++(UIView*) closest: (BOOL (^)(UIView* view))predicate from: (UIView*) root;
+
+@end

package/ios/RCTCBIOTreeUtils.m

@@ -0,0 +1,21 @@
+#import "RCTCBIOTreeUtils.h"
+
+@implementation RCTCBIOTreeUtils
+
++(NSArray*) allParents: (UIView*) root {
+    NSMutableArray* parents = [NSMutableArray array];
+    UIView* target = root.superview;
+    while (target) {
+        [parents insertObject:target atIndex:0];
+        target = target.superview;
+    }
+    return parents;
+}
+
++(UIView*) closest: (BOOL (^)(UIView* view))predicate from: (UIView*) root {
+    if (predicate(root)) return root;
+    else if (!root.superview) return nil;
+    else return [self closest:predicate from:root.superview];
+}
+
+@end

package/ios/RCTCobrowseIO.h

@@ -4,6 +4,20 @@
 
 @import CobrowseIO;
 
+
+@protocol RCTCobrowseIODelegate <NSObject>
+
+@optional
+
+-(nonnull NSArray<UIView*>*) cobrowseRedactedViewsForViewController: (nonnull UIViewController*) vc;
+-(nonnull NSArray<UIView*>*) cobrowseUnredactedViewsForViewController: (nonnull UIViewController*) vc;
+
+@end
+
+
 @interface RCTCobrowseIO: RCTEventEmitter <RCTBridgeModule, CobrowseIODelegate>
 
+@property (class, nullable) id<RCTCobrowseIODelegate> delegate;
+
 @end
+

package/ios/RCTCobrowseIO.m

@@ -5,17 +5,22 @@
 #import <React/RCTUtils.h>
 #import <React/RCTView.h>
 #import <React/RCTBridge.h>
+#import <React/RCTUIManager.h>
 #import "RCTCobrowseIO.h"
+#import "RCTCBIOTreeUtils.h"
 
 #define SESSION_LOADED "session.loaded"
 #define SESSION_UPDATED "session.updated"
 #define SESSION_ENDED "session.ended"
 #define SESSION_REQUESTED "session.requested"
 
+static id<RCTCobrowseIODelegate> _Nullable _delegate;
+
 @import CobrowseIO;
 
 @implementation RCTCobrowseIO {
     bool hasListeners;
+    NSMutableSet* unredactedTags;
 }
 
 RCT_EXPORT_MODULE();
@@ -24,10 +29,19 @@ RCT_EXPORT_MODULE();
     self = [super init];
     if (self) {
         [CobrowseIO.instance setDelegate:self];
+        unredactedTags = [NSMutableSet set];
     }
     return self;
 }
 
++(id<RCTCobrowseIODelegate>)delegate {
+    return _delegate;
+}
+
++(void)setDelegate:(id<RCTCobrowseIODelegate>)delegate {
+    _delegate = delegate;
+}
+
 + (BOOL)requiresMainQueueSetup {
     return YES;
 }
@@ -52,6 +66,28 @@ RCT_EXPORT_MODULE();
     if (hasListeners) [self sendEventWithName:@SESSION_LOADED body:[session toDict]];
 }
 
+-(NSSet<UIView*>*) redactedViews: (UIViewController*) vc {
+    NSMutableSet* views = [CBIOCobrowseRedactedManager.redactedViews mutableCopy];
+    if ([RCTCobrowseIO.delegate respondsToSelector:@selector(cobrowseRedactedViewsForViewController:)]) {
+        [views addObjectsFromArray: [RCTCobrowseIO.delegate cobrowseRedactedViewsForViewController:vc]];
+    }
+    return views;
+}
+
+-(NSSet<UIView*>*) unredactedViews: (UIViewController*) vc {
+    NSMutableSet* views = [NSMutableSet set];
+    @synchronized(unredactedTags) {
+        for (id tag in unredactedTags) {
+            UIView* v = [self.bridge.uiManager viewForReactTag: tag];
+            if (v != nil) [views addObject:v];
+        }
+    }
+    if ([RCTCobrowseIO.delegate respondsToSelector:@selector(cobrowseUnredactedViewsForViewController:)]) {
+        [views addObjectsFromArray: [RCTCobrowseIO.delegate cobrowseUnredactedViewsForViewController:vc]];
+    }
+    return views;
+}
+
 -(void)cobrowseSessionDidUpdate:(CBIOSession *)session {
     if (hasListeners) [self sendEventWithName:@SESSION_UPDATED body:[session toDict]];
 }
@@ -70,11 +106,60 @@ RCT_EXPORT_MODULE();
 }
 
 -(NSArray<UIView *> *)cobrowseRedactedViewsForViewController:(UIViewController *)vc {
-    NSMutableArray* views = [NSMutableArray array];
-    for (UIView* v in CBIOCobrowseRedactedManager.redactedViews.allObjects) {
-        if ([v isDescendantOfView:vc.view]) [views addObject:v];
+    NSSet* redacted = [self redactedViews: vc];
+    NSSet* unredacted = [self unredactedViews: vc];
+    
+    // Project all unredactions to the root to get the full set of unredacted nodes
+    NSMutableSet* projectedUnredacted = [NSMutableSet set];
+    for (id view in unredacted) {
+        [projectedUnredacted addObject:view];
+        [projectedUnredacted addObjectsFromArray: [RCTCBIOTreeUtils allParents: view]];
     }
-    return views;
+
+    // Work out which nodes are explicitly redacted but need to be unredacted
+    // due to a nested unredaction tag (these redactions will be moved towards the
+    // leaves of the view hierarchy instead)
+    NSMutableSet* redactedProjectedUnredactions = [redacted mutableCopy];
+    [redactedProjectedUnredactions intersectSet: projectedUnredacted];
+    
+    // Start to build the set of redactions we should actually apply. We start off with
+    // the set of explicitly redacted nodes
+    NSMutableSet* toRedact = [redacted mutableCopy];
+    
+    // remove any redactions that have unredacted decendants (i.e. any that appear in the
+    // projection of the unredaction). These are the redacted nodes we need to move towards
+    // the leaves of the tree
+    [toRedact minusSet: redactedProjectedUnredactions];
+    
+    // Work out the set of all nodes that are siblings of any projected unredacted node
+    NSMutableSet* projectedUnredactionSiblings = [NSMutableSet set];
+    for (UIView* view in projectedUnredacted) {
+        [projectedUnredactionSiblings addObjectsFromArray: view.superview.subviews];
+    }
+    
+    // Subtract the projected unredactions from the set of all siblings of projected
+    // unredactions. i.e. subtract things that should be definitely unredacted to leave
+    // a set we're not sure yet whether to redact or not
+    NSMutableSet* potentiallyRedactedUnredactedSiblings = [projectedUnredactionSiblings mutableCopy];
+    [potentiallyRedactedUnredactedSiblings minusSet:projectedUnredacted];
+    
+    // for each node we're not sure about yet, check if the closest redacted or unredacted ancestor
+    // is a redacted node, if so this descendant should also be redacted
+    for (UIView* view in potentiallyRedactedUnredactedSiblings) {
+        UIView* closest = [RCTCBIOTreeUtils closest:^BOOL(UIView *v) {
+            return [redacted containsObject:v] || [unredacted containsObject:v];
+        } from: view];
+        if ([redacted containsObject: closest]) [toRedact addObject: view];
+    }
+    
+    // Remove any empty RCTViews from the redacted set, they're often used for wrapping
+    // or sizing other elements, and do not usually need to be redacted
+    // If it's absolutely necessary they are redacted, they can always be replaced with
+    // a <Redacted> tag instead
+    for (UIView* v in [toRedact copy])
+        if ([v isKindOfClass:RCTView.class] && v.subviews.count == 0) [toRedact removeObject: v];
+
+    return toRedact.allObjects;
 }
 
 - (bool) cobrowseShouldCaptureWindow:(UIWindow *)window {
@@ -85,6 +170,14 @@ RCT_EXPORT_MODULE();
     }
 }
 
+-(void) forceRedactionUpdate {
+    // TODO: expose an API for forcing redaction updates?
+    static UIView* v;
+    if (!v) v = [[UIView alloc] init];
+    [UIApplication.sharedApplication.keyWindow addSubview: v];
+    [v removeFromSuperview];
+}
+
 RCT_EXPORT_METHOD(start) {
     [CobrowseIO.instance start];
 }
@@ -106,6 +199,18 @@ RCT_EXPORT_METHOD(api: (NSString*) api) {
     CobrowseIO.instance.api = api;
 }
 
+RCT_REMAP_METHOD(setUnredactedTags,
+                 setUnredactedTags: (NSArray*) reactTags
+                 resolver:(RCTPromiseResolveBlock)resolve
+                 rejecter:(RCTPromiseRejectBlock)reject) {
+    @synchronized(unredactedTags) {
+        [unredactedTags removeAllObjects];
+        [unredactedTags addObjectsFromArray:reactTags];
+    }
+    [self forceRedactionUpdate];
+    resolve(nil);
+}
+
 RCT_EXPORT_METHOD(customData: (NSDictionary*) customData) {
     CobrowseIO.instance.customData = customData;
 }

package/js/Redacted.js

@@ -1,19 +1,7 @@
-import React, { useContext } from 'react'
-import { View, requireNativeComponent } from 'react-native'
+import React from 'react'
+import { requireNativeComponent } from 'react-native'
 const CBIOCobrowseRedacted = requireNativeComponent('CBIOCobrowseRedacted')
 
-const RedactionContext = React.createContext(false)
-
-export default function (props) {
-  const alreadyRedacted = useContext(RedactionContext)
-  if (!alreadyRedacted) {
-    return (
-      <RedactionContext.Provider value>
-        <CBIOCobrowseRedacted style={props.style}>
-          <View>{props.children}</View>
-        </CBIOCobrowseRedacted>
-      </RedactionContext.Provider>
-    )
-  }
-  return props.children
+module.exports = function (props) {
+  return <CBIOCobrowseRedacted {...props}>{props.children}</CBIOCobrowseRedacted>
 }

package/js/Unredacted.js

@@ -0,0 +1,82 @@
+import React, { useRef, useEffect, useCallback, useMemo } from 'react'
+import { View, findNodeHandle } from 'react-native'
+import { throttle } from 'lodash'
+const CobrowseIONative = require('react-native').NativeModules.CobrowseIO
+
+function mergeRefs (refs) {
+  return (value) => {
+    refs.forEach((ref) => {
+      if (typeof ref === 'function') {
+        ref(value)
+      } else if (ref != null) {
+        ref.current = value
+      }
+    })
+  }
+}
+
+const unredactedTags = new Set()
+const sendUnredactionUpdates = throttle(() => {
+  CobrowseIONative.setUnredactedTags([...unredactedTags])
+}, 50, { leading: false })
+
+const removeUnredactedView = (view) => {
+  if (view) {
+    unredactedTags.delete(view)
+    sendUnredactionUpdates()
+  }
+}
+
+export const useUnredaction = (shouldWarnUnhandledRefs = true, componentName = '') => {
+  const ref = useRef(null)
+
+  const setRef = useCallback((node) => {
+    let hasRemovedRef = false
+    if (ref.current) {
+      hasRemovedRef = true
+      removeUnredactedView(ref.current)
+    }
+
+    if (node) {
+      const view = findNodeHandle(node)
+
+      if (view) {
+        unredactedTags.add(view)
+        sendUnredactionUpdates()
+
+        ref.current = view
+      } else {
+        console.warn(`Failed to apply unredact() to ${componentName} due to view not found`)
+      }
+    } else if (!hasRemovedRef) {
+      console.warn(
+        `Failed to apply unredact() to ${componentName} due to null node handle – make sure you are forwarding refs`
+      )
+    }
+  }, [])
+
+  useEffect(() => {
+    if (shouldWarnUnhandledRefs && !ref.current) {
+      console.warn(
+        `Failed to apply unredact() to ${componentName} due to null node handle – make sure the setRef function is called with the ref`
+      )
+    }
+
+    return () => removeUnredactedView(ref.current)
+  }, [])
+
+  return setRef
+}
+
+// HOC for adding unredaction to a whole component class
+export function unredact(Component) {
+  return React.forwardRef(function Redacted(props, ref) {
+    const localRef = useUnredaction(true, Component?.name)
+    const refs = useMemo(() => mergeRefs([localRef, ref]), [localRef, ref])
+    return <Component {...props} collapsable={false} ref={refs} />
+  })
+}
+
+// also expose a basic Component based on a View
+const Unredacted = unredact(View)
+export default Unredacted

package/js/index.js

@@ -1,5 +1,6 @@
 export { default } from './CobrowseIO'
 export { default as CobrowseView } from './CobrowseView'
 export { default as Redacted } from './Redacted'
+export { default as Unredacted, unredact, useUnredaction } from './Unredacted'
 export { default as SessionControl } from './SessionControl'
 export { default as CobrowseAccessibilityService } from './CobrowseAccessibilityService'

package/package.json

@@ -1,12 +1,11 @@
 {
   "name": "cobrowse-sdk-react-native",
-  "version": "2.11.0",
+  "version": "2.12.0",
   "description": "Cobrowse SDK for React Native",
   "main": "js/index.js",
   "types": "ts/index.d.ts",
   "scripts": {
     "lint-fix": "ts-standard ts/*.d.ts --fix",
-    "watch": "node scripts/watch.mjs",
     "start:dev": "nodemon --exec ./scripts/copy.sh"
   },
   "author": {
@@ -28,17 +27,17 @@
   ],
   "license": "Apache-2.0",
   "optionalDependencies": {
-    "@types/react": "^17.0.38",
-    "@types/react-native": "^0.66.15"
+    "@types/react": "^18.0.18",
+    "@types/react-native": "^0.69.6"
+  },
+  "dependencies": {
+    "lodash": "^4.17.21"
   },
-  "dependencies": {},
   "devDependencies": {
-    "@types/react": "^17.0.38",
-    "@types/react-native": "^0.66.15",
-    "managed-service-daemon": "^1.2.1",
-    "nodemon": "^2.0.15",
+    "@types/react": "^18.0.18",
+    "@types/react-native": "^0.69.6",
+    "nodemon": "^2.0.19",
     "ts-standard": "^11.0.0",
-    "typescript": "^4.5.5",
-    "watchr": "^6.11.0"
+    "typescript": "^4.8.2"
   }
 }

package/ts/Redacted.d.ts

@@ -1,7 +1,8 @@
-import type { Provider, ReactNode } from 'react'
+import type { ReactNode, ReactElement } from 'react'
 
-type Props = Readonly<{}> & Readonly<{
-  children?: ReactNode
-}>
+type Props = Readonly<{}> &
+  Readonly<{
+    children?: ReactNode | undefined
+  }>
 
-export default function (props: Props): Provider<boolean>
+export default function (props: Props): ReactElement | null

package/ts/Unredacted.d.ts

@@ -0,0 +1,15 @@
+import React, { ReactElement, ForwardRefRenderFunction } from 'react'
+import { View, ScrollView, Text, Image, FlatList, SectionList } from 'react-native'
+
+export function useUnredaction<
+  T = View | ScrollView | Text | Image | FlatList | SectionList
+>(shouldWarnUnhandledRefs?: boolean , componentName?: string): (elem: T) => void
+
+type ForwardedRefType<T, P> = typeof React.forwardRef
+
+// HOC for adding unredaction to a whole component class
+export function unredact(Component: ReactElement): ForwardedRefType<View, Record<string, unknown>>
+
+// also expose a basic Component based on a View
+declare const Unredacted: ForwardRefRenderFunction<View, Record<string, unknown>>
+export default Unredacted

package/ts/index.d.ts

@@ -2,4 +2,5 @@ export { default } from './CobrowseIO'
 export { default as CobrowseView } from './CobrowseView'
 export { default as Redacted } from './Redacted'
 export { default as SessionControl } from './SessionControl'
+export { default as Unredacted, unredact, useUnredaction } from './Unredacted'
 export { default as CobrowseAccessibilityService } from './CobrowseAccessibilityService'

package/ios/RCTCobrowseIO.xcodeproj/project.xcworkspace/contents.xcworkspacedata

@@ -1,7 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<Workspace
-   version = "1.0">
-   <FileRef
-      location = "self:">
-   </FileRef>
-</Workspace>

package/ios/RCTCobrowseIO.xcodeproj/project.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist

@@ -1,8 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-	<key>IDEDidComputeMac32BitWarning</key>
-	<true/>
-</dict>
-</plist>