@amplytools/react-native-amply-sdk 0.4.0 → 0.5.0

package/ios/Sources/AmplyReactNative/AmplyModule.mm

@@ -44,14 +44,69 @@ static NSString* AmplyLogLevelToString(AmplyLogLevel level) {
     return @"none";
 }
 
+// Maps a JS-reported result string to the KMP CampaignResult enum. Strict semantics:
+// anything other than a deliberate user "Dismissed" or explicit "Completed" fails open
+// to Unavailable (proceed) — never strand the continuation on a malformed value.
+static ASDKCampaignResult* AmplyCampaignResultFromString(NSString *result) {
+    if ([result isEqualToString:@"Completed"]) return ASDKCampaignResult.completed;
+    if ([result isEqualToString:@"Dismissed"]) return ASDKCampaignResult.dismissed;
+    if ([result isEqualToString:@"Unavailable"]) return ASDKCampaignResult.unavailable;
+    RCTLogWarn(@"[AmplyReactNative] Unknown campaign result '%@'; treating as Unavailable (fail-open)", result);
+    return ASDKCampaignResult.unavailable;
+}
+
+// Gate-side protocol names confirmed against the published KMP 0.5.0-SNAPSHOT Obj-C header
+// (AmplySDK.xcframework): ASDKCampaignPresenter (present(params:info:resolution:) + dismiss())
+// and ASDKCampaignResolution (resolve(result:)).
+@class AmplyGatePresenter;
+
+// The module owns the GLOBAL routing table and the JS emitter; each registered gate gets its
+// OWN AmplyGatePresenter instance (below) that owns the per-gate "current presentation" slot.
 @interface Amply : NativeAmplyModuleSpecBase <NativeAmplyModuleSpec, ASDKDeepLinkListener, ASDKSystemEventsListener, ASDKLogListener>
 @property (nonatomic, strong) ASDKAmply *amplyInstance;
 @property (nonatomic, assign) BOOL deepLinkListenerRegistered;
+@property (nonatomic, assign) BOOL gateRegistered;
 @property (nonatomic, assign) BOOL systemEventsListenerRegistered;
 @property (nonatomic, assign) BOOL lifecycleObserversRegistered;
 @property (nonatomic, assign) BOOL logListenerRegistered;
 @property (nonatomic, assign) AmplyLogLevel currentLogLevel;
 @property (nonatomic, strong) NSMutableArray<void (^)(ASDKAmply *)> *pendingPropertyOps;
+// Global routing table: mediationId -> the KMP CampaignResolution token awaiting a JS reply.
+// Shared across every registered gate because resolveCampaign(mediationId) routes by exact id —
+// that lookup is correct regardless of which gate minted the id. Guarded by @synchronized(self).
+@property (nonatomic, strong) NSMutableDictionary<NSString *, id<ASDKCampaignResolution>> *pendingCompletions;
+// Retains the per-gate presenter instances; the KMP gate registry does not keep them alive.
+@property (nonatomic, strong) NSMutableArray<AmplyGatePresenter *> *gatePresenters;
+
+// Internal hooks used by AmplyGatePresenter (one instance per registerGate).
+- (id<ASDKCampaignResolution>)takePendingCompletionForMediationId:(NSString *)mediationId;
+- (void)parkPendingCompletion:(id<ASDKCampaignResolution>)resolution forMediationId:(NSString *)mediationId;
+- (void)emitGatePresent:(NSDictionary *)payload;
+@end
+
+/**
+ * One ASDKCampaignPresenter per registerGate registration (per url-pattern).
+ *
+ * Concurrency model: KMP presents at most one gate per url-pattern at a time (the gate is modal —
+ * you cannot show two rewarded ads, or two presentations of the same pattern, at once). KMP's
+ * -dismiss is parameterless and is dispatched to the SPECIFIC presenter instance registered for
+ * that pattern. So the "which presentation does my dismiss() target" state must live PER-PRESENTER,
+ * here in `activeMediationId` — NOT in one global slot on the module. With one global slot, an
+ * overlap of two different-pattern gates (A present, B present, A dismiss) routes A's dismiss to
+ * B's token. Per-instance state makes A's dismiss abandon only A's own live presentation.
+ *
+ * Concurrent presentations of the SAME url-pattern are not supported: a second -present overwrites
+ * `activeMediationId`, so a later -dismiss targets the latest. That is acceptable and intended
+ * given the modal contract above. The module's pendingCompletions stays global (lookup by exact id
+ * is always correct), so a JS resolveCampaign for the overwritten id still settles its own token.
+ */
+@interface AmplyGatePresenter : NSObject <ASDKCampaignPresenter>
+@property (nonatomic, weak) Amply *module;
+@property (nonatomic, copy) NSString *baseUrl;
+// The mediationId this presenter most recently -present'ed and has not yet resolved/abandoned.
+// -dismiss targets exactly this id, so it can only ever release THIS gate's live presentation.
+// Guarded by @synchronized(self); only ever holds a live id (cleared when its token is taken).
+@property (nonatomic, copy) NSString *activeMediationId;
 @end
 
 @implementation Amply
