react-native-nami-sdk 3.3.0-beta.8 → 3.3.0

package/dist/specs/NativeNamiPaywallManager.d.ts

@@ -0,0 +1,71 @@
+import type { TurboModule } from 'react-native';
+export interface Spec extends TurboModule {
+    buySkuComplete(purchase: {
+        product: {
+            id: string;
+            skuId: string;
+            name?: string;
+            type: string;
+        };
+        transactionID?: string;
+        originalTransactionID?: string;
+        orderId?: string;
+        purchaseToken?: string;
+        receiptId?: string;
+        localizedPrice?: string;
+        userId?: string;
+        marketplace?: string;
+        price?: string;
+        currencyCode?: string;
+    }): void;
+    buySkuCompleteApple(purchase: {
+        product: {
+            id: string;
+            skuId: string;
+            name?: string;
+            type: string;
+        };
+        transactionID: string;
+        originalTransactionID: string;
+        price: string;
+        currencyCode: string;
+    }): void;
+    buySkuCompleteAmazon(purchase: {
+        product: {
+            id: string;
+            skuId: string;
+            name?: string;
+            type: string;
+        };
+        receiptId: string;
+        localizedPrice: string;
+        userId: string;
+        marketplace: string;
+    }): void;
+    buySkuCompleteGooglePlay(purchase: {
+        product: {
+            id: string;
+            skuId: string;
+            name?: string;
+            type: string;
+        };
+        orderId: string;
+        purchaseToken: string;
+    }): void;
+    registerBuySkuHandler(): void;
+    registerCloseHandler(): void;
+    registerSignInHandler(): void;
+    registerRestoreHandler(): void;
+    registerDeeplinkActionHandler(): void;
+    dismiss(): Promise<void>;
+    show(): void;
+    hide(): void;
+    isHidden(): Promise<boolean>;
+    isPaywallOpen(): Promise<boolean>;
+    buySkuCancel(): void;
+    setProductDetails(productDetails: string, allowOffers?: boolean): void;
+    setAppSuppliedVideoDetails(url: string, name?: string): void;
+    allowUserInteraction(allowed: boolean): void;
+}
+declare const _default: Spec;
+export default _default;

package/dist/specs/NativeNamiPurchaseManager.d.ts

@@ -0,0 +1,28 @@
+import type { TurboModule } from 'react-native';
+export interface Spec extends TurboModule {
+    allPurchases(): Promise<Array<{
+        skuId: string;
+        sku?: {
+            id: string;
+            skuId: string;
+            name?: string;
+            type: string;
+            promoId?: string;
+            promoToken?: string;
+        };
+        transactionIdentifier?: string;
+        purchaseToken?: string;
+        expires?: number;
+        purchaseInitiatedTimestamp: number;
+        purchaseSource?: 'CAMPAIGN' | 'MARKETPLACE' | 'UNKNOWN';
+    }>>;
+    skuPurchased(skuId: string): Promise<boolean>;
+    anySkuPurchased(skuIds: string[]): Promise<boolean>;
+    consumePurchasedSku(skuId: string): void;
+    presentCodeRedemptionSheet(): void;
+    restorePurchases(): void;
+    registerPurchasesChangedHandler(): void;
+    registerRestorePurchasesHandler(): void;
+}
+declare const _default: Spec;
+export default _default;

package/dist/src/Nami.d.ts

@@ -0,0 +1,5 @@
+import type { NamiConfiguration } from './types';
+export declare const Nami: {
+    configure: (config: NamiConfiguration) => Promise<boolean>;
+    sdkConfigured: () => Promise<boolean>;
+};

package/dist/src/NamiCampaignManager.d.ts

@@ -0,0 +1,29 @@
+import { NativeEventEmitter } from 'react-native';
+import type { PaywallLaunchContext, NamiCampaign } from './types';
+export declare enum NamiCampaignManagerEvents {
+    AvailableCampaignsChanged = "AvailableCampaignsChanged",
+    NamiPaywallEvent = "NamiPaywallEvent"
+}
+export declare const NamiCampaignManager: {
+    emitter: NativeEventEmitter;
+    launchSubscription: ReturnType<NativeEventEmitter["addListener"]> | undefined;
+    launch(label: string | null, withUrl: string | null, context: PaywallLaunchContext | null, resultCallback?: (success: boolean, errorCode?: number | null) => void, actionCallback?: (event: any) => void): void;
+    allCampaigns: () => Promise<{
+        id?: string;
+        rule?: string;
+        segment?: string;
+        paywall?: string;
+        type: string;
+        value?: string;
+    }[]>;
+    isCampaignAvailable: (campaignName: string | null) => Promise<boolean>;
+    refresh: () => Promise<{
+        id?: string;
+        rule?: string;
+        segment?: string;
+        paywall?: string;
+        type: string;
+        value?: string;
+    }[]>;
+    registerAvailableCampaignsHandler: (callback: (campaigns: NamiCampaign[]) => void) => (() => void);
+};

package/{src → dist/src}/NamiCustomerManager.d.ts

@@ -1,27 +1,25 @@
 import { NativeEventEmitter, EmitterSubscription } from 'react-native';
-import { AccountStateAction, CustomerJourneyState } from './types';
-export declare const RNNamiCustomerManager: any;
+import type { AccountStateAction, CustomerJourneyState } from './types';
 export declare enum NamiCustomerManagerEvents {
     JourneyStateChanged = "JourneyStateChanged",
     AccountStateChanged = "AccountStateChanged"
 }
-export interface INamiCustomerManager {
+export declare const NamiCustomerManager: {
     emitter: NativeEventEmitter;
+    login: (customerId: string) => void;
+    logout: () => void;
     setCustomerAttribute: (key: string, value: string) => void;
     getCustomerAttribute: (key: string) => Promise<string | undefined>;
     clearCustomerAttribute: (key: string) => void;
     clearAllCustomerAttributes: () => void;
-    journeyState: () => Promise<CustomerJourneyState | undefined>;
+    journeyState: () => Promise<CustomerJourneyState>;
     isLoggedIn: () => Promise<boolean>;
     loggedInId: () => Promise<string | undefined>;
-    deviceId: () => Promise<string>;
-    login: (customerId: string) => void;
-    logout: () => void;
-    registerJourneyStateHandler: (callback: (journeyState: CustomerJourneyState) => void) => EmitterSubscription['remove'];
-    registerAccountStateHandler: (callback: (action: AccountStateAction, success: boolean, error?: number) => void) => EmitterSubscription['remove'];
+    setCustomerDataPlatformId: (platformId: any) => void;
     clearCustomerDataPlatformId: () => void;
-    setCustomerDataPlatformId: (platformId: string) => void;
-    setAnonymousMode: (anonymousMode: boolean) => void;
+    setAnonymousMode: (anonymousMode: any) => void;
+    deviceId: () => Promise<string>;
     inAnonymousMode: () => Promise<boolean>;
-}
-export declare const NamiCustomerManager: INamiCustomerManager;
+    registerJourneyStateHandler: (callback: (state: CustomerJourneyState) => void) => EmitterSubscription["remove"];
+    registerAccountStateHandler: (callback: (action: AccountStateAction, success: boolean, error?: number) => void) => EmitterSubscription["remove"];
+};

package/dist/src/NamiEntitlementManager.d.ts

@@ -0,0 +1,13 @@
+import { NativeEventEmitter, EmitterSubscription } from 'react-native';
+import type { NamiEntitlement } from './types';
+export declare enum NamiEntitlementManagerEvents {
+    EntitlementsChanged = "EntitlementsChanged"
+}
+export declare const NamiEntitlementManager: {
+    emitter: NativeEventEmitter;
+    active: () => Promise<NamiEntitlement[]>;
+    isEntitlementActive: (entitlementId: string) => Promise<boolean>;
+    refresh: (callback: (entitlements: NamiEntitlement[]) => void) => EmitterSubscription["remove"];
+    registerActiveEntitlementsHandler: (callback: (entitlements: NamiEntitlement[]) => void) => EmitterSubscription["remove"];
+    clearProvisionalEntitlementGrants: () => void;
+};

package/dist/src/NamiFlowManager.d.ts

@@ -0,0 +1,11 @@
+import { NativeEventEmitter } from 'react-native';
+export declare enum NamiFlowManagerEvents {
+    Handoff = "Handoff",
+    FlowEvent = "FlowEvent"
+}
+export declare const NamiFlowManager: {
+    emitter: NativeEventEmitter;
+    registerStepHandoff: (callback: (handoffTag: string, handoffData?: Record<string, unknown>) => void) => (() => void);
+    resume: () => void;
+    registerEventHandler: (callback: (payload: Record<string, unknown>) => void) => (() => void);
+};

package/dist/src/NamiPaywallManager.d.ts

@@ -0,0 +1,30 @@
+import { NativeEventEmitter } from 'react-native';
+import type { NamiPurchaseDetails, NamiPurchaseSuccessApple, NamiPurchaseSuccessAmazon, NamiPurchaseSuccessGooglePlay, NamiSKU } from '../src/types';
+export declare enum NamiPaywallManagerEvents {
+    BuySku = "RegisterBuySKU",
+    Close = "PaywallCloseRequested",
+    SignIn = "PaywallSignInRequested",
+    Restore = "PaywallRestoreRequested",
+    DeeplinkAction = "PaywallDeeplinkAction"
+}
+export declare const NamiPaywallManager: {
+    emitter: NativeEventEmitter;
+    buySkuComplete: (purchase: NamiPurchaseDetails) => void;
+    buySkuCompleteApple: (purchase: NamiPurchaseSuccessApple) => void;
+    buySkuCompleteAmazon: (purchase: NamiPurchaseSuccessAmazon) => void;
+    buySkuCompleteGooglePlay: (purchase: NamiPurchaseSuccessGooglePlay) => void;
+    registerBuySkuHandler: (callback: (sku: NamiSKU) => void) => (() => void);
+    registerCloseHandler: (callback: () => void) => (() => void);
+    registerSignInHandler: (callback: () => void) => (() => void);
+    registerRestoreHandler: (callback: () => void) => (() => void);
+    registerDeeplinkActionHandler: (callback: (url: string) => void) => (() => void);
+    dismiss: () => Promise<boolean>;
+    show: () => void;
+    hide: () => void;
+    isHidden: () => Promise<boolean>;
+    isPaywallOpen: () => Promise<boolean>;
+    buySkuCancel: () => void;
+    setProductDetails: (productDetails: string, allowOffers?: boolean) => void;
+    setAppSuppliedVideoDetails: (url: string, name?: string) => void;
+    allowUserInteraction: (allowed: boolean) => void;
+};

package/dist/src/NamiPurchaseManager.d.ts

@@ -0,0 +1,17 @@
+import { NativeEventEmitter } from 'react-native';
+import { NamiPurchase, NamiPurchasesState, NamiRestorePurchasesState } from './types';
+export declare enum NamiPurchaseManagerEvents {
+    PurchasesChanged = "PurchasesChanged",
+    RestorePurchasesStateChanged = "RestorePurchasesStateChanged"
+}
+export declare const NamiPurchaseManager: {
+    emitter: NativeEventEmitter;
+    allPurchases: () => Promise<NamiPurchase[]>;
+    skuPurchased: (skuId: string) => Promise<boolean>;
+    anySkuPurchased: (skuIds: string[]) => Promise<boolean>;
+    consumePurchasedSku: (skuId: string) => void;
+    presentCodeRedemptionSheet: () => void;
+    restorePurchases: () => void;
+    registerPurchasesChangedHandler: (callback: (state: NamiPurchasesState, purchases: NamiPurchase[], error: string) => void) => (() => void);
+    registerRestorePurchasesHandler: (callback: (state: NamiRestorePurchasesState, newPurchases: NamiPurchase[], oldPurchases: NamiPurchase[]) => void) => (() => void);
+};

package/dist/src/transformers.d.ts

@@ -0,0 +1,3 @@
+import type { NamiPurchase, NamiSKUType } from './types';
+export declare function parsePurchaseDates(purchase: any): NamiPurchase;
+export declare function coerceSkuType(raw: string): NamiSKUType;

package/{src → dist/src}/types.d.ts

@@ -1,6 +1,5 @@
 export type NamiConfiguration = {
-    'appPlatformID-apple': string;
-    'appPlatformID-android': string;
+    appPlatformID: string;
     logLevel: string;
     namiCommands?: string[];
     namiLanguageCode?: NamiLanguageCodes;
@@ -44,8 +43,8 @@ export type AppleProduct = {
     priceCurrency: string;
     priceLanguage: string;
 };
-export type GoogleProduct = {};
-export type AmazonProduct = {};
+export type GoogleProduct = Record<string, never>;
+export type AmazonProduct = Record<string, never>;
 export type NamiCampaign = {
     name: string;
     rule: string;
@@ -91,7 +90,7 @@ export type PaywallLaunchContext = {
         [key: string]: string;
     };
     customObject?: {
-        [key: string]: any;
+        [key: string]: unknown;
     };
 };
 export type CustomerJourneyState = {
@@ -108,11 +107,23 @@ export type NamiEntitlement = {
     activePurchases: NamiPurchase[];
     desc: string;
     name: string;
-    namiId: string;
     purchasedSkus: NamiSKU[];
     referenceId: string;
     relatedSkus: NamiSKU[];
 };
+export type NamiPurchaseDetails = {
+    product: NamiSKU;
+    transactionID?: string;
+    originalTransactionID?: string;
+    orderId?: string;
+    purchaseToken?: string;
+    receiptId?: string;
+    localizedPrice?: string;
+    price?: string;
+    currencyCode?: string;
+    userId?: string;
+    marketplace?: string;
+};
 export type NamiPurchaseSuccessApple = {
     product: NamiSKU;
     transactionID: string;
@@ -170,6 +181,15 @@ export type NamiPurchase = {
     purchaseInitiatedTimestamp: Date;
     purchaseSource?: 'CAMPAIGN' | 'MARKETPLACE' | 'UNKNOWN';
 };
+export type NamiPurchaseFromBridge = {
+    sku?: NamiSKU;
+    skuId: string;
+    transactionIdentifier?: string;
+    purchaseToken?: string;
+    expires?: number;
+    purchaseInitiatedTimestamp: number;
+    purchaseSource?: 'CAMPAIGN' | 'MARKETPLACE' | 'UNKNOWN';
+};
 export type NamiPurchasesState = 'pending' | 'purchased' | 'consumed' | 'resubscribed' | 'unsubscribed' | 'deferred' | 'failed' | 'cancelled' | 'unknown';
 export type NamiPaywallEvent = {
     action: NamiPaywallAction;
@@ -205,4 +225,13 @@ export type NamiPaywallEventVideoMetadata = {
     contentTimecode?: number;
     contentDuration?: number;
 };
+export type NamiFlowHandoffPayload = {
+    handoffTag: string;
+    handoffData?: Record<string, unknown>;
+};
+export type NamiAccountStateEvent = {
+    action: AccountStateAction;
+    success: boolean;
+    error?: number;
+};
 export {};

package/dist/src/version.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Auto-generated file. Do not edit manually.
+ * React Native Nami SDK version.
+ */
+export declare const NAMI_REACT_NATIVE_VERSION = "3.3.0";

package/index.ts

@@ -1,9 +1,7 @@
 export { Nami } from './src/Nami';
-export { NamiMLManager } from './src/NamiMLManager';
 export { NamiCampaignManager } from './src/NamiCampaignManager';
 export { NamiCustomerManager } from './src/NamiCustomerManager';
 export { NamiEntitlementManager } from './src/NamiEntitlementManager';
-export { NamiManager } from './src/NamiManager';
 export { NamiPurchaseManager } from './src/NamiPurchaseManager';
 export { NamiPaywallManager } from './src/NamiPaywallManager';
 export { NamiFlowManager } from './src/NamiFlowManager';

package/ios/Nami.m

@@ -2,100 +2,20 @@
 //  Nami.m
 //  RNNami
 //
-//  Copyright © 2020-2023 Nami ML Inc. All rights reserved.
+//  Copyright © 2020-2025 Nami ML Inc. All rights reserved.
 //
-
-#import <Foundation/Foundation.h>
-#import <NamiApple/NamiApple.h>
-
 #import <React/RCTBridgeModule.h>
-#import <React/RCTEventEmitter.h>
-
-#import "React/RCTViewManager.h"
-
-
-
-@interface NamiBridge : NSObject <RCTBridgeModule>
-@end
-@implementation NamiBridge (RCTExternModule)
-
-RCT_EXPORT_METHOD(configure: (NSDictionary *)configDict completion: (RCTResponseSenderBlock) completion) {
-    NSString *appID = configDict[@"appPlatformID-apple"];
-
-    if ([appID length] > 0 ) {
-        NamiConfiguration *config = [NamiConfiguration configurationForAppPlatformId:appID];
-            NSLog(@"NAMI: RN Bridge - appPlatformId: %@", appID);
-
-        NSString *logLevelString = configDict[@"logLevel"];
-        if ([logLevelString isEqualToString:@"ERROR" ]) {
-            config.logLevel = NamiLogLevelError;
-        } else if ([logLevelString isEqualToString:@"INFO" ]) {
-            config.logLevel = NamiLogLevelInfo;
-        } else if ([logLevelString isEqualToString:@"WARNING" ]) {
-            config.logLevel = NamiLogLevelWarn;
-        } else {
-            // If they messed up the params, just set logging to full.
-            config.logLevel = NamiLogLevelDebug;
-        }
 
-        NSString *languageString = configDict[@"namiLanguageCode"];
-        if ([languageString length] > 0) {
-            NSLog(@"NAMI: RN Bridge - language code: %@", languageString);
-            if  ([[NamiLanguageCodes allAvailableNamiLanguageCodes]
-                  containsObject:[languageString lowercaseString]] ) {
-              config.namiLanguageCode = languageString;
-            } else {
-                NSLog(@"Warning: Nami language code from config dictionary %@ not found in list of available Nami Language Codes:\n%@", languageString, [NamiLanguageCodes allAvailableNamiLanguageCodes]);
-            }
-        }
+@interface RCT_EXTERN_MODULE(RNNami, NSObject)
 
-        // Start commands with header iformation for Nami to let them know this is a React client.
-        NSMutableArray *namiCommandStrings = [NSMutableArray arrayWithArray:@[@"extendedClientInfo:react-native:3.3.0-beta.3"]];
+RCT_EXTERN_METHOD(configure:(NSDictionary *)configDict
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
 
-        // Add additional namiCommands app may have sent in.
-        NSObject *appCommandStrings = configDict[@"namiCommands"];
-        if ( appCommandStrings != NULL ) {
-            NSLog(@"NAMI: RN Bridge - additional config settings %@", configDict[@"namiCommands"]);
-            if ([appCommandStrings isKindOfClass:[NSArray class]] ) {
-                for (NSObject *commandObj in ((NSArray *)appCommandStrings)){
-                    if ([commandObj isKindOfClass:[NSString class]]) {
-                        [namiCommandStrings addObject:(NSString *)commandObj];
-                    }
-                }
-            }
-        }
-
-        config.namiCommands = namiCommandStrings;
-
-        NSString *initialConfigString = configDict[@"initialConfig"];
-        if ([initialConfigString length] > 0) {
-              NSLog(@"NAMI: RN Bridge - Found an initialConfig file to use for Nami SDK setup.");
-              config.initialConfig = initialConfigString;
-        }
-
-        [Nami configureWith:config :^(BOOL sdkConfigured) {
-            if ( sdkConfigured == YES ) {
-                NSDictionary *dict = @{@"success": @YES};
-                completion(@[dict]);
-            } else {
-                NSDictionary *dict = @{@"success": @NO};
-                completion(@[dict]);
-            }
-        }];
-    }
-}
-
-@end
-
-@implementation NamiBridge
-RCT_EXPORT_MODULE_NO_LOAD(NamiBridge, NamiBridge)
-
-- (dispatch_queue_t)methodQueue
-{
-    return dispatch_get_main_queue();
-}
+RCT_EXTERN_METHOD(sdkConfigured:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
 
 + (BOOL)requiresMainQueueSetup {
-    return YES;
+  return NO;
 }
 @end

package/ios/Nami.swift

@@ -0,0 +1,85 @@
+//
+//  Nami.swift
+//  RNNami
+//
+//  Copyright © 2020-2025 Nami ML Inc. All rights reserved.
+//
+import Foundation
+import NamiApple
+import React
+
+#if RCT_NEW_ARCH_ENABLED
+    import React_RCTTurboModule
+
+    extension RNNami: RCTTurboModule {}
+#endif
+
+@objc(RNNami)
+class RNNami: NSObject {
+    static func moduleName() -> String! {
+        return "RNNami"
+    }
+
+    @objc
+    func configure(
+        _ configDict: NSDictionary,
+        resolver resolve: @escaping RCTPromiseResolveBlock,
+        rejecter reject: @escaping RCTPromiseRejectBlock
+    ) {
+        guard let appID = configDict["appPlatformID"] as? String, !appID.isEmpty else {
+            reject("missing_app_id", "The appPlatformID is required.", nil)
+            return
+        }
+
+        let config = NamiConfiguration(appPlatformId: appID)
+        NSLog("RNNami: Configure with appPlatformId: %@", appID)
+
+        if isNewArchitectureEnabled() {
+            NSLog("RNNami: New Architecture is ENABLED")
+        } else {
+            NSLog("RNNami: New Architecture is DISABLED")
+        }
+
+        if let logLevelString = configDict["logLevel"] as? String {
+            config.logLevel = {
+                switch logLevelString.uppercased() {
+                case "ERROR": return .error
+                case "INFO": return .info
+                case "WARNING": return .warn
+                default: return .debug
+                }
+            }()
+        }
+
+        if let languageCode = configDict["namiLanguageCode"] as? String,
+           NamiLanguageCodes.allAvailableNamiLanguageCodes.contains(where: { $0.caseInsensitiveCompare(languageCode) == .orderedSame })
+        {
+            config.namiLanguageCode = languageCode
+        }
+
+        if let commands = configDict["namiCommands"] as? [String] {
+            config.namiCommands = commands
+        }
+
+        if let initialConfig = configDict["initialConfig"] as? String {
+            config.initialConfig = initialConfig
+        }
+
+        Nami.configure(with: config) { sdkConfigured in
+            resolve(["success": sdkConfigured])
+        }
+    }
+
+    @objc
+    func sdkConfigured(_ resolve: RCTPromiseResolveBlock, rejecter _: RCTPromiseRejectBlock) {
+        resolve(Nami.sdkConfigured())
+    }
+
+    func isNewArchitectureEnabled() -> Bool {
+        #if RCT_NEW_ARCH_ENABLED
+            return true
+        #else
+            return false
+        #endif
+    }
+}

package/ios/NamiCampaignManagerBridge.m

@@ -1,8 +1,8 @@
 //
-//  NamiCampaignManager.m
+//  NamiCampaignManagerBridge.m
 //  RNNami
 //
-//  Copyright © 2023 Nami ML INc.. All rights reserved.
+//  Copyright © 2020-2025 Nami ML Inc. All rights reserved.
 //
 
 #import <React/RCTBridgeModule.h>
@@ -20,7 +20,7 @@ RCT_EXTERN_METHOD(refresh:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRe
 RCT_EXTERN_METHOD(registerAvailableCampaignsHandler)
 
 + (BOOL)requiresMainQueueSetup {
-  return YES;
+  return NO;
 }
 
 @end