@qonversion/react-native-sdk 10.0.0-RC1

package/src/internal/NoCodesInternal.ts

@@ -0,0 +1,84 @@
+import type NoCodesApi from "../NoCodesApi";
+import NoCodesConfig from "../NoCodesConfig";
+import Mapper, { type QNoCodeAction, type QNoCodesError, type QNoCodeScreenInfo } from "./Mapper";
+import type {NoCodesListener} from '../dto/NoCodesListener';
+import ScreenPresentationConfig from '../dto/ScreenPresentationConfig';
+import NoCodesError from '../dto/NoCodesError';
+import {NoCodesErrorCode} from '../dto/enums';
+import RNNoCodes, {type NoCodeEvent} from './specs/NativeNoCodesModule';
+import {sdkSource, sdkVersion} from './QonversionInternal';
+
+const EVENT_SCREEN_SHOWN = "nocodes_screen_shown";
+const EVENT_FINISHED = "nocodes_finished";
+const EVENT_ACTION_STARTED = "nocodes_action_started";
+const EVENT_ACTION_FAILED = "nocodes_action_failed";
+const EVENT_ACTION_FINISHED = "nocodes_action_finished";
+const EVENT_SCREEN_FAILED_TO_LOAD = "nocodes_screen_failed_to_load";
+
+export default class NoCodesInternal implements NoCodesApi {
+  private noCodesListener: NoCodesListener | null = null;
+
+  constructor(config: NoCodesConfig) {
+    RNNoCodes.initialize(config.projectKey, sdkSource, sdkVersion);
+
+    if (config.noCodesListener) {
+      this.setNoCodesListener(config.noCodesListener);
+    }
+  }
+
+  async setScreenPresentationConfig(config: ScreenPresentationConfig, contextKey?: string) {
+    const data = Mapper.convertScreenPresentationConfig(config);
+    await RNNoCodes.setScreenPresentationConfig(data, contextKey);
+  }
+
+  async showScreen(contextKey: string) {
+    await RNNoCodes.showScreen(contextKey);
+  }
+
+  async close() {
+    await RNNoCodes.close();
+  }
+
+  private noCodeEventHandler = (event: NoCodeEvent) => {
+    switch (event.name) {
+      case EVENT_SCREEN_SHOWN:
+        const screenId = (event.payload as QNoCodeScreenInfo)["screenId"] ?? "";
+        this.noCodesListener?.onScreenShown(screenId);
+        break;  
+      case EVENT_ACTION_STARTED:
+        const actionStarted = Mapper.convertAction(event.payload as QNoCodeAction);
+        this.noCodesListener?.onActionStartedExecuting(actionStarted);
+        break;
+      case EVENT_ACTION_FAILED:
+        const actionFailed = Mapper.convertAction(event.payload as QNoCodeAction);
+        this.noCodesListener?.onActionFailedToExecute(actionFailed);
+        break;
+      case EVENT_ACTION_FINISHED:
+        const actionFinished = Mapper.convertAction(event.payload as QNoCodeAction);
+        this.noCodesListener?.onActionFinishedExecuting(actionFinished);
+        break;
+      case EVENT_FINISHED:
+        this.noCodesListener?.onFinished();
+        break;
+      case EVENT_SCREEN_FAILED_TO_LOAD:
+        const error = Mapper.convertNoCodesError(event.payload as QNoCodesError | undefined);
+        const defaultError = new NoCodesError(
+          NoCodesErrorCode.UNKNOWN, 
+          "Failed to load No-Code screen",
+          "Native error parsing failed."
+        );
+        this.noCodesListener?.onScreenFailedToLoad(error ?? defaultError);
+        break;
+      default: 
+        console.warn(`No-Codes SDK: Unknown event: ${event.name}`);
+        break;
+    }
+  }
+
+  setNoCodesListener(listener: NoCodesListener) {
+    if (this.noCodesListener == null) {
+      RNNoCodes.onNoCodeEvent(this.noCodeEventHandler);
+    }
+    this.noCodesListener = listener;
+  }
+}

package/src/internal/QonversionInternal.ts

@@ -0,0 +1,370 @@
+import {AttributionProvider, QonversionErrorCode, UserPropertyKey} from "../dto/enums";
+import IntroEligibility from "../dto/IntroEligibility";
+import Mapper from "./Mapper";
+import type {QEntitlement, QEligibilityInfo, QProduct} from "./Mapper";
+import Offerings from "../dto/Offerings";
+import Entitlement from "../dto/Entitlement";
+import Product from "../dto/Product";
+import {isAndroid, isIos} from "./utils";
+import type {EntitlementsUpdateListener} from '../dto/EntitlementsUpdateListener';
+import type {PromoPurchasesListener} from '../dto/PromoPurchasesListener';
+import User from '../dto/User';
+import PurchaseOptions from '../dto/PurchaseOptions';
+import SKProductDiscount from '../dto/storeProducts/SKProductDiscount';
+import type { QonversionApi } from '../QonversionApi';
+import QonversionConfig from '../QonversionConfig';
+import RemoteConfig from "../dto/RemoteConfig";
+import UserProperties from '../dto/UserProperties';
+import PurchaseModel from '../dto/PurchaseModel';
+import PurchaseUpdateModel from '../dto/PurchaseUpdateModel';
+import {RemoteConfigList} from '../index';
+import PurchaseOptionsBuilder from "../dto/PurchaseOptionsBuilder";
+import PromotionalOffer from '../dto/PromotionalOffer';
+import RNQonversion from './specs/NativeQonversionModule';
+import type { QPromoOfferDetails } from './specs/NativeQonversionModule';
+
+export const sdkVersion = "10.0.0-RC1";
+export const sdkSource = "rn";
+
+export default class QonversionInternal implements QonversionApi {
+
+  private entitlementsUpdateListener: EntitlementsUpdateListener | null = null;
+  private promoPurchasesDelegate: PromoPurchasesListener | null = null;
+
+  constructor(qonversionConfig: QonversionConfig) {
+    RNQonversion.storeSDKInfo(sdkSource, sdkVersion);
+    RNQonversion.initializeSdk(
+      qonversionConfig.projectKey,
+      qonversionConfig.launchMode,
+      qonversionConfig.environment,
+      qonversionConfig.entitlementsCacheLifetime,
+      qonversionConfig.proxyUrl,
+      qonversionConfig.kidsMode
+    );
+
+    if (qonversionConfig.entitlementsUpdateListener) {
+      this.setEntitlementsUpdateListener(qonversionConfig.entitlementsUpdateListener);
+    }
+  }
+
+  syncHistoricalData () {
+    RNQonversion.syncHistoricalData();
+  }
+
+  syncStoreKit2Purchases() {
+    if (isIos()) {
+      RNQonversion.syncStoreKit2Purchases();
+    }
+  }
+
+  async isFallbackFileAccessible(): Promise<boolean> {
+    const isAccessibleResult = await RNQonversion.isFallbackFileAccessible();
+
+    return isAccessibleResult.success;
+  }
+
+  async getPromotionalOffer(product: Product, discount: SKProductDiscount): Promise<PromotionalOffer | null> {
+    if (isAndroid()) {
+      return null;
+    }
+    const promoOffer = await RNQonversion.getPromotionalOffer(product.qonversionId, discount.identifier);
+    const mappedPromoOffer: PromotionalOffer | null = Mapper.convertPromoOffer(promoOffer);
+
+    return mappedPromoOffer;
+  }
+
+  async purchaseProduct(product: Product, options: PurchaseOptions | undefined): Promise<Map<string, Entitlement>> {
+    try {
+      if (!options) {
+        options = new PurchaseOptionsBuilder().build();
+      }
+
+      let purchasePromise: Promise<Object | null | undefined>;
+      const promoOffer: QPromoOfferDetails = {
+        productDiscountId: options.promotionalOffer?.productDiscount.identifier,
+        keyIdentifier: options.promotionalOffer?.paymentDiscount.keyIdentifier,
+        nonce: options.promotionalOffer?.paymentDiscount.nonce,
+        signature: options.promotionalOffer?.paymentDiscount.signature,
+        timestamp: options.promotionalOffer?.paymentDiscount.timestamp
+      };
+
+      if (isIos()) {
+        purchasePromise = RNQonversion.purchase(
+          product.qonversionId,
+          options.quantity,
+          options.contextKeys,
+          promoOffer,
+          undefined,
+          false,
+          undefined,
+          undefined,
+        );
+      } else {
+        purchasePromise = RNQonversion.purchase(
+            product.qonversionId,
+            1,
+            options.contextKeys,
+            undefined,
+            options.offerId,
+            options.applyOffer,
+            options.oldProduct?.qonversionId,
+            options.updatePolicy,
+        );
+      }
+      const entitlements = await purchasePromise;
+
+      // noinspection UnnecessaryLocalVariableJS
+      const mappedPermissions = Mapper.convertEntitlements(entitlements as Record<string, QEntitlement>);
+
+      return mappedPermissions;
+    } catch (e: any) {
+      e.userCanceled = e.code === QonversionErrorCode.PURCHASE_CANCELED;
+      throw e;
+    }
+  }
+
+  async purchase(purchaseModel: PurchaseModel): Promise<Map<string, Entitlement>> {
+    try {
+      let purchasePromise: Promise<Object | null | undefined>;
+      if (isIos()) {
+        purchasePromise = RNQonversion.purchase(
+          purchaseModel.productId,
+          1,
+          undefined,
+          undefined,
+          undefined,
+          false,
+          undefined,
+          undefined,
+        );
+      } else {
+        purchasePromise = RNQonversion.purchase(
+          purchaseModel.productId,
+          1,
+          undefined,
+          undefined,
+          purchaseModel.offerId,
+          purchaseModel.applyOffer,
+          undefined,
+          undefined
+        );
+      }
+      const entitlements = await purchasePromise;
+
+      // noinspection UnnecessaryLocalVariableJS
+      const mappedPermissions = Mapper.convertEntitlements(entitlements as Record<string, QEntitlement>);
+
+      return mappedPermissions;
+    } catch (e: any) {
+      e.userCanceled = e.code === QonversionErrorCode.PURCHASE_CANCELED;
+      throw e;
+    }
+  }
+
+  async updatePurchase(purchaseUpdateModel: PurchaseUpdateModel): Promise<Map<string, Entitlement> | null> {
+    if (!isAndroid()) {
+      return null;
+    }
+
+    try {
+      const entitlements = await RNQonversion.updatePurchase(
+        purchaseUpdateModel.productId,
+        purchaseUpdateModel.offerId,
+        purchaseUpdateModel.applyOffer,
+        purchaseUpdateModel.oldProductId,
+        purchaseUpdateModel.updatePolicy,
+      );
+
+      // noinspection UnnecessaryLocalVariableJS
+      const mappedPermissions: Map<string, Entitlement> = Mapper.convertEntitlements(entitlements as Record<string, QEntitlement>);
+
+      return mappedPermissions;
+    } catch (e: any) {
+      e.userCanceled = e.code === QonversionErrorCode.PURCHASE_CANCELED;
+      throw e;
+    }
+  }
+
+  async products(): Promise<Map<string, Product>> {
+    let products = await RNQonversion.products();
+    const mappedProducts: Map<string, Product> = Mapper.convertProducts(products as Record<string, QProduct>);
+
+    return mappedProducts;
+  }
+
+  async offerings(): Promise<Offerings | null> {
+    let offerings = await RNQonversion.offerings();
+    const mappedOfferings = Mapper.convertOfferings(offerings);
+
+    return mappedOfferings;
+  }
+
+  async checkTrialIntroEligibility(
+    ids: string[]
+  ): Promise<Map<string, IntroEligibility>> {
+    const eligibilityInfo = await RNQonversion.checkTrialIntroEligibilityForProductIds(ids);
+
+    const mappedEligibility: Map<string, IntroEligibility> = Mapper.convertEligibility(eligibilityInfo as Record<string, QEligibilityInfo>);
+
+    return mappedEligibility;
+  }
+
+  async checkEntitlements(): Promise<Map<string, Entitlement>> {
+    const entitlements = await RNQonversion.checkEntitlements();
+    const mappedPermissions: Map<string, Entitlement> = Mapper.convertEntitlements(entitlements as Record<string, QEntitlement>);
+
+    return mappedPermissions;
+  }
+
+  async restore(): Promise<Map<string, Entitlement>> {
+    const entitlements = await RNQonversion.restore();
+
+    const mappedPermissions: Map<string, Entitlement> = Mapper.convertEntitlements(entitlements as Record<string, QEntitlement>);
+
+    return mappedPermissions;
+  }
+
+  syncPurchases() {
+    if (!isAndroid()) {
+      return;
+    }
+
+    RNQonversion.syncPurchases();
+  }
+
+  async identify(userId: string): Promise<User> {
+    const userInfo = await RNQonversion.identify(userId);
+    const mappedUserInfo: User = Mapper.convertUserInfo(userInfo);
+
+    return mappedUserInfo;
+  }
+
+  logout() {
+    RNQonversion.logout();
+  }
+
+  async userInfo(): Promise<User> {
+    const info = await RNQonversion.userInfo();
+    const mappedUserInfo: User = Mapper.convertUserInfo(info);
+
+    return mappedUserInfo;
+  }
+
+  attribution(data: Object, provider: AttributionProvider) {
+    RNQonversion.addAttributionData(data, provider);
+  }
+
+  setUserProperty(property: UserPropertyKey, value: string) {
+    if (property === UserPropertyKey.CUSTOM) {
+      console.warn("Can not set user property with the key `UserPropertyKey.CUSTOM`. " +
+        "To set custom user property, use the `setCustomUserProperty` method.");
+      return;
+    }
+
+    RNQonversion.setDefinedProperty(property, value);
+  }
+
+  setCustomUserProperty(property: string, value: string) {
+    RNQonversion.setCustomProperty(property, value);
+  }
+
+  async userProperties(): Promise<UserProperties> {
+    const properties = await RNQonversion.userProperties();
+    const mappedUserProperties: UserProperties = Mapper.convertUserProperties(properties);
+
+    return mappedUserProperties;
+  }
+
+  collectAdvertisingId() {
+    if (isIos()) {
+      RNQonversion.collectAdvertisingId();
+    }
+  }
+
+  collectAppleSearchAdsAttribution() {
+    if (isIos()) {
+      RNQonversion.collectAppleSearchAdsAttribution();
+    }
+  }
+
+  presentCodeRedemptionSheet() {
+    if (isIos()) {
+      RNQonversion.presentCodeRedemptionSheet();
+    }
+  }
+
+  async remoteConfig(contextKey: string | undefined): Promise<RemoteConfig> {
+    const remoteConfig = await RNQonversion.remoteConfig(contextKey);
+    const mappedRemoteConfig: RemoteConfig = Mapper.convertRemoteConfig(remoteConfig);
+
+    return mappedRemoteConfig;
+  }
+
+  async remoteConfigList(): Promise<RemoteConfigList> {
+    const remoteConfigList = await RNQonversion.remoteConfigList();
+    const mappedRemoteConfigList: RemoteConfigList = Mapper.convertRemoteConfigList(remoteConfigList);
+
+    return mappedRemoteConfigList;
+  }
+
+  async remoteConfigListForContextKeys(contextKeys: string[], includeEmptyContextKey: boolean): Promise<RemoteConfigList> {
+    const remoteConfigList = await RNQonversion.remoteConfigListForContextKeys(contextKeys, includeEmptyContextKey);
+    const mappedRemoteConfigList: RemoteConfigList = Mapper.convertRemoteConfigList(remoteConfigList);
+
+    return mappedRemoteConfigList;
+  }
+
+  async attachUserToExperiment(experimentId: string, groupId: string): Promise<void> {
+    await RNQonversion.attachUserToExperiment(experimentId, groupId);
+    return;
+  }
+
+  async detachUserFromExperiment(experimentId: string): Promise<void> {
+    await RNQonversion.detachUserFromExperiment(experimentId);
+    return;
+  }
+
+  async attachUserToRemoteConfiguration(remoteConfigurationId: string): Promise<void> {
+    await RNQonversion.attachUserToRemoteConfiguration(remoteConfigurationId);
+    return;
+  }
+
+  async detachUserFromRemoteConfiguration(remoteConfigurationId: string): Promise<void> {
+    await RNQonversion.detachUserFromRemoteConfiguration(remoteConfigurationId);
+    return;
+  }
+
+  private entitlementsUpdatedEventHandler = (payload: Object) => {
+    const entitlements = Mapper.convertEntitlements(payload as Record<string, QEntitlement>);
+    this.entitlementsUpdateListener?.onEntitlementsUpdated(entitlements);
+  }
+
+  private promoPurchaseReceivedEventHandler = (productId: string) => {
+    const promoPurchaseExecutor = async () => {
+      const entitlements = await RNQonversion.promoPurchase(productId);
+      const mappedPermissions: Map<string, Entitlement> = Mapper.convertEntitlements(entitlements as Record<string, QEntitlement>);
+      return mappedPermissions;
+    };
+    this.promoPurchasesDelegate?.onPromoPurchaseReceived(productId, promoPurchaseExecutor);
+  }
+
+  setEntitlementsUpdateListener(listener: EntitlementsUpdateListener) {
+    if (this.entitlementsUpdateListener == null) {
+      RNQonversion.onEntitlementsUpdated(this.entitlementsUpdatedEventHandler);
+    }
+    
+    this.entitlementsUpdateListener = listener;
+  }
+
+  setPromoPurchasesDelegate(delegate: PromoPurchasesListener) {
+    if (!isIos()) {
+      return;
+    }
+
+    if (this.promoPurchasesDelegate == null) {
+      RNQonversion.onPromoPurchaseReceived(this.promoPurchaseReceivedEventHandler);
+    }
+
+    this.promoPurchasesDelegate = delegate;
+  }
+}

package/src/internal/specs/NativeNoCodesModule.ts

@@ -0,0 +1,20 @@
+import type { TurboModule } from 'react-native';
+import { TurboModuleRegistry } from 'react-native';
+import type { EventEmitter } from 'react-native/Libraries/Types/CodegenTypes';
+import type { QNoCodeAction, QNoCodesError, QNoCodeScreenInfo } from '../Mapper';
+
+export type NoCodeEvent = {
+  name: string;
+  payload: QNoCodeAction | QNoCodesError | QNoCodeScreenInfo | undefined;
+};
+
+export interface Spec extends TurboModule {
+  initialize(projectKey: string, source: string, version: string): void;
+  setScreenPresentationConfig(configData: Object, contextKey?: string): Promise<boolean>;
+  showScreen(contextKey: string): Promise<boolean>;
+  close(): Promise<boolean>;
+
+  readonly onNoCodeEvent: EventEmitter<NoCodeEvent>;
+}
+
+export default TurboModuleRegistry.getEnforcing<Spec>('RNNoCodes');

package/src/internal/specs/NativeQonversionModule.ts

@@ -0,0 +1,74 @@
+import type {TurboModule} from 'react-native';
+import {TurboModuleRegistry} from 'react-native';
+import type { QPromotionalOffer, QOfferings, QUser, QUserProperties, QRemoteConfig, QRemoteConfigList } from '../Mapper';
+import type { EventEmitter } from 'react-native/Libraries/Types/CodegenTypes';
+
+export type QPromoOfferDetails = {
+  productDiscountId: string | undefined,
+  keyIdentifier: string | undefined,
+  nonce: string | undefined,
+  signature: string | undefined,
+  timestamp: number | undefined,
+}
+
+export interface Spec extends TurboModule {
+  storeSDKInfo(sdkName: string, sdkVersion: string): void;
+  initializeSdk(
+    projectKey: string,
+    launchMode: string,
+    environment: string,
+    entitlementsCacheLifetime: string,
+    proxyUrl: string | undefined,
+    kidsMode: boolean
+  ): void;
+  syncHistoricalData(): void;
+  syncStoreKit2Purchases(): void;
+  isFallbackFileAccessible(): Promise<{success: boolean}>;
+  getPromotionalOffer(product: string, discount: string | undefined): Promise<QPromotionalOffer | null>;
+  purchase(
+    productId: string,
+    quantity: number, // iOS only
+    contextKeys: string[] | null | undefined,
+    promoOffer: QPromoOfferDetails | undefined, // iOS only
+    offerId: string | null | undefined, // Android only
+    applyOffer: boolean, // Android only
+    oldProductId: string | null | undefined, // Android only
+    updatePolicyKey: string | null | undefined, // Android only
+  ): Promise<Object | null | undefined>; // Record<string, QEntitlement
+  updatePurchase(
+    productId: string,
+    offerId: string | null | undefined,
+    applyOffer: boolean,
+    oldProductId: string | null | undefined,
+    updatePolicyKey: string | null | undefined,
+  ): Promise<Object>; // Android only // Record<string, QEntitlement>
+  promoPurchase(productId: string): Promise<Object>; // iOS only / Record<string, QEntitlement
+  products(): Promise<Object>; // Record<string, QProduct
+  offerings(): Promise<QOfferings | null>;
+  checkTrialIntroEligibilityForProductIds(ids: string[]): Promise<Object>; // Record<string, QEligibilityInfo>
+  checkEntitlements(): Promise<Object>; // Record<string, QEntitlement>
+  restore(): Promise<Object>; // Record<string, QEntitlement>
+  syncPurchases(): void;
+  identify(userId: string): Promise<QUser>;
+  logout(): void;
+  userInfo(): Promise<QUser>;
+  addAttributionData(data: Object, provider: string): void;
+  setDefinedProperty(property: string, value: string): void;
+  setCustomProperty(property: string, value: string): void;
+  userProperties(): Promise<QUserProperties>;
+  collectAdvertisingId(): void; // iOS only
+  collectAppleSearchAdsAttribution(): void; // iOS only
+  presentCodeRedemptionSheet(): void; // iOS only
+  remoteConfig(contextKey: string | undefined): Promise<QRemoteConfig>;
+  remoteConfigList(): Promise<QRemoteConfigList>;
+  remoteConfigListForContextKeys(contextKeys: string[], includeEmptyContextKey: boolean): Promise<QRemoteConfigList>;
+  attachUserToExperiment(experimentId: string, groupId: string): Promise<void>;
+  detachUserFromExperiment(experimentId: string): Promise<void>;
+  attachUserToRemoteConfiguration(remoteConfigurationId: string): Promise<void>;
+  detachUserFromRemoteConfiguration(remoteConfigurationId: string): Promise<void>;
+
+  readonly onEntitlementsUpdated: EventEmitter<Object>; // Record<string, QEntitlement>
+  readonly onPromoPurchaseReceived: EventEmitter<string>;
+}
+
+export default TurboModuleRegistry.getEnforcing<Spec>('RNQonversion');

package/src/internal/utils.ts

@@ -0,0 +1,9 @@
+import {Platform} from "react-native";
+
+export const isIos = (): boolean => {
+    return Platform.OS === "ios"
+};
+
+export const isAndroid = (): boolean => {
+    return Platform.OS === "android"
+};