@@ -209,6 +264,204 @@ RCT_EXPORT_MODULE()
   }
 }
 
+// Maps the KMP GateDecision enum/sealed value to the JS-facing decision map:
+//   { outcome: "proceed", reason: "completed" | "failOpen" } | { outcome: "cancelled" }
+// The raw CampaignResult is never surfaced — the SDK collapses it into GateDecision.
+static NSDictionary *AmplyGateDecisionToMap(ASDKGateDecision *decision) {
+  // Proceed carries a `reason` (Completed / FailOpen); Cancelled carries nothing.
+  if ([decision isKindOfClass:[ASDKGateDecisionProceed class]]) {
+    ASDKGateDecisionProceed *proceed = (ASDKGateDecisionProceed *)decision;
+    NSString *reason = @"failOpen";
+    if (proceed.reason == ASDKProceedReason.completed) {
+      reason = @"completed";
+    }
+    return @{@"outcome": @"proceed", @"reason": reason};
+  }
+  // Cancelled — or any unexpected shape — collapses to its terminal outcome. A
+  // Cancelled value is the only non-proceed terminal in the frozen API.
+  if ([decision isKindOfClass:[ASDKGateDecisionCancelled class]]) {
+    return @{@"outcome": @"cancelled"};
+  }
+  // Defensive: an unknown decision subtype fails open rather than stranding the caller.
+  RCTLogWarn(@"[AmplyReactNative] Unknown GateDecision subtype; failing open");
+  return @{@"outcome": @"proceed", @"reason": @"failOpen"};
+}
+
+/**
+ * Gated form of track. Backed by the K/N-generated async selector for the KMP
+ * `suspend fun trackGated(event:props:): GateDecision`. The resolve block is settled
+ * exactly once with the collapsed decision map; __block + a settled flag guards the
+ * (defensive) double-settle. This NEVER rejects: not-initialized, a thrown exception,
+ * or a K/N error all fail open to { outcome: "proceed", reason: "failOpen" }.
+ */
+- (void)trackGated:(NSString *)event
+        properties:(NSDictionary *)properties
+           resolve:(RCTPromiseResolveBlock)resolve
+            reject:(RCTPromiseRejectBlock)reject
+{
+  if (!event || event.length == 0) {
+    // Even an invalid event fails open rather than rejecting — the JS contract is
+    // "trackGated never rejects".
+    RCTLogWarn(@"[AmplyReactNative] trackGated with empty event; failing open");
+    if (resolve) { resolve(@{@"outcome": @"proceed", @"reason": @"failOpen"}); }
+    return;
+  }
+
+  NSDictionary *props = [properties isKindOfClass:[NSDictionary class]] ? properties : @{};
+
+  // Contract: resolve EXACTLY ONCE, ON MAIN. Every settle path — fail-open before init, the
+  // K/N success completion, the K/N error/cancellation completion, and the @catch — funnels
+  // through here. We always hop to the main queue (which serializes the once-guard, so the
+  // flag needs no further synchronization) and resolve at most once.
+  __block BOOL settled = NO;
+  void (^settle)(NSDictionary *) = ^(NSDictionary *decision) {
+    dispatch_async(dispatch_get_main_queue(), ^{
+      if (settled) { return; }
+      settled = YES;
+      if (resolve) {
+        resolve(decision);
+      }
+    });
+  };
+  NSDictionary *failOpen = @{@"outcome": @"proceed", @"reason": @"failOpen"};
+
+  if (!self.amplyInstance) {
+    // Fail open: not initialized -> proceed immediately (KMP gate state-machine row 1).
+    RCTLogWarn(@"[AmplyReactNative] trackGated before init; failing open");
+    settle(failOpen);
+    return;
+  }
+
+  @try {
+    // Confirmed against the published KMP 0.5.0-SNAPSHOT header: the ASDKAmply facade's
+    // `suspend fun trackGated(event:properties:)` projects to
+    // `-trackGatedEvent:properties:completionHandler:` with a (ASDKGateDecision*, NSError*) handler.
+    [self.amplyInstance trackGatedEvent:event
+                             properties:props
+                      completionHandler:^(ASDKGateDecision *decision, NSError *error) {
+      if (error) {
+        // A coroutine error/cancellation fails open — never strand the caller. settle() routes
+        // this onto main with the same once-guard as the success path (resolve once, on main).
+        RCTLogWarn(@"[AmplyReactNative] trackGated coroutine error; failing open: %@", error.localizedDescription);
+        settle(failOpen);
+        return;
+      }
+      // settle() already hops to main to match the deeplink/present delivery contract.
+      settle(AmplyGateDecisionToMap(decision));
+    }];
+    RCTLogInfo(@"[AmplyReactNative] trackGated dispatched: %@", event);
+  } @catch (NSException *exception) {
+    RCTLogError(@"[AmplyReactNative] trackGated threw; failing open: %@", exception.reason);
+    settle(failOpen);
+  }
+}
+
+/**
+ * Atomically removes and returns the token parked under `mediationId` from the GLOBAL routing
+ * table. Returning the token to exactly one caller is what makes resolve and dismiss mutually-
+ * exclusive and at-most-once: whoever takes the token first owns the outcome; every later path
+ * gets nil and becomes a no-op. This is the single point that prevents the pending-resolution
+ * leak on timeout/cancel/dismiss. (The per-gate "current presentation" slot lives on each
+ * AmplyGatePresenter, not here — the presenter clears its own slot around -dismiss.)
+ */
+- (id<ASDKCampaignResolution>)takePendingCompletionForMediationId:(NSString *)mediationId
+{
+  if (!mediationId) { return nil; }
+  @synchronized (self) {
+    if (!self.pendingCompletions) { return nil; }
+    id<ASDKCampaignResolution> token = self.pendingCompletions[mediationId];
+    if (token) {
+      [self.pendingCompletions removeObjectForKey:mediationId];
+    }
+    return token;
+  }
+}
+
+/** Parks a resolution token in the global routing table under `mediationId`. */
+- (void)parkPendingCompletion:(id<ASDKCampaignResolution>)resolution forMediationId:(NSString *)mediationId
+{
+  @synchronized (self) {
+    if (!self.pendingCompletions) {
+      self.pendingCompletions = [NSMutableDictionary new];
+    }
+    self.pendingCompletions[mediationId] = resolution;
+  }
+}
+
+/** Surfaces a gate present dispatch to JS. Emitter delivery is async; hop to main to match deeplink. */
+- (void)emitGatePresent:(NSDictionary *)payload
+{
+  dispatch_async(dispatch_get_main_queue(), ^{
+    [self emitOnCampaignPresent:payload];
+  });
+}
+
+- (void)resolveCampaign:(NSString *)mediationId
+                 result:(NSString *)result
+{
+  id<ASDKCampaignResolution> completion = [self takePendingCompletionForMediationId:mediationId];
+  if (!completion) {
+    // Late/duplicate/unknown reply — the SDK token is the source of truth and is
+    // already settled (or never existed). Ignore.
+    RCTLogInfo(@"[AmplyReactNative] resolveCampaign for unknown/settled mediationId=%@; ignored", mediationId);
+    return;
+  }
+  ASDKCampaignResult *mapped = AmplyCampaignResultFromString(result);
+  RCTLogInfo(@"[AmplyReactNative] resolveCampaign mediationId=%@ result=%@", mediationId, result);
+  // Confirmed against the published header: CampaignResolution.resolve(result:) projects to
+  // -resolveResult:.
+  [completion resolveResult:mapped];
+}
+
+/**
+ * Register the bridge as the gate presenter for `baseUrl`. JS is the single capability
+ * registry and routes by baseUrl on its side; the native gate carries the abort policy
+ * and timeout.
+ *
+ * FLAG (native-compile gate): the frozen KMP 0.5.0 API is
+ *   `registerGate(baseUrl, presenter, onAbort, timeoutMs)`.
+ * The selector below is written to the documented K/N convention
+ * (`-registerGateBaseUrl:presenter:onAbort:timeoutMs:`) and the ASDKAbortPolicy
+ * enum-case names (.cancel / .proceed) are assumed. BOTH the selector and the
+ * AbortPolicy projection MUST be confirmed against the published header before publish.
+ *
+ * Each registration gets its OWN AmplyGatePresenter instance owning its OWN "current
+ * presentation" slot, so a dismiss() delivered to this gate's presenter can only abandon THIS
+ * gate's live presentation — never one belonging to a different url-pattern's gate.
+ */
+- (void)registerGate:(NSString *)baseUrl
+             onAbort:(NSString *)onAbort
+           timeoutMs:(double)timeoutMs
+{
+  if (!self.amplyInstance) {
+    RCTLogWarn(@"[AmplyReactNative] Cannot register gate - Amply not initialized");
+    return;
+  }
+  if (!self.pendingCompletions) {
+    self.pendingCompletions = [NSMutableDictionary new];
+  }
+  if (!self.gatePresenters) {
+    self.gatePresenters = [NSMutableArray new];
+  }
+
+  ASDKAbortPolicy *policy = [onAbort isEqualToString:@"proceed"]
+      ? ASDKAbortPolicy.proceed
+      : ASDKAbortPolicy.cancel;
+
+  AmplyGatePresenter *presenter = [[AmplyGatePresenter alloc] init];
+  presenter.module = self;
+  presenter.baseUrl = baseUrl;
+  // Retain the presenter — the KMP gate registry does not keep it alive.
+  [self.gatePresenters addObject:presenter];
+
+  RCTLogInfo(@"[AmplyReactNative] Registering gate baseUrl=%@ onAbort=%@ timeoutMs=%f", baseUrl, onAbort, timeoutMs);
+  [self.amplyInstance registerGateBaseUrl:baseUrl
+                                presenter:presenter
+                                  onAbort:policy
+                                timeoutMs:(int64_t)timeoutMs];
+  self.gateRegistered = YES;
+}
+
 - (void)getRecentEvents:(double)limit
                 resolve:(RCTPromiseResolveBlock)resolve
                  reject:(RCTPromiseRejectBlock)reject
@@ -675,6 +928,22 @@ static ASDKDataSetType *AmplyDataSetTypeFromDictionary(NSDictionary *type, NSStr
 - (void)dealloc
 {
   [[NSNotificationCenter defaultCenter] removeObserver:self];
+
+  // Fail open any in-flight gate presentations so no caller is left hanging. Each per-gate
+  // presenter clears its own current-presentation slot when its token is taken below; on dealloc
+  // the presenters themselves are released with the module.
+  NSArray<id<ASDKCampaignResolution>> *inFlight = nil;
+  @synchronized (self) {
+    inFlight = self.pendingCompletions.allValues;
+    [self.pendingCompletions removeAllObjects];
+  }
+  for (id<ASDKCampaignResolution> completion in inFlight) {
+    @try {
+      [completion resolveResult:ASDKCampaignResult.unavailable];
+    } @catch (NSException *exception) {
+      // Best-effort cleanup during teardown.
+    }
+  }
 }
 
 #pragma mark - ASDKSystemEventsListener
@@ -732,3 +1001,83 @@ static ASDKDataSetType *AmplyDataSetTypeFromDictionary(NSDictionary *type, NSStr
 }
 
 @end
+
+#pragma mark - AmplyGatePresenter (one instance per registerGate / url-pattern)
+
+@implementation AmplyGatePresenter
+
+/**
+ * Called by the KMP SDK when this gate dispatches its (blocking) presentation. We mint a
+ * mediationId, park the resolution token in the module's GLOBAL routing table, record it as
+ * THIS presenter's current presentation, and surface the dispatch to JS. JS later replies via
+ * resolveCampaign:result: (which routes by exact id, so it is unaffected by overlap).
+ *
+ * Confirmed against the published header: the presenter signature is
+ *   `present(params:info:resolution:)` -> `-presentParams:info:resolution:`,
+ * with params projected as NSDictionary<NSString *, NSString *>.
+ */
+- (void)presentParams:(NSDictionary<NSString *, NSString *> *)params
+                 info:(NSDictionary<NSString *, id> *)info
+           resolution:(id<ASDKCampaignResolution>)resolution
+{
+  Amply *module = self.module;
+  if (!module) {
+    // Module gone (teardown race) — drop the token so the SDK's own abort machinery proceeds.
+    RCTLogWarn(@"[AmplyReactNative] Gate[%@] present after module teardown; dropping", self.baseUrl);
+    return;
+  }
+
+  NSString *mediationId = [[NSUUID UUID] UUIDString];
+  [module parkPendingCompletion:resolution forMediationId:mediationId];
+  // Record THIS gate's live presentation so -dismiss releases exactly this token on abandon. A
+  // second present() on this same presenter overwrites it (concurrent same-pattern not supported;
+  // latest wins) — the prior id still lives in the global table for its own JS reply.
+  @synchronized (self) {
+    self.activeMediationId = mediationId;
+  }
+
+  // `info` carries the action url under @"url"; surface it for JS-side baseUrl routing.
+  NSString *url = [info[@"url"] isKindOfClass:[NSString class]] ? info[@"url"] : @"";
+
+  RCTLogInfo(@"[AmplyReactNative] Gate[%@] dispatching present mediationId=%@ url=%@", self.baseUrl, mediationId, url);
+
+  NSDictionary *payload = @{
+    @"url": url,
+    @"params": params ?: @{},
+    @"info": info ?: @{},
+    @"mediationId": mediationId
+  };
+
+  [module emitGatePresent:payload];
+}
+
+/**
+ * Tear down any UI this presenter put on screen WITHOUT producing a result. Called by the SDK
+ * when THIS gate's caller coroutine is cancelled/times out and the resolution token is abandoned.
+ *
+ * Presentation lives entirely in JS here (no native gate UI), so there is nothing to tear down —
+ * BUT the parked token MUST be released or the global pendingCompletions leaks on every
+ * timeout/cancel. We take THIS presenter's current presentation's token (at-most-once via
+ * -takePendingCompletionForMediationId:) and simply drop it: the SDK's own abort machinery owns
+ * the outcome here, so we must NOT also resolve it. A subsequent JS resolveCampaign: for the same
+ * id finds nothing and is a harmless no-op. Crucially, because the active id is per-presenter, an
+ * overlapping different-pattern gate's presentation can never be the one we abandon here.
+ */
+- (void)dismiss
+{
+  NSString *activeId = nil;
+  @synchronized (self) {
+    activeId = self.activeMediationId;
+    self.activeMediationId = nil;
+  }
+  if (!activeId) {
+    RCTLogInfo(@"[AmplyReactNative] Gate[%@] dismiss() with no active presentation", self.baseUrl);
+    return;
+  }
+  Amply *module = self.module;
+  id<ASDKCampaignResolution> abandoned = [module takePendingCompletionForMediationId:activeId];
+  RCTLogInfo(@"[AmplyReactNative] Gate[%@] dismiss() releasing mediationId=%@ (token %@)",
+             self.baseUrl, activeId, abandoned ? @"dropped" : @"already settled");
+}
+
+@end

package/ios/Sources/AmplyReactNative/AmplyReactNative/AmplyReactNative-generated.mm

@@ -23,6 +23,10 @@
 {
   _eventEmitterCallback("onDeepLink", value);
 }
+- (void)emitOnCampaignPresent:(NSDictionary *)value
+{
+  _eventEmitterCallback("onCampaignPresent", value);
+}
 
 - (void)setEventEmitterCallback:(EventEmitterCallbackWrapper *)eventEmitterCallbackWrapper
 {
@@ -56,6 +60,18 @@ namespace facebook::react {
       return static_cast<ObjCTurboModule&>(turboModule).invokeObjCMethod(rt, PromiseKind, "track", @selector(track:resolve:reject:), args, count);
     }
 
+    static facebook::jsi::Value __hostFunction_NativeAmplyModuleSpecJSI_trackGated(facebook::jsi::Runtime& rt, TurboModule &turboModule, const facebook::jsi::Value* args, size_t count) {
+      return static_cast<ObjCTurboModule&>(turboModule).invokeObjCMethod(rt, PromiseKind, "trackGated", @selector(trackGated:properties:resolve:reject:), args, count);
+    }
+
+    static facebook::jsi::Value __hostFunction_NativeAmplyModuleSpecJSI_resolveCampaign(facebook::jsi::Runtime& rt, TurboModule &turboModule, const facebook::jsi::Value* args, size_t count) {
+      return static_cast<ObjCTurboModule&>(turboModule).invokeObjCMethod(rt, VoidKind, "resolveCampaign", @selector(resolveCampaign:result:), args, count);
+    }
+
+    static facebook::jsi::Value __hostFunction_NativeAmplyModuleSpecJSI_registerGate(facebook::jsi::Runtime& rt, TurboModule &turboModule, const facebook::jsi::Value* args, size_t count) {
+      return static_cast<ObjCTurboModule&>(turboModule).invokeObjCMethod(rt, VoidKind, "registerGate", @selector(registerGate:onAbort:timeoutMs:), args, count);
+    }
+
     static facebook::jsi::Value __hostFunction_NativeAmplyModuleSpecJSI_getRecentEvents(facebook::jsi::Runtime& rt, TurboModule &turboModule, const facebook::jsi::Value* args, size_t count) {
       return static_cast<ObjCTurboModule&>(turboModule).invokeObjCMethod(rt, PromiseKind, "getRecentEvents", @selector(getRecentEvents:resolve:reject:), args, count);
     }
@@ -116,6 +132,15 @@ namespace facebook::react {
         methodMap_["track"] = MethodMetadata {1, __hostFunction_NativeAmplyModuleSpecJSI_track};
         setMethodArgConversionSelector(@"track", 0, @"JS_NativeAmplyModule_TrackEventPayload:");
         
+        methodMap_["trackGated"] = MethodMetadata {2, __hostFunction_NativeAmplyModuleSpecJSI_trackGated};
+        
+        
+        methodMap_["resolveCampaign"] = MethodMetadata {2, __hostFunction_NativeAmplyModuleSpecJSI_resolveCampaign};
+        
+        
+        methodMap_["registerGate"] = MethodMetadata {3, __hostFunction_NativeAmplyModuleSpecJSI_registerGate};
+        
+        
         methodMap_["getRecentEvents"] = MethodMetadata {1, __hostFunction_NativeAmplyModuleSpecJSI_getRecentEvents};
         
         
@@ -153,6 +178,7 @@ namespace facebook::react {
         
         eventEmitterMap_["onSystemEvent"] = std::make_shared<AsyncEventEmitter<id>>();
         eventEmitterMap_["onDeepLink"] = std::make_shared<AsyncEventEmitter<id>>();
+        eventEmitterMap_["onCampaignPresent"] = std::make_shared<AsyncEventEmitter<id>>();
         setEventEmitterCallback([&](const std::string &name, id value) {
           static_cast<AsyncEventEmitter<id> &>(*eventEmitterMap_[name]).emit(value);
         });

package/ios/Sources/AmplyReactNative/AmplyReactNative/AmplyReactNative.h

@@ -78,6 +78,15 @@ namespace JS {
 - (void)track:(JS::NativeAmplyModule::TrackEventPayload &)payload
       resolve:(RCTPromiseResolveBlock)resolve
        reject:(RCTPromiseRejectBlock)reject;
+- (void)trackGated:(NSString *)event
+        properties:(NSDictionary *)properties
+           resolve:(RCTPromiseResolveBlock)resolve
+            reject:(RCTPromiseRejectBlock)reject;
+- (void)resolveCampaign:(NSString *)mediationId
+                 result:(NSString *)result;
+- (void)registerGate:(NSString *)baseUrl
+             onAbort:(NSString *)onAbort
+           timeoutMs:(double)timeoutMs;
 - (void)getRecentEvents:(double)limit
                 resolve:(RCTPromiseResolveBlock)resolve
                  reject:(RCTPromiseRejectBlock)reject;
@@ -107,6 +116,7 @@ facebook::react::EventEmitterCallback _eventEmitterCallback;
 
 - (void)emitOnSystemEvent:(NSDictionary *)value;
 - (void)emitOnDeepLink:(NSDictionary *)value;
+- (void)emitOnCampaignPresent:(NSDictionary *)value;
 @end
 
 namespace facebook::react {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amplytools/react-native-amply-sdk",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "React Native SDK for Amply: Mobile SDK to orchestrate in-app experiences and campaigns remotely, without app releases",
   "license": "MIT",
   "repository": {