react-native-insider 8.1.0 → 9.0.0-nh

package/ios/RNInsider/RNInsiderAppFrameView.h

@@ -0,0 +1,33 @@
+// Fabric-only. Guarded here as well as in the .mm, because the .mm imports this header before
+// its own guard and a legacy-architecture build would otherwise pull in RCTViewComponentView.h.
+#ifdef RCT_NEW_ARCH_ENABLED
+
+#import <React/RCTViewComponentView.h>
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface RNInsiderAppFrameView : RCTViewComponentView
+@end
+
+/**
+ * The error-code name that crosses the bridge for a delegate error.
+ *
+ * Answers `@"UNKNOWN"` for an error outside App Frames' own domain, and for every error when the
+ * linked InsiderMobile has no App Frames. The signature uses no InsiderMobile type so it compiles
+ * either way.
+ */
+FOUNDATION_EXPORT NSString *RNInsiderAppFramesErrorCodeNameForError(NSError *error);
+
+/**
+ * The status name that crosses the bridge for a native status value.
+ *
+ * Answers `@"UNRECOGNIZED"` for a value outside the SDK's enum, and for every value when the
+ * linked InsiderMobile has no App Frames. The signature uses no InsiderMobile type so it compiles
+ * either way.
+ */
+FOUNDATION_EXPORT NSString *RNInsiderAppFramesStatusNameForRawStatus(NSInteger status);
+
+NS_ASSUME_NONNULL_END
+
+#endif // RCT_NEW_ARCH_ENABLED

package/ios/RNInsider/RNInsiderAppFrameView.mm

