@attentive-mobile/attentive-react-native-sdk 0.1.0

package/LICENSE

@@ -0,0 +1,20 @@
+MIT License
+
+Copyright (c) 2023 Attentive Mobile
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,140 @@
+# attentive-react-native-sdk
+
+# Attentive React Native SDK
+The Attentive React Native SDK provides the functionality to render Attentive creative units and collect Attentive events in React Native mobile applications.
+
+## Installation
+
+TODO
+
+## Usage
+See the [Example Project](https://github.com/attentive-mobile/attentive-react-native-sdk/blob/main/example)
+for a sample of how the Attentive React Native SDK is used.
+
+__*** NOTE: Please refrain from using any private or undocumented classes or methods as they may change between releases. ***__
+
+### Import the SDK
+
+```typescript
+import { Attentive, <other types you need here> } from 'attentive-react-native-sdk';
+```
+
+### Create the AttentiveConfig
+
+```typescript
+// Create an AttentiveConfiguration with your attentive domain, in production mode
+const config : AttentiveConfiguration = {
+  attentiveDomain: 'YOUR_ATTENTIVE_DOMAIN',
+  mode: Mode.Production,
+}
+```
+```typescript
+// Alternatively, use "debug" mode. When in debug mode, the Creative will not be shown, but instead a popup will show with debug information about your creative and any reason the Creative wouldn't show.
+const config : AttentiveConfiguration = {
+  attentiveDomain: 'YOUR_ATTENTIVE_DOMAIN',
+  mode: Mode.Debug,
+}
+```
+
+### Initialize the SDK
+
+```typescript
+// 'initialize' should be called as soon as possible after the app starts (see the example app for an example of initializing the SDK in the App element)
+// Note: 'initialize' should only be called once per app session - if you call it multiple times it will throw an exception
+Attentive.initialize(config);
+```
+
+
+### Identify the current user
+```typescript
+// Before loading the creative or sending events, if you have any user identifiers, they will need to be registered. Each identifier is optional. It is okay to skip this step if you have no identifiers about the user yet.
+const identifiers : UserIdentifiers = {
+  'phone': '+15556667777',
+  'email': 'some_email@gmailfake.com',
+  'klaviyoId': 'userKlaviyoId',
+  'shopifyId': 'userShopifyId',
+  'clientUserId': 'userClientUserId',
+  'customIdentifiers': { 'customIdKey': 'customIdValue' }
+};
+Attentive.identify(identifiers);
+```
+
+The more identifiers that are passed to `identify`, the better the SDK will function. Here is the list of possible identifiers:
+| Identifier Name    | Type                  | Description                                                                                                             |
+| ------------------ | --------------------- | ----------------------------------------------------------------------------------------------------------------------- |
+| Client User ID     | String                | Your unique identifier for the user. This should be consistent across the user's lifetime. For example, a database id.  |
+| Phone              | String                | The users's phone number in E.164 format                                                                                |
+| Email              | String                | The users's email                                                                                                       |
+| Shopify ID         | String                | The users's Shopify ID                                                                                                  |
+| Klaviyo ID         | String                | The users's Klaviyo ID                                                                                                  | 
+| Custom Identifiers | Map<String,String>    | Key-value pairs of custom identifier names and values. The values should be unique to this user.                        |
+
+### Load the Creative
+#### 1. Create the Creative
+```typescript
+// Trigger the Creative. This will show the Creative as a pop-up over the rest of the app.
+Attentive.triggerCreative();
+```
+
+#### 3. Destroy the Creative
+
+TODO
+
+__*** NOTE: You must call the destroy method when the creative is no longer in use to properly clean up the WebView and it's resources ***__
+
+
+### Record user events
+
+The SDK currently supports `PurchaseEvent`, `AddToCartEvent`, `ProductViewEvent`, and `CustomEvent`.
+
+```typescript
+// Construct one or more "Item"s, which represents the product(s) purchased
+const items : Item[] = [
+        {
+          productId: '555',
+          productVariantId: '777',
+          price: {
+            price: '14.99',
+            currency: 'USD',
+          },
+        },
+      ];
+
+// Construct an "Order", which represents the order for the purchase
+const order : Order = {
+  orderId: '88888'
+}
+
+// (Optional) Construct a "Cart", which represents the cart this Purchase was made from
+const cart : Cart = {
+  cartId: '555555',
+  cartCoupon: 'SOME-DISCOUNT'
+}
+
+// Construct a PurchaseEvent, which ties together the preceding objects
+const purchaseEvent : PurchaseEvent = {
+  items: items,
+  order: order,
+  cart: cart
+}
+
+// Record the PurchaseEvent
+Attentive.recordPurchaseEvent(purchaseEvent);
+```
+
+The process is similar for the other events. See [eventTypes.tsx](https://github.com/attentive-mobile/attentive-react-native-sdk/blob/main/src/eventTypes.tsx) for all events.
+
+### Update the current user when new identifiers are available
+
+```typescript
+// If new identifiers are available for the user, register them
+Attentive.identify({email: 'theusersemail@gmail.com'});
+```
+
+```typescript
+Attentive.identify({email: 'theusersemail@gmail.com'});
+Attentive.identify({phone: '+15556667777'};)
+// The SDK will have these two identifiers:
+//   email: 'theusersemail@gmail.com'
+//   phone: '+15556667777'
+```

package/android/build.gradle

@@ -0,0 +1,92 @@
+buildscript {
+  repositories {
+    google()
+    mavenCentral()
+  }
+
+  dependencies {
+    classpath "com.android.tools.build:gradle:7.2.1"
+  }
+}
+
+def isNewArchitectureEnabled() {
+  return rootProject.hasProperty("newArchEnabled") && rootProject.getProperty("newArchEnabled") == "true"
+}
+
+apply plugin: "com.android.library"
+
+
+def appProject = rootProject.allprojects.find { it.plugins.hasPlugin('com.android.application') }
+
+if (isNewArchitectureEnabled()) {
+  apply plugin: "com.facebook.react"
+}
+
+def getExtOrDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties["AttentiveReactNativeSdk_" + name]
+}
+
+def getExtOrIntegerDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["AttentiveReactNativeSdk_" + name]).toInteger()
+}
+
+android {
+  compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
+
+  defaultConfig {
+    minSdkVersion getExtOrIntegerDefault("minSdkVersion")
+    targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
+    buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled().toString()
+  }
+  buildTypes {
+    release {
+      minifyEnabled false
+    }
+  }
+
+  lintOptions {
+    disable "GradleCompatible"
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_1_8
+    targetCompatibility JavaVersion.VERSION_1_8
+  }
+
+}
+
+Properties ghProperties = new Properties()
+File ghPropertiesFile = file("github.properties")
+if (!ghPropertiesFile.exists()) {
+  throw new GradleException('Could not find github.properties file.')
+}
+ghProperties.load(ghPropertiesFile.newDataInputStream())
+
+repositories {
+  mavenCentral()
+  google()
+  maven {
+    url = uri("https://maven.pkg.github.com/attentive-mobile/attentive-android-sdk")
+    credentials {
+      username = ghProperties.getProperty('gpr.user')
+      password = ghProperties.getProperty('gpr.key')
+    }
+  }
+}
+
+
+dependencies {
+  // For < 0.71, this will be from the local maven repo
+  // For > 0.71, this will be replaced by `com.facebook.react:react-android:$version` by react gradle plugin
+  //noinspection GradleDynamicVersion
+  implementation "com.facebook.react:react-native:+"
+  implementation 'com.attentive:attentive-android-sdk:0.4.0'
+}
+
+if (isNewArchitectureEnabled()) {
+  react {
+    jsRootDir = file("../src/")
+    libraryName = "AttentiveReactNativeSdk"
+    codegenJavaPackageName = "com.attentivereactnativesdk"
+  }
+}

package/android/github.properties

@@ -0,0 +1,2 @@
+gpr.user=wyattjoe40
+gpr.key=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

package/android/gradle.properties

@@ -0,0 +1,5 @@
+AttentiveReactNativeSdk_kotlinVersion=1.7.0
+AttentiveReactNativeSdk_minSdkVersion=21
+AttentiveReactNativeSdk_targetSdkVersion=31
+AttentiveReactNativeSdk_compileSdkVersion=31
+AttentiveReactNativeSdk_ndkversion=21.4.7075529

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,4 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+          package="com.attentivereactnativesdk">
+
+</manifest>

package/android/src/main/java/com/attentivereactnativesdk/AttentiveReactNativeSdkModule.java

@@ -0,0 +1,195 @@
+package com.attentivereactnativesdk;
+
+import android.app.Activity;
+import android.util.Log;
+import android.view.ViewGroup;
+import androidx.annotation.NonNull;
+
+import com.attentive.androidsdk.AttentiveConfig;
+import com.attentive.androidsdk.AttentiveEventTracker;
+import com.attentive.androidsdk.UserIdentifiers;
+import com.attentive.androidsdk.creatives.Creative;
+import com.attentive.androidsdk.events.AddToCartEvent;
+import com.attentive.androidsdk.events.CustomEvent;
+import com.attentive.androidsdk.events.Item;
+import com.attentive.androidsdk.events.Order;
+import com.attentive.androidsdk.events.Price;
+import com.attentive.androidsdk.events.ProductViewEvent;
+import com.attentive.androidsdk.events.PurchaseEvent;
+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.bridge.UiThreadUtil;
+import com.facebook.react.module.annotations.ReactModule;
+import java.math.BigDecimal;
+import java.security.InvalidParameterException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Currency;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+
+@ReactModule(name = AttentiveReactNativeSdkModule.NAME)
+public class AttentiveReactNativeSdkModule extends ReactContextBaseJavaModule {
+  public static final String NAME = "AttentiveReactNativeSdk";
+  private static final String TAG = NAME;
+
+  private AttentiveConfig attentiveConfig;
+
+  public AttentiveReactNativeSdkModule(ReactApplicationContext reactContext) {
+    super(reactContext);
+  }
+
+  @Override
+  @NonNull
+  public String getName() {
+    return NAME;
+  }
+
+  @ReactMethod
+  public void initialize(ReadableMap config) {
+    final String rawMode = config.getString("mode");
+    if (rawMode == null) {
+      throw new IllegalArgumentException("The 'mode' parameter cannot be null.");
+    }
+    final String domain = config.getString("attentiveDomain");
+    attentiveConfig = new AttentiveConfig(domain, AttentiveConfig.Mode.valueOf(rawMode.toUpperCase(Locale.ROOT)), this.getReactApplicationContext());
+    AttentiveEventTracker.getInstance().initialize(attentiveConfig);
+  }
+
+  @ReactMethod
+  public void triggerCreative() {
+    Log.i(TAG, "Native Attentive module was called to trigger the creative.");
+    try {
+      Activity currentActivity = getReactApplicationContext().getCurrentActivity();
+      if (currentActivity != null) {
+        ViewGroup rootView =
+          (ViewGroup) currentActivity.getWindow().getDecorView().getRootView();
+        // The following calls edit the view hierarchy so they must run on the UI thread
+        UiThreadUtil.runOnUiThread(() -> {
+          Creative creative = new Creative(attentiveConfig, rootView);
+          creative.trigger();
+        });
+      } else {
+        Log.w(TAG, "Could not trigger the Attentive Creative because the current Activity was null");
+      }
+    } catch (Exception e) {
+      Log.e(TAG, "Exception when triggering the creative: " + e);
+    }
+  }
+
+  @ReactMethod
+  public void clearUser() {
+    attentiveConfig.clearUser();
+  }
+
+  @ReactMethod
+  public void identify(ReadableMap identifiers) {
+    UserIdentifiers.Builder idsBuilder = new UserIdentifiers.Builder();
+    if (identifiers.hasKey("phone")) {
+      idsBuilder.withPhone(identifiers.getString("phone"));
+    }
+    if (identifiers.hasKey("email")) {
+      idsBuilder.withEmail(identifiers.getString("email"));
+    }
+    if (identifiers.hasKey("klaviyoId")) {
+      idsBuilder.withKlaviyoId(identifiers.getString("klaviyoId"));
+    }
+    if (identifiers.hasKey("shopifyId")) {
+      idsBuilder.withShopifyId(identifiers.getString("shopifyId"));
+    }
+    if (identifiers.hasKey("clientUserId")) {
+      idsBuilder.withClientUserId(identifiers.getString("clientUserId"));
+    }
+    if (identifiers.hasKey("customIdentifiers")) {
+      Map<String, String> customIds = new HashMap<>();
+      Map<String, Object> rawCustomIds = identifiers.getMap("customIdentifiers").toHashMap();
+      for (Map.Entry<String, Object> entry : rawCustomIds.entrySet()) {
+        if (entry.getValue() instanceof String) {
+          customIds.put(entry.getKey(), (String) entry.getValue());
+        }
+      }
+      idsBuilder.withCustomIdentifiers(customIds);
+    }
+
+    attentiveConfig.identify(idsBuilder.build());
+  }
+
+  @ReactMethod
+  public void recordProductViewEvent(ReadableMap productViewAttrs) {
+    Log.i(TAG, "Sending product viewed event");
+
+    List<Item> items = buildItems(productViewAttrs.getArray("items"));
+    ProductViewEvent productViewEvent = new ProductViewEvent.Builder(items).build();
+
+    AttentiveEventTracker.getInstance().recordEvent(productViewEvent);
+  }
+
+  @ReactMethod
+  public void recordPurchaseEvent(ReadableMap purchaseAttrs) {
+    Log.i(TAG, "Sending purchase event");
+    Order order = new Order.Builder(purchaseAttrs.getMap("order").getString("orderId")).build();
+
+    List<Item> items = buildItems(purchaseAttrs.getArray("items"));
+    PurchaseEvent purchaseEvent = new PurchaseEvent.Builder(items, order).build();
+
+    AttentiveEventTracker.getInstance().recordEvent(purchaseEvent);
+  }
+
+  @ReactMethod
+  public void recordAddToCartEvent(ReadableMap addToCartAttrs) {
+    Log.i(TAG, "Sending add to cart event");
+
+    List<Item> items = buildItems(addToCartAttrs.getArray("items"));
+    AddToCartEvent addToCartEvent = new AddToCartEvent.Builder(items).build();
+
+    AttentiveEventTracker.getInstance().recordEvent(addToCartEvent);
+  }
+
+  @ReactMethod
+  public void recordCustomEvent(ReadableMap customEventAttrs) {
+    Log.i(TAG, "Sending custom event");
+    ReadableMap propertiesRawMap = customEventAttrs.getMap("properties");
+    if (propertiesRawMap == null) {
+      throw new IllegalArgumentException("The CustomEvent 'properties' field cannot be null.");
+    }
+    Map<String, String> properties = convertToStringMap(propertiesRawMap.toHashMap());
+    CustomEvent customEvent = new CustomEvent.Builder(customEventAttrs.getString("type"), properties).build();
+
+    AttentiveEventTracker.getInstance().recordEvent(customEvent);
+  }
+
+  private Map<String, String> convertToStringMap(Map<String, Object> inputMap) {
+    Map<String, String> outputMap = new HashMap<>();
+    for (Map.Entry<String, Object> entry : inputMap.entrySet()) {
+      Object entryValue = entry.getValue();
+      if (entryValue == null) {
+        throw new InvalidParameterException(String.format("The key '%s' has a null value.", entry.getKey()));
+      }
+      if (entryValue instanceof String) {
+        outputMap.put(entry.getKey(), (String) entry.getValue());
+      }
+    }
+
+    return outputMap;
+  }
+
+  private List<Item> buildItems(ReadableArray rawItems) {
+    List<Item> items = new ArrayList<>();
+    for (int i = 0; i < rawItems.size(); i++) {
+      ReadableMap rawItem = rawItems.getMap(i);
+
+      ReadableMap priceMap = rawItem.getMap("price");
+      Price price = new Price.Builder(new BigDecimal(priceMap.getString("price")), Currency.getInstance(priceMap.getString("currency"))).build();
+
+      Item item = new Item.Builder(rawItem.getString("productId"), rawItem.getString("productVariantId"), price).build();
+      items.add(item);
+    }
+
+    return items;
+  }
+}

package/android/src/main/java/com/attentivereactnativesdk/AttentiveReactNativeSdkPackage.java

@@ -0,0 +1,28 @@
+package com.attentivereactnativesdk;
+
+import androidx.annotation.NonNull;
+
+import com.facebook.react.ReactPackage;
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.uimanager.ViewManager;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+public class AttentiveReactNativeSdkPackage implements ReactPackage {
+  @NonNull
+  @Override
+  public List<NativeModule> createNativeModules(@NonNull ReactApplicationContext reactContext) {
+    List<NativeModule> modules = new ArrayList<>();
+    modules.add(new AttentiveReactNativeSdkModule(reactContext));
+    return modules;
+  }
+
+  @NonNull
+  @Override
+  public List<ViewManager> createViewManagers(@NonNull ReactApplicationContext reactContext) {
+    return Collections.emptyList();
+  }
+}

package/attentive-react-native-sdk.podspec

@@ -0,0 +1,36 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+folly_compiler_flags = '-DFOLLY_NO_CONFIG -DFOLLY_MOBILE=1 -DFOLLY_USE_LIBCPP=1 -Wno-comma -Wno-shorten-64-to-32'
+
+Pod::Spec.new do |s|
+  s.name         = "attentive-react-native-sdk"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.homepage     = package["homepage"]
+  s.license      = package["license"]
+  s.authors      = package["author"]
+
+  s.platforms    = { :ios => "11.0" }
+  s.source       = { :git => "https://github.com/attentive-mobile/attentive-react-native-sdk.git", :tag => "#{s.version}" }
+
+  s.source_files = "ios/**/*.{h,m,mm}"
+
+  s.dependency 'attentive-ios-sdk', '0.4.0'
+  s.dependency "React-Core"
+
+  # Don't install the dependencies when we run `pod install` in the old architecture.
+  if ENV['RCT_NEW_ARCH_ENABLED'] == '1' then
+    s.compiler_flags = folly_compiler_flags + " -DRCT_NEW_ARCH_ENABLED=1"
+    s.pod_target_xcconfig    = {
+        "HEADER_SEARCH_PATHS" => "\"$(PODS_ROOT)/boost\"",
+        "OTHER_CPLUSPLUSFLAGS" => "-DFOLLY_NO_CONFIG -DFOLLY_MOBILE=1 -DFOLLY_USE_LIBCPP=1",
+        "CLANG_CXX_LANGUAGE_STANDARD" => "c++17"
+    }
+    s.dependency "React-Codegen"
+    s.dependency "RCT-Folly"
+    s.dependency "RCTRequired"
+    s.dependency "RCTTypeSafety"
+    s.dependency "ReactCommon/turbomodule/core"
+  end
+end

package/ios/AttentiveReactNativeSdk.h

@@ -0,0 +1,18 @@
+//
+//  AttentiveReactNativeSdk.h
+//  AttentiveReactNativeSdk
+//
+//  Created by Wyatt Davis on 2/13/23.
+//
+
+#ifdef RCT_NEW_ARCH_ENABLED
+#import "RNAttentiveReactNativeSdkSpec.h"
+
+@interface AttentiveReactNativeSdk : NSObject <NativeAttentiveReactNativeSdkSpec>
+#else
+#import <React/RCTBridgeModule.h>
+
+@interface AttentiveReactNativeSdk : NSObject <RCTBridgeModule>
+#endif
+
+@end

package/ios/AttentiveReactNativeSdk.mm

@@ -0,0 +1,85 @@
+//
+//  AttentiveReactNativeSdk.m
+//  AttentiveReactNativeSdk
+//
+//  Created by Wyatt Davis on 2/13/23.
+//
+
+#import "AttentiveReactNativeSdk.h"
+#import "attentive-sdk-umbrella.h"
+
+@implementation AttentiveReactNativeSdk {
+    ATTNSDK* _sdk;
+}
+
+RCT_EXPORT_MODULE()
+
+RCT_EXPORT_METHOD(initialize:(NSDictionary*)configuration) {
+    _sdk = [[ATTNSDK alloc] initWithDomain:configuration[@"attentiveDomain"] mode:configuration[@"mode"]];
+    [ATTNEventTracker setupWithSdk:_sdk];
+}
+
+RCT_EXPORT_METHOD(triggerCreative) {
+  dispatch_async(dispatch_get_main_queue(), ^{
+    UIWindow *window = [[UIApplication sharedApplication] keyWindow];
+    UIView *topView = window.rootViewController.view;
+    [self->_sdk trigger:topView];
+  });
+}
+
+RCT_EXPORT_METHOD(identify:(NSDictionary*)identifiers) {
+  // The dictionary already has the correct keys from the React code, so no translating necessary
+  [_sdk identify:identifiers];
+}
+
+RCT_EXPORT_METHOD(clearUser) {
+  [_sdk clearUser];
+}
+
+RCT_EXPORT_METHOD(recordAddToCartEvent:(NSDictionary*)attrs) {
+  NSArray* items = [self parseItems:attrs[@"items"]];
+  ATTNAddToCartEvent* event = [[ATTNAddToCartEvent alloc] initWithItems:items];
+  [[ATTNEventTracker sharedInstance] recordEvent:event];
+}
+
+RCT_EXPORT_METHOD(recordProductViewEvent:(NSDictionary*)attrs) {
+  NSArray* items = [self parseItems:attrs[@"items"]];
+  ATTNProductViewEvent* event = [[ATTNProductViewEvent alloc] initWithItems:items];
+  [[ATTNEventTracker sharedInstance] recordEvent:event];
+}
+
+RCT_EXPORT_METHOD(recordPurchaseEvent:(NSDictionary*)attrs) {
+  NSArray* items = [self parseItems:attrs[@"items"]];
+  ATTNOrder* order = [[ATTNOrder alloc] initWithOrderId:attrs[@"order"][@"id"]];
+  ATTNPurchaseEvent* event = [[ATTNPurchaseEvent alloc] initWithItems:items order:order];
+  [[ATTNEventTracker sharedInstance] recordEvent:event];
+}
+
+RCT_EXPORT_METHOD(recordCustomEvent:(NSDictionary*)attrs) {
+  ATTNCustomEvent* customEvent = [[ATTNCustomEvent alloc] initWithType:attrs[@"type"] properties:attrs[@"properties"]];
+  [[ATTNEventTracker sharedInstance] recordEvent:customEvent];
+}
+
+- (NSArray*)parseItems:(NSArray*)rawItems {
+  NSMutableArray* itemsToReturn = [[NSMutableArray alloc] init];
+  for (NSDictionary* rawItem in rawItems) {
+    NSDictionary* rawPrice = rawItem[@"price"];
+    ATTNPrice* price = [[ATTNPrice alloc] initWithPrice:[[NSDecimalNumber alloc] initWithString:rawPrice[@"price"]] currency:rawPrice[@"currency"]];
+    
+    ATTNItem* item = [[ATTNItem alloc] initWithProductId:rawItem[@"productId"] productVariantId:rawItem[@"productVariantId"] price:price];
+    
+    [itemsToReturn addObject:item];
+  }
+  return itemsToReturn;
+}
+
+// Don't compile this code when we build for the old architecture.
+#ifdef RCT_NEW_ARCH_ENABLED
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+    (const facebook::react::ObjCTurboModule::InitParams &)params
+{
+    return std::make_shared<facebook::react::NativeAttentiveReactNativeSdkSpecJSI>(params);
+}
+#endif
+
+@end