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

package/scripts/generate-version.ts

@@ -0,0 +1,18 @@
+import * as fs from 'fs';
+import * as path from 'path';
+
+const pkgPath = path.resolve(__dirname, '../package.json');
+const versionFilePath = path.resolve(__dirname, '../src/version.ts');
+
+const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+const version = pkg.version;
+
+const fileContent = `/**
+ * Auto-generated file. Do not edit manually.
+ * React Native Nami SDK version.
+ */
+export const NAMI_REACT_NATIVE_VERSION = '${version}';
+`;
+
+fs.writeFileSync(versionFilePath, fileContent, 'utf8');
+console.log(`Generated version.ts with version ${version}`);

package/specs/NativeNami.ts

@@ -0,0 +1,16 @@
+import type { TurboModule } from 'react-native';
+import { TurboModuleRegistry } from 'react-native';
+
+export interface Spec extends TurboModule {
+  configure(config: {
+    appPlatformID: string;
+    logLevel: string;
+    namiCommands?: string[];
+    namiLanguageCode?: string;
+    initialConfig?: string;
+  }): Promise<{ success: boolean }>;
+
+  sdkConfigured(): Promise<boolean>;
+}
+
+export default TurboModuleRegistry.getEnforcing<Spec>('RNNami');

package/specs/NativeNamiCampaignManager.ts

@@ -0,0 +1,94 @@
+import type { TurboModule } from 'react-native';
+import { TurboModuleRegistry } from 'react-native';
+
+export interface Spec extends TurboModule {
+  launch(
+    label: string | null,
+    withUrl: string | null,
+    context: {
+      productGroups?: string[];
+      customAttributes?: { [key: string]: string };
+      customObject?: { [key: string]: unknown };
+    } | null,
+    completion: (successAction: boolean, error: number | null) => void,
+    paywallCompletion: (event: {
+      campaignId?: string;
+      campaignName?: string;
+      campaignType?: string;
+      campaignLabel?: string;
+      campaignUrl?: string;
+      paywallId?: string;
+      paywallName?: string;
+      segmentId?: string;
+      externalSegmentId?: string;
+      action: string;
+      sku?: {
+        id?: string;
+        name?: string;
+        skuId?: string;
+        type?: string;
+        promoId?: string;
+        promoToken?: string;
+      };
+      purchaseError?: string;
+      purchases?: Array<{
+        sku?: {
+          id: string;
+          skuId: string;
+          name: string;
+          type: string;
+        };
+        skuId: string;
+        transactionIdentifier?: string;
+        purchaseToken?: string;
+        expires?: number; // timestamp (ms)
+        purchaseInitiatedTimestamp: number; // timestamp (ms)
+        purchaseSource?: 'CAMPAIGN' | 'MARKETPLACE' | 'UNKNOWN';
+      }>;
+      deeplinkUrl?: string;
+      componentChange?: {
+        id?: string;
+        name?: string;
+      };
+      videoMetadata?: {
+        id?: string;
+        name?: string;
+        url?: string;
+        loopVideo?: boolean;
+        muteByDefault?: boolean;
+        autoplayVideo?: boolean;
+        contentTimecode?: string;
+        contentDuration?: string;
+      };
+      timeSpentOnPaywall?: number;
+    }) => void,
+  ): void;
+
+  allCampaigns(): Promise<
+    {
+      id?: string;
+      rule?: string;
+      segment?: string;
+      paywall?: string;
+      type: string;
+      value?: string;
+    }[]
+  >;
+
+  isCampaignAvailable(source?: string): Promise<boolean>;
+
+  refresh(): Promise<
+    {
+      id?: string;
+      rule?: string;
+      segment?: string;
+      paywall?: string;
+      type: string;
+      value?: string;
+    }[]
+  >;
+
+  registerAvailableCampaignsHandler(): void;
+}
+
+export default TurboModuleRegistry.getEnforcing<Spec>('RNNamiCampaignManager');

package/specs/NativeNamiCustomerManager.ts

@@ -0,0 +1,37 @@
+import type { TurboModule } from 'react-native';
+import { TurboModuleRegistry } from 'react-native';
+
+export interface Spec extends TurboModule {
+  setCustomerAttribute(key: string, value: string): void;
+  getCustomerAttribute(key: string): Promise<string | null>;
+  clearCustomerAttribute(key: string): void;
+  clearAllCustomerAttributes(): void;
+
+  setCustomerDataPlatformId(platformId: string): void;
+  clearCustomerDataPlatformId(): void;
+
+  setAnonymousMode(anonymousMode: boolean): void;
+  inAnonymousMode(): Promise<boolean>;
+
+  journeyState(): Promise<{
+    formerSubscriber: boolean;
+    inGracePeriod: boolean;
+    inTrialPeriod: boolean;
+    inIntroOfferPeriod: boolean;
+    isCancelled: boolean;
+    inPause: boolean;
+    inAccountHold: boolean;
+  }>;
+
+  isLoggedIn(): Promise<boolean>;
+  loggedInId(): Promise<string | null>;
+  deviceId(): Promise<string>;
+
+  login(customerId: string): void;
+  logout(): void;
+
+  registerJourneyStateHandler(): void;
+  registerAccountStateHandler(): void;
+}
+
+export default TurboModuleRegistry.getEnforcing<Spec>('RNNamiCustomerManager');

package/specs/NativeNamiEntitlementManager.ts

@@ -0,0 +1,54 @@
+import type { TurboModule } from 'react-native';
+import { TurboModuleRegistry } from 'react-native';
+
+export interface Spec extends TurboModule {
+  isEntitlementActive(referenceId?: string): Promise<boolean>;
+  active(): Promise<
+    Array<{
+      referenceId: string;
+      desc?: string;
+      name?: string;
+      purchasedSkus: Array<{
+        id: string;
+        skuId: string;
+        name?: string;
+        type: string;
+        promoId?: string;
+        promoToken?: string;
+      }>;
+      relatedSkus: Array<{
+        id: string;
+        skuId: string;
+        name?: string;
+        type: string;
+        promoId?: string;
+        promoToken?: string;
+      }>;
+      activePurchases: Array<{
+        skuId: string;
+        transactionIdentifier?: string;
+        expires?: string;
+        purchaseInitiatedTimestamp: string;
+        purchaseSource?: string;
+        sku?: {
+          id: string;
+          skuId: string;
+          name?: string;
+          type: string;
+          promoId?: string;
+          promoToken?: string;
+        };
+      }>;
+    }>
+  >;
+
+  refresh(): void;
+
+  registerActiveEntitlementsHandler(): void;
+
+  clearProvisionalEntitlementGrants(): void;
+}
+
+export default TurboModuleRegistry.getEnforcing<Spec>(
+  'RNNamiEntitlementManager',
+);

package/specs/NativeNamiFlowManager.ts

@@ -0,0 +1,12 @@
+import type { TurboModule } from 'react-native';
+import { TurboModuleRegistry } from 'react-native';
+
+export interface Spec extends TurboModule {
+  registerStepHandoff(): void;
+
+  resume(): void;
+
+  registerEventHandler(): void;
+}
+
+export default TurboModuleRegistry.getEnforcing<Spec>('RNNamiFlowManager');

package/specs/NativeNamiPaywallManager.ts

@@ -0,0 +1,85 @@
+import type { TurboModule } from 'react-native';
+import { TurboModuleRegistry } from 'react-native';
+
+export interface Spec extends TurboModule {
+  // Unified purchase success handler
+  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;
+
+  // Backward compatibility methods
+  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;
+}
+
+export default TurboModuleRegistry.getEnforcing<Spec>('RNNamiPaywallManager');

package/specs/NativeNamiPurchaseManager.ts

@@ -0,0 +1,33 @@
+import type { TurboModule } from 'react-native';
+import { TurboModuleRegistry } 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; // timestamp in milliseconds
+      purchaseInitiatedTimestamp: number; // timestamp in milliseconds
+      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;
+}
+
+export default TurboModuleRegistry.getEnforcing<Spec>('RNNamiPurchaseManager');

package/src/Nami.ts

@@ -1,24 +1,34 @@
-import { NativeModules } from 'react-native';
-import { NamiConfiguration } from './types';
+import type { Spec } from '../specs/NativeNami';
+import { TurboModuleRegistry, NativeModules } from 'react-native';
+import type { NamiConfiguration } from './types';
 
-export const { NamiBridge, NamiManager } = NativeModules;
+const RNNami: Spec =
+  TurboModuleRegistry.getEnforcing<Spec>('RNNami') ?? NativeModules.RNNami;
 
-export interface INami {
-  configure: (config: NamiConfiguration) => Promise<{ success: boolean }>;
-}
+import { NAMI_REACT_NATIVE_VERSION } from './version';
 
-export const Nami: INami = {
-  ...NamiBridge,
-  configure: (
-    configureObj: NamiConfiguration,
-  ): Promise<{ success: boolean }> => {
-    return new Promise(resolve => {
-      NamiBridge.configure(
-        configureObj,
-        (resultObject: { success: boolean }) => {
-          resolve(resultObject);
-        },
-      );
+export const Nami = {
+  configure: async (config: NamiConfiguration): Promise<boolean> => {
+    const result = await RNNami.configure({
+      ...config,
+      namiCommands: [
+        ...(config.namiCommands ?? []),
+        `extendedClientInfo:react-native:${NAMI_REACT_NATIVE_VERSION}`,
+      ],
     });
+
+    // Treat 'already configured' as success
+    if (result?.success === false) {
+      const alreadyConfigured = await RNNami.sdkConfigured?.();
+      if (alreadyConfigured) {
+        return true;
+      }
+    }
+
+    return result?.success ?? false;
+  },
+
+  sdkConfigured: async (): Promise<boolean> => {
+    return await RNNami.sdkConfigured?.();
   },
 };

package/src/NamiCampaignManager.ts

@@ -1,62 +1,61 @@
+import type { Spec } from '../specs/NativeNamiCampaignManager';
 import {
+  TurboModuleRegistry,
   NativeModules,
   NativeEventEmitter,
-  EmitterSubscription,
 } from 'react-native';
-import {
-  LaunchCampaignError,
-  NamiCampaign,
-  NamiPaywallActionHandler,
+import type {
   NamiPaywallEvent,
   PaywallLaunchContext,
+  NamiCampaign,
 } from './types';
+import { NamiPaywallAction } from './types';
 
-export const { RNNamiCampaignManager } = NativeModules;
+const RNNamiCampaignManager: Spec =
+  TurboModuleRegistry.getEnforcing<Spec>('RNNamiCampaignManager') ??
+  NativeModules.RNNamiCampaignManager;
 
 export enum NamiCampaignManagerEvents {
-  ResultCampaign = 'ResultCampaign',
   AvailableCampaignsChanged = 'AvailableCampaignsChanged',
+  NamiPaywallEvent = 'NamiPaywallEvent',
 }
 
-const searchString_Nami = 'NAMI_';
+const validPaywallActions = new Set(
+  Object.values(NamiPaywallAction) as NamiPaywallAction[],
+);
 
-interface ICampaignManager {
-  launchSubscription: EmitterSubscription | undefined;
-  emitter: NativeEventEmitter;
-  allCampaigns: () => Promise<Array<NamiCampaign>>;
-  isCampaignAvailable(campaignSource: string | null): Promise<boolean>;
-  launch: (
-    label?: string,
-    withUrl?: string,
-    context?: PaywallLaunchContext,
-    resultCallback?: (success: boolean, error?: LaunchCampaignError) => void,
-    actionCallback?: NamiPaywallActionHandler,
-  ) => void;
-  refresh: () => Promise<Array<NamiCampaign>>;
-  registerAvailableCampaignsHandler: (
-    callback: (availableCampaigns: NamiCampaign[]) => void,
-  ) => EmitterSubscription['remove'];
+function mapToNamiPaywallAction(action: string): NamiPaywallAction {
+  return validPaywallActions.has(action as NamiPaywallAction)
+    ? (action as NamiPaywallAction)
+    : NamiPaywallAction.UNKNOWN;
 }
 
-export const NamiCampaignManager: ICampaignManager = {
-  launchSubscription: undefined,
-  emitter: new NativeEventEmitter(RNNamiCampaignManager),
-  ...RNNamiCampaignManager,
-  launch(label, withUrl, context, resultCallback, actionCallback) {
+const emitter = new NativeEventEmitter(NativeModules.RNNamiCampaignManager);
+
+export const NamiCampaignManager = {
+  emitter,
+
+  launchSubscription: undefined as
+    | 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 {
     if (this.launchSubscription) {
       this.launchSubscription.remove();
     }
 
     this.launchSubscription = this.emitter.addListener(
-      NamiCampaignManagerEvents.ResultCampaign,
-      body => {
-        body.action = body.action.startsWith(searchString_Nami)
-          ? body.action.substring(5, body.action.length)
-          : body.action;
-
+      NamiCampaignManagerEvents.NamiPaywallEvent,
+      (body: any) => {
         if (actionCallback) {
           const paywallEvent: NamiPaywallEvent = {
-            action: body.action,
+            action: mapToNamiPaywallAction(body.action),
             campaignId: body.campaignId,
             campaignName: body.campaignName,
             campaignType: body.campaignType,
@@ -78,33 +77,38 @@ export const NamiCampaignManager: ICampaignManager = {
         }
       },
     );
+
     RNNamiCampaignManager.launch(
-      label ?? null,
-      withUrl ?? null,
-      context ?? null,
+      label,
+      withUrl,
+      context,
       resultCallback ?? (() => {}),
       actionCallback ?? (() => {}),
     );
   },
 
-  isCampaignAvailable: campaignSource => {
-    return RNNamiCampaignManager.isCampaignAvailable(campaignSource ?? null);
+  allCampaigns: async () => {
+    return await RNNamiCampaignManager.allCampaigns();
   },
 
-  registerAvailableCampaignsHandler(callback) {
-    if (typeof callback !== 'function') {
-      throw new Error('Expected callback to be a function.');
-    }
-    const subscription = this.emitter.addListener(
+  isCampaignAvailable: async (campaignName: string | null) => {
+    return await RNNamiCampaignManager.isCampaignAvailable(
+      campaignName ?? undefined,
+    );
+  },
+
+  refresh: async () => {
+    return await RNNamiCampaignManager.refresh();
+  },
+
+  registerAvailableCampaignsHandler: (
+    callback: (campaigns: NamiCampaign[]) => void,
+  ): (() => void) => {
+    const sub = emitter.addListener(
       NamiCampaignManagerEvents.AvailableCampaignsChanged,
       callback,
     );
-
-    RNNamiCampaignManager.registerAvailableCampaignsHandler();
-    return () => {
-      if (subscription) {
-        subscription.remove();
-      }
-    };
+    RNNamiCampaignManager.registerAvailableCampaignsHandler?.();
+    return () => sub.remove();
   },
 };