@@ -0,0 +1,315 @@
+#import "RNInsiderAppFrameView.h"
+
+// The codegen headers below exist only under the New Architecture. The legacy architecture is
+// the default on React Native 0.74-0.75 and still selectable on 0.76-0.81 (removed in 0.82), all
+// in the supported range, and this pod must still compile there.
+#ifdef RCT_NEW_ARCH_ENABLED
+
+
+#import <react/renderer/components/RNInsiderSpec/ComponentDescriptors.h>
+#import <react/renderer/components/RNInsiderSpec/EventEmitters.h>
+#import <react/renderer/components/RNInsiderSpec/Props.h>
+#import <react/renderer/components/RNInsiderSpec/RCTComponentViewHelpers.h>
+
+#import <React/RCTConversions.h>
+
+// Diagnostics go through +[Insider sendError:desc:], like the rest of the bridge, rather than
+// NSLog into a host app console the integrator cannot switch off.
+#import <InsiderMobile/Insider.h>
+
+// InsiderMobile releases before 16.0.0 have no App Frames headers. Codegen registers
+// "InsiderAppFrameView" in every app regardless of the linked SDK, so InsiderAppFrameViewCls()
+// must still resolve without them, or the app fails to link.
+#if __has_include(<InsiderMobile/InsiderAppFramesView.h>)
+#define INSIDER_APP_FRAMES_AVAILABLE 1
+#import <InsiderMobile/InsiderAppFramesView.h>
+#import <InsiderMobile/InsiderAppFramesError.h>
+#else
+#define INSIDER_APP_FRAMES_AVAILABLE 0
+#endif
+
+using namespace facebook::react;
+
+#if INSIDER_APP_FRAMES_AVAILABLE
+
+// Matches NO_DISMISS_CODE in src/InsiderAppFramesError.js.
+static const NSInteger kInsiderAppFramesNoDismissCode = -1;
+
+static NSString *RNInsiderAppFramesErrorCodeName(InsiderAppFramesErrorCode code) {
+  switch (code) {
+    case InsiderAppFramesErrorCodeResolutionFailed:
+      return @"RESOLUTION_FAILED";
+    case InsiderAppFramesErrorCodeResponseMalformed:
+      return @"RESPONSE_MALFORMED";
+    case InsiderAppFramesErrorCodeDownloadingFailed:
+      return @"DOWNLOADING_FAILED";
+    case InsiderAppFramesErrorCodePlacementUntrusted:
+      return @"PLACEMENT_UNTRUSTED";
+    case InsiderAppFramesErrorCodeContentDisplayFailed:
+      return @"CONTENT_DISPLAY_FAILED";
+    case InsiderAppFramesErrorCodeRenderingFailed:
+      return @"RENDERING_FAILED";
+    case InsiderAppFramesErrorCodeUnknown:
+      return @"UNKNOWN";
+  }
+
+  // No `default:`, and the parameter is the enum type rather than NSInteger, so a code added
+  // to the SDK trips -Wswitch instead of silently mapping to UNKNOWN.
+  return @"UNKNOWN";
+}
+
+// JS compares against its own UPPER_SNAKE enum (src/InsiderAppFrameStatus.js), so the SDK's
+// lowerCamelCase `stringValue` would match nothing, silently.
+static NSString *RNInsiderAppFramesStatusName(InsiderAppFramesViewStatus status) {
+  switch (status) {
+    case InsiderAppFramesViewStatusDetached:
+      return @"DETACHED";
+    case InsiderAppFramesViewStatusNoPlacement:
+      return @"NO_PLACEMENT";
+    case InsiderAppFramesViewStatusResolving:
+      return @"RESOLVING";
+    case InsiderAppFramesViewStatusDownloading:
+      return @"DOWNLOADING";
+    case InsiderAppFramesViewStatusRendering:
+      return @"RENDERING";
+    case InsiderAppFramesViewStatusUnavailable:
+      return @"UNAVAILABLE";
+    case InsiderAppFramesViewStatusReady:
+      return @"READY";
+    case InsiderAppFramesViewStatusDismissed:
+      return @"DISMISSED";
+    case InsiderAppFramesViewStatusErrorResolving:
+      return @"ERROR_RESOLVING";
+    case InsiderAppFramesViewStatusErrorDownloading:
+      return @"ERROR_DOWNLOADING";
+    case InsiderAppFramesViewStatusErrorRendering:
+      return @"ERROR_RENDERING";
+    case InsiderAppFramesViewStatusDisabled:
+      return @"DISABLED";
+  }
+
+  // Reachable only for an out-of-enum runtime value. UNRECOGNIZED is a declared member of the
+  // JS status union; a real status such as DETACHED would tell JS something specific and wrong.
+  [Insider sendError:[NSException exceptionWithName:@"InsiderAppFrameUnrecognisedStatus"
+                                             reason:[NSString stringWithFormat:
+                                                     @"Unrecognised InsiderAppFramesViewStatus: %ld",
+                                                     (long)status]
+                                           userInfo:nil]
+                desc:[NSString stringWithFormat:@"%s:%d", __func__, __LINE__]];
+  return @"UNRECOGNIZED";
+}
+
+// Test seam; the delegate callbacks call the static mapper directly.
+NSString *RNInsiderAppFramesStatusNameForRawStatus(NSInteger status) {
+  return RNInsiderAppFramesStatusName((InsiderAppFramesViewStatus)status);
+}
+
+@interface RNInsiderAppFrameView () <InsiderAppFramesViewDelegate>
+@end
+
+static SharedViewProps RNInsiderAppFrameViewDefaultProps() {
+  // SharedViewProps, not Props::Shared: `_props` is shared_ptr<const ViewProps>, and a
+  // shared_ptr<const Props> will not implicitly convert down to it.
+  static const auto defaultProps = std::make_shared<const InsiderAppFrameViewProps>();
+  return defaultProps;
+}
+
+@implementation RNInsiderAppFrameView {
+  InsiderAppFramesView *_frameView;
+}
+
++ (ComponentDescriptorProvider)componentDescriptorProvider {
+  return concreteComponentDescriptorProvider<InsiderAppFrameViewComponentDescriptor>();
+}
+
+- (instancetype)initWithFrame:(CGRect)frame {
+  if (self = [super initWithFrame:frame]) {
+    _props = RNInsiderAppFrameViewDefaultProps();
+
+    _frameView = [[InsiderAppFramesView alloc] initWithFrame:self.bounds];
+    _frameView.delegate = self;
+    self.contentView = _frameView;
+  }
+  return self;
+}
+
+- (void)updateProps:(Props::Shared const &)props oldProps:(Props::Shared const &)oldProps {
+  const auto &newProps = *std::static_pointer_cast<InsiderAppFrameViewProps const>(props);
+  const auto &previousProps = *std::static_pointer_cast<InsiderAppFrameViewProps const>(_props);
+
+  if (newProps.placementId != previousProps.placementId) {
+    NSString *placementId = RCTNSStringFromStringNilIfEmpty(newProps.placementId);
+    _frameView.placementId = placementId;
+  }
+
+  [super updateProps:props oldProps:oldProps];
+}
+
+// A recycled view's next updateProps: diffs against `_props`, which RCTViewComponentView does
+// not reset; without resetting it here, a view reused for the same placementId never applies it.
+- (void)prepareForRecycle {
+  [super prepareForRecycle];
+
+  // Replace the SDK view rather than reset it. A recycled view is already off-window, so it sits
+  // in DETACHED, which keeps its reported height; native suppresses a repeat of that height, so
+  // the next occupant would never receive one and render into a zero-height box.
+  _frameView.delegate = nil;
+  [_frameView removeFromSuperview];
+
+  _frameView = [[InsiderAppFramesView alloc] initWithFrame:self.bounds];
+  _frameView.delegate = self;
+  self.contentView = _frameView;
+
+  _props = RNInsiderAppFrameViewDefaultProps();
+}
+
+- (std::shared_ptr<const InsiderAppFrameViewEventEmitter>)frameEventEmitter {
+  if (!_eventEmitter) {
+    // Not expected: the emitter is set at mount, before the view reaches a window. Reported
+    // because JS mirrors status and error from these events, so a dropped one leaves it stale.
+    [Insider sendError:[NSException exceptionWithName:@"InsiderAppFrameDroppedEvent"
+                                               reason:@"Dropped an event: no event emitter attached yet."
+                                             userInfo:nil]
+                  desc:[NSString stringWithFormat:@"%s:%d", __func__, __LINE__]];
+    return nullptr;
+  }
+  return std::static_pointer_cast<const InsiderAppFrameViewEventEmitter>(_eventEmitter);
+}
+
+- (std::string)currentPlacementId {
+  return RCTStringFromNSString(_frameView.placementId ?: @"");
+}
+
+#pragma mark - InsiderAppFramesViewDelegate
+
+- (void)appFramesView:(InsiderAppFramesView *)view
+    didChangeStatusTo:(InsiderAppFramesViewStatus)status
+                 from:(InsiderAppFramesViewStatus)previousStatus {
+  auto emitter = [self frameEventEmitter];
+  if (emitter) {
+    emitter->onStatusChange({
+        .placementId = [self currentPlacementId],
+        .status = RCTStringFromNSString(RNInsiderAppFramesStatusName(status)),
+        .previousStatus = RCTStringFromNSString(RNInsiderAppFramesStatusName(previousStatus)),
+    });
+  }
+}
+
+// The cast below would reinterpret a foreign-domain code as a real App Frames code.
+NSString *RNInsiderAppFramesErrorCodeNameForError(NSError *error) {
+  if (![error.domain isEqualToString:InsiderAppFramesErrorDomain]) {
+    return @"UNKNOWN";
+  }
+  return RNInsiderAppFramesErrorCodeName((InsiderAppFramesErrorCode)error.code);
+}
+
+- (void)appFramesView:(InsiderAppFramesView *)view didFailLoadingWithError:(NSError *)error {
+  auto emitter = [self frameEventEmitter];
+  if (!emitter) {
+    return;
+  }
+
+  // `message` is the canonical per-code text, as on Android; the underlying error goes in `cause`.
+  NSError *underlying = error.userInfo[NSUnderlyingErrorKey];
+  NSString *message = error.localizedDescription ?: @"";
+  NSString *cause = underlying.localizedDescription ?: @"";
+
+  // Set when a template dismisses with a non-default code. The SDK exports no constant for this
+  // userInfo key.
+  NSNumber *dismissCode = error.userInfo[@"dismiss_code"];
+
+  NSString *codeName = RNInsiderAppFramesErrorCodeNameForError(error);
+
+  emitter->onLoadError({
+      .placementId = [self currentPlacementId],
+      .code = RCTStringFromNSString(codeName),
+      .message = RCTStringFromNSString(message),
+      .cause = RCTStringFromNSString(cause),
+      // The ternary's common type is NSInteger, which the Int32 braced initialiser rejects as
+      // narrowing (-Wc++11-narrowing).
+      .dismissCode = static_cast<int32_t>(
+          dismissCode != nil ? dismissCode.integerValue : kInsiderAppFramesNoDismissCode),
+  });
+}
+
+// The height is applied in JS: Fabric assigns frames without Auto Layout, so the native view's
+// intrinsicContentSize is never consulted.
+- (void)appFramesView:(InsiderAppFramesView *)view didRequestHeightChangeTo:(CGFloat)optimalHeight {
+  auto emitter = [self frameEventEmitter];
+  if (emitter) {
+    emitter->onHeightChange({
+        .placementId = [self currentPlacementId],
+        .height = static_cast<double>(optimalHeight),
+    });
+  }
+}
+
+- (void)appFramesViewDidRequestDismiss:(InsiderAppFramesView *)view {
+  auto emitter = [self frameEventEmitter];
+  if (emitter) {
+    emitter->onDismissRequest({.placementId = [self currentPlacementId]});
+  }
+}
+
+- (void)appFramesView:(InsiderAppFramesView *)view
+    didTriggerActionWithData:(NSDictionary<NSString *, id> *)actionData {
+  auto emitter = [self frameEventEmitter];
+  if (!emitter) {
+    return;
+  }
+
+  NSString *json = nil;
+  if ([NSJSONSerialization isValidJSONObject:actionData]) {
+    NSData *data = [NSJSONSerialization dataWithJSONObject:actionData options:0 error:nil];
+    if (data) {
+      json = [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding];
+    }
+  }
+  if (!json) {
+    // The payload is lost either way, since the codegen field is non-nullable; the report is what
+    // makes the loss visible.
+    [Insider sendError:[NSException exceptionWithName:@"InsiderAppFrameUnserializableAction"
+                                               reason:@"Action data could not be serialized; forwarding {}."
+                                             userInfo:nil]
+                  desc:[NSString stringWithFormat:@"%s:%d", __func__, __LINE__]];
+    json = @"{}";
+  }
+
+  emitter->onAction({
+      .placementId = [self currentPlacementId],
+      .data = RCTStringFromNSString(json),
+  });
+}
+
+@end
+
+#else // !INSIDER_APP_FRAMES_AVAILABLE
+
+// The only signal for this configuration: the inert stub registers cleanly and nothing at runtime
+// reports it. `#pragma message` rather than `#warning`, so a -Werror build does not break over it.
+#pragma message("[Insider] App Frames is unavailable in the linked InsiderMobile, so InsiderAppFrameView compiles as an inert stub: it registers, renders nothing and emits no events. Update InsiderMobile to 16.0.0 or later.")
+
+@implementation RNInsiderAppFrameView
+
++ (ComponentDescriptorProvider)componentDescriptorProvider {
+  return concreteComponentDescriptorProvider<InsiderAppFrameViewComponentDescriptor>();
+}
+
+@end
+
+// The header declares these unconditionally, so they are defined here to avoid a link error.
+NSString *RNInsiderAppFramesErrorCodeNameForError(__unused NSError *error) {
+  return @"UNKNOWN";
+}
+
+NSString *RNInsiderAppFramesStatusNameForRawStatus(__unused NSInteger status) {
+  return @"UNRECOGNIZED";
+}
+
+#endif // INSIDER_APP_FRAMES_AVAILABLE
+
+Class<RCTComponentViewProtocol> InsiderAppFrameViewCls(void) {
+  return RNInsiderAppFrameView.class;
+}
+
+#endif // RCT_NEW_ARCH_ENABLED

package/ios/RNInsider/RNNotificationHandler.h

@@ -15,6 +15,7 @@
 #endif
 
 @interface RNNotificationHandler : RCTEventEmitter<RCTBridgeModule>
+
 extern NSString * const NOTIFICATION_OPEN;
 extern NSString * const INAPP_BUTTON_CLICK;
 extern NSString * const TEMP_STORE_PURCHASE;
@@ -24,6 +25,8 @@ extern NSString * const INAPP_SEEN;
 extern NSString * const FOREGROUND_PUSH;
 extern NSString * const INSIDER_ID_LISTENER;
 extern NSString * const SESSION_STARTED;
+extern NSString * const INSIDER_EVENT_RECORDED;
+
+- (void)sendDataToJS:(NSString *)eventName data:(NSDictionary *)data;
 
--(void)sendDataToJS:(NSString *)eventName data:(NSDictionary *)data;
 @end

package/ios/RNInsider/RNNotificationHandler.m

@@ -24,36 +24,34 @@ NSString * const INAPP_SEEN = @"INAPP_SEEN";
 NSString * const FOREGROUND_PUSH = @"FOREGROUND_PUSH";
 NSString * const INSIDER_ID_LISTENER = @"INSIDER_ID_LISTENER";
 NSString * const SESSION_STARTED = @"SESSION_STARTED";
+NSString * const INSIDER_EVENT_RECORDED = @"INSIDER_EVENT_RECORDED";
 
 static RNNotificationHandler *notificationHandler;
 
-+(id)allocWithZone:(struct _NSZone *)zone{
-    @try {
-        static dispatch_once_t onceToken;
-        dispatch_once(&onceToken, ^{
-            notificationHandler = [super allocWithZone:zone];
-        });
-        return notificationHandler;
-    } @catch (NSException *e) {
-        [Insider sendError:e desc:@"RNNotificationHandler.m - allocWithZone"];
-    }
++ (id)allocWithZone:(struct _NSZone *)zone {
+    static dispatch_once_t onceToken;
+    dispatch_once(&onceToken, ^{
+        notificationHandler = [super allocWithZone:zone];
+    });
+
+    return notificationHandler;
+}
+
++ (BOOL)requiresMainQueueSetup {
+    return NO;
 }
 
 RCT_EXPORT_MODULE();
 
--(NSArray<NSString *> *)supportedEvents{
-    return @[NOTIFICATION_OPEN, INAPP_BUTTON_CLICK, TEMP_STORE_PURCHASE, TEMP_STORE_ADDED_TO_CART, TEMP_STORE_CUSTOM_ACTION, INAPP_SEEN, FOREGROUND_PUSH, INSIDER_ID_LISTENER, SESSION_STARTED];
+- (NSArray<NSString *> *)supportedEvents {
+    return @[NOTIFICATION_OPEN, INAPP_BUTTON_CLICK, TEMP_STORE_PURCHASE, TEMP_STORE_ADDED_TO_CART, TEMP_STORE_CUSTOM_ACTION, INAPP_SEEN, FOREGROUND_PUSH, INSIDER_ID_LISTENER, SESSION_STARTED, INSIDER_EVENT_RECORDED];
 }
 
--(void)sendDataToJS:(NSString *)eventName data:(NSDictionary *)data {
+- (void)sendDataToJS:(NSString *)eventName data:(NSDictionary *)data {
     @try {
-        if (!notificationHandler){
-            [Insider sendError:nil desc:@"RNNotificationHandler.m - sendDataToJS. NotificationHandler is not initialized."];
-            return;
-        }
         [self sendEventWithName:eventName body:data];
     } @catch (NSException *e) {
-        [Insider sendError:e desc:@"RNNotificationHandler.m - sendDataToJS"];
+        [Insider sendError:e desc:[NSString stringWithFormat:@"%s:%d", __func__, __LINE__]];
     }
 }
 @end

package/ios/RNInsider/RNUtils.h

@@ -25,6 +25,8 @@
 
 + (nonnull NSDictionary<NSString *, id> *)parseCustomParameters:(nonnull NSArray *)customParameters;
 
++ (nonnull NSDictionary<NSString *, id> *)convertParametersForBridge:(nullable NSDictionary *)parameters;
+
 + (nonnull NSString *)mapAppCardsErrorCode:(nonnull NSError *)error;
 + (nonnull NSDictionary *)appCardsErrorToDictionary:(nonnull NSError *)error;
 

package/ios/RNInsider/RNUtils.m

@@ -283,6 +283,85 @@
     return mappedCustomParameters;
 }
 
+/**
+ * Normalizes a recorded-event `parameters` dictionary into values React Native's bridge
+ * can actually serialize, mirroring Android's `RNUtils.convertObjectMapToWritableMap`.
+ *
+ * WHY THIS IS NOT OPTIONAL: RN converts an Obj-C payload with
+ * `convertIdToFollyDynamic` (ReactCommon/react/utils/platform/ios/react/utils/FollyConvert.mm).
+ * That function dispatches ONLY on NSNumber / NSString / NSArray / NSDictionary / nil /
+ * NSNull. Anything else — NSDate above all, but also NSURL, NSData, NSUUID — falls off
+ * the end of the chain and hits `return nil`, producing a NULL folly::dynamic. The key
+ * survives but its value silently arrives in JS as `null`, so a `Date` parameter that
+ * Android delivers as epoch-millis would reach an iOS integrator as nothing at all.
+ *
+ * Conversions applied, recursively through nested dictionaries and arrays:
+ *   - NSDate   -> epoch MILLISECONDS as an NSNumber, matching Android's
+ *                 `map.putDouble(key, ((Date) value).getTime())` and the repo's
+ *                 epoch-millis bridge convention for dates.
+ *   - NSNull   -> preserved (RN maps it to JS `null`).
+ *   - Anything else non-serializable -> its `description`, so ONE odd value degrades to a
+ *                 readable string instead of vanishing.
+ *
+ * NOTE: this is only about `Date`s nested INSIDE `parameters`. The top-level `timestamp`
+ * of a recorded event stays in WHOLE SECONDS by explicit product decision — see
+ * `RNInsiderEventListener.onEventRecorded` in RNInsider.m.
+ */
++ (NSDictionary<NSString *, id> *)convertParametersForBridge:(NSDictionary *)parameters {
+    if (![parameters isKindOfClass:[NSDictionary class]]) {
+        return @{};
+    }
+
+    NSMutableDictionary<NSString *, id> *converted = [NSMutableDictionary dictionaryWithCapacity:parameters.count];
+
+    for (id key in parameters) {
+        // The bridge can only key an object by a string.
+        NSString *stringKey = [key isKindOfClass:[NSString class]] ? (NSString *)key : [key description];
+        if (stringKey == nil) continue;
+
+        converted[stringKey] = [self convertValueForBridge:parameters[key]];
+    }
+
+    return converted;
+}
+
+/// Recursive leaf/branch conversion backing `convertParametersForBridge:`.
++ (id)convertValueForBridge:(id)value {
+    if (value == nil || value == [NSNull null]) {
+        return [NSNull null];
+    }
+
+    if ([value isKindOfClass:[NSDictionary class]]) {
+        return [self convertParametersForBridge:(NSDictionary *)value];
+    }
+
+    if ([value isKindOfClass:[NSArray class]]) {
+        NSArray *array = (NSArray *)value;
+        NSMutableArray *convertedArray = [NSMutableArray arrayWithCapacity:array.count];
+
+        for (id element in array) {
+            [convertedArray addObject:[self convertValueForBridge:element]];
+        }
+
+        return convertedArray;
+    }
+
+    // NSDate -> epoch millis. Checked before the NSNumber/NSString passthrough because a
+    // date is the value type that actually motivated this converter.
+    if ([value isKindOfClass:[NSDate class]]) {
+        NSTimeInterval seconds = [(NSDate *)value timeIntervalSince1970];
+        return @((long long)llround(seconds * 1000.0));
+    }
+
+    // NSNumber (incl. booleans) and NSString cross the bridge untouched.
+    if ([value isKindOfClass:[NSNumber class]] || [value isKindOfClass:[NSString class]]) {
+        return value;
+    }
+
+    // Unknown leaf: degrade to a readable string rather than letting RN null it out.
+    return [value description] ?: [NSNull null];
+}
+
 + (NSString *)mapAppCardsErrorCode:(NSError *)error {
     if ([error.domain isEqualToString:InsiderAppCardsErrorDomain]) {
         switch (error.code) {

package/package.json

@@ -1,12 +1,16 @@
 {
     "name": "react-native-insider",
-    "version": "8.1.0",
+    "version": "9.0.0-nh",
     "description": "React Native Insider SDK",
     "main": "index.js",
     "types": "index.d.ts",
     "scripts": {
         "test": "jest",
-        "test:coverage": "jest --coverage --coverageReporters=text --coverageReporters=lcov --coverageReporters=json-summary"
+        "test:unit": "jest --selectProjects unit",
+        "test:integration": "jest --selectProjects integration",
+        "test:coverage": "jest --coverage --coverageReporters=text --coverageReporters=lcov --coverageReporters=json-summary",
+        "test:mutation": "stryker run",
+        "typecheck": "tsc --noEmit"
     },
     "keywords": [
         "react-native",
@@ -20,23 +24,50 @@
     ],
     "author": "insidermobile",
     "homepage": "https://github.com/useinsider/react-native-insider",
+    "peerDependencies": {
+        "react": ">=18.0.0",
+        "react-native": ">=0.74.0"
+    },
     "devDependencies": {
-        "@babel/core": "^7.20.0",
+        "@babel/core": "^7.29.6",
         "@babel/preset-env": "^7.20.0",
         "@react-native/babel-preset": "0.83.0",
-        "babel-jest": "^30.2.0",
+        "@stryker-mutator/core": "^9.6.1",
+        "@stryker-mutator/jest-runner": "^9.6.1",
+        "@testing-library/react-native": "^14.0.1",
+        "babel-jest": "^29.7.0",
         "jest": "^29.7.0",
+        "jest-config": "^29.7.0",
+        "jest-util": "^29.7.0",
         "react": "19.2.0",
-        "react-native": "0.83.0"
+        "react-native": "0.83.0",
+        "react-test-renderer": "19.2.0",
+        "typescript": "^5.9.3"
     },
     "overrides": {
-        "shell-quote": "^1.8.4"
+        "shell-quote": "^1.9.0",
+        "js-yaml": "^3.15.2",
+        "brace-expansion": "^1.1.18",
+        "@stryker-mutator/core": {
+            "minimatch": {
+                "brace-expansion": "^5.0.8"
+            }
+        },
+        "browserslist": "^4.28.7",
+        "baseline-browser-mapping": "^2.11.0",
+        "ws": "^7.5.11"
     },
-    "jest": {
-        "preset": "react-native",
-        "modulePathIgnorePatterns": [
-            "<rootDir>/example/node_modules",
-            "<rootDir>/lib/"
-        ]
+    "codegenConfig": {
+        "name": "RNInsiderSpec",
+        "type": "components",
+        "jsSrcsDir": "src/specs",
+        "android": {
+            "javaPackageName": "com.useinsider.react"
+        },
+        "ios": {
+            "componentProvider": {
+                "InsiderAppFrameView": "RNInsiderAppFrameView"
+            }
+        }
     }
 }

package/src/EventHandler.js

@@ -0,0 +1,17 @@
+import { NativeModules, NativeEventEmitter } from 'react-native';
+
+const NotificationHandler = NativeModules.RNNotificationHandler;
+
+/**
+ * The single NativeEventEmitter for `RNNotificationHandler`, shared by every module that
+ * listens to native → JS events (`index.js` for the init/push/ID callbacks,
+ * `src/InsiderEvents.js` for the recorded-event stream).
+ *
+ * It MUST stay a single instance. Constructing a second emitter over the same native
+ * module would make the native side see two independent listener sets, so listener
+ * bookkeeping (`addListener` counts, `removeAllListeners`) would be split across emitters
+ * and each side would be blind to the other's subscriptions.
+ */
+const eventHandler = new NativeEventEmitter(NotificationHandler);
+
+export default eventHandler;

package/src/InsiderAppFrame.d.ts

@@ -0,0 +1,45 @@
+import type {ForwardRefExoticComponent, RefAttributes} from 'react';
+import type {ViewProps} from 'react-native';
+import type {InsiderAppFramesError} from './InsiderAppFramesError';
+import type {InsiderAppFrameStatusType} from './InsiderAppFrameStatus';
+
+export interface InsiderAppFrameProps extends ViewProps {
+  /** The placement whose content this frame renders. */
+  placementId: string;
+  /** Called on every status transition with the new status and the one it replaced. */
+  onStatusChange?: (
+    status: InsiderAppFrameStatusType,
+    previousStatus: InsiderAppFrameStatusType,
+  ) => void;
+  /** Called when resolving, downloading or rendering the content fails. */
+  onLoadError?: (error: InsiderAppFramesError) => void;
+  /**
+   * Called when the content reports a new height, in dp. The frame applies this height itself
+   * unless `style.height` is set, which always wins.
+   */
+  onHeightChange?: (height: number) => void;
+  /** Called when the content asks to be dismissed. A request, not a command. */
+  onDismissRequest?: () => void;
+  /** Called with the payload of a custom action defined in the content. */
+  onAction?: (data: Record<string, unknown>) => void;
+}
+
+/** Imperative access to a frame's current state, through a ref. */
+export interface InsiderAppFrameHandle {
+  /** The frame's current status; `DETACHED` until the first transition. */
+  getStatus(): InsiderAppFrameStatusType;
+  /** The error behind the current status; non-null only while the status is an `ERROR_*` value. */
+  getError(): InsiderAppFramesError | null;
+}
+
+/**
+ * Renders the content of an App Frames placement.
+ *
+ * On iOS, requires the New Architecture and React Native 0.77 or later. Without the New
+ * Architecture the frame renders nothing; below 0.77 it may not register. Either case logs a
+ * one-time warning in development.
+ */
+declare const InsiderAppFrame: ForwardRefExoticComponent<
+  InsiderAppFrameProps & RefAttributes<InsiderAppFrameHandle>
+>;
+export default InsiderAppFrame;