react-native-sdk-pianoio 0.3.0 → 0.3.2

package/src/NativeSdkPianoio.ts

@@ -1,28 +1,26 @@
-import { NativeModules } from 'react-native';
+import { NativeModules, Platform } from 'react-native';
 
 interface SdkPianoioType {
-  initializeComposer(aid: string): Promise<any>;
+  initializeComposer(aid: string): Promise<boolean>;
+  executeExperience(): Promise<any>;
   getComposer(): Promise<any>;
-  addComposerTag(tag: string): Promise<any>;
-  addComposerTags(tags: string[]): Promise<any>;
-  setComposerZoneId(zoneId: string): Promise<any>;
-  setComposerReferrer(referrer: string): Promise<any>;
-  setComposerUrl(url: string): Promise<any>;
-  setComposerCustomVariable(name: string, value: string): Promise<any>;
-  setComposerUserToken(token: string): Promise<any>;
-  executeComposer(): Promise<void>;
 
-  experienceExecute(): Promise<boolean>;
-  showLogin(): Promise<boolean>;
-  showTemplate(): Promise<boolean>;
-  showForm(): Promise<boolean>;
-  showRecommendations(): Promise<boolean>;
-  nonSite(): Promise<boolean>;
-  userSegmentTrue(): Promise<boolean>;
-  userSegmentFalse(): Promise<boolean>;
-  meterActive(): Promise<boolean>;
-  meterExpired(): Promise<boolean>;
-  composerExecutionCompleted(): Promise<boolean>;
+  addComposerTag(tag: string): Promise<void>;
+  addComposerTags(tags: string[]): Promise<void>;
+  setComposerZoneId(zoneId: string): Promise<void>;
+  setComposerReferrer(referrer: string): Promise<void>;
+  setComposerUrl(url: string): Promise<void>;
+  setComposerCustomVariable(name: string, value: string): Promise<void>;
+  setComposerUserToken(token: string): Promise<void>;
 }
 
-export default NativeModules.SdkPianoio as SdkPianoioType;
+const SdkPianoio = NativeModules.SdkPianoio;
+
+if (!SdkPianoio) {
+  throw new Error(
+    `react-native-sdk-pianoio: Native module 'SdkPianoio' is not available on ${Platform.OS}. ` +
+      'Make sure you have properly linked the library and rebuilt your app.'
+  );
+}
+
+export default SdkPianoio as SdkPianoioType;

package/src/PianoComposer.tsx

@@ -1,158 +1,80 @@
 import SdkPianoio from './NativeSdkPianoio';
 
 class PianoComposer {
-  aid: string;
-  tags: string[] = [];
-  zoneId: string | null = null;
-  referrer: string | null = null;
-  customVariables: { [key: string]: string } = {};
-  userToken: string | null = null;
-  url: string | null = null;
-
+  // --- Properties to hold configuration state ---
+  private aid: string;
+  private tags: string[] = [];
+  private zoneId: string | null = null;
+  private referrer: string | null = null;
+  private customVariables: { [key: string]: string } = {};
+  private userToken: string | null = null;
+  private url: string | null = null;
+
+  // The constructor is private to force users to use the async `create` method.
   private constructor(aid: string) {
     this.aid = aid;
   }
 
+  /**
+   * Creates and initializes a new PianoComposer instance.
+   * This is the entry point for using the library.
+   * @param aid Your Application ID from Piano.io
+   */
   static async create(aid: string): Promise<PianoComposer> {
     await SdkPianoio.initializeComposer(aid);
     return new PianoComposer(aid);
   }
 
+  // --- Configuration Methods ---
+
   async addTag(tag: string) {
-    this.tags.push(tag);
+    this.tags.push(tag); // Store state locally
     return SdkPianoio.addComposerTag(tag);
   }
 
   async addTags(tags: string[]) {
-    this.tags.push(...tags);
+    this.tags.push(...tags); // Store state locally
     return SdkPianoio.addComposerTags(tags);
   }
 
   async setZoneId(zoneId: string) {
-    this.zoneId = zoneId;
+    this.zoneId = zoneId; // Store state locally
     return SdkPianoio.setComposerZoneId(zoneId);
   }
 
   async setReferrer(referrer: string) {
-    this.referrer = referrer;
+    this.referrer = referrer; // Store state locally
     return SdkPianoio.setComposerReferrer(referrer);
   }
 
   async setCustomVariable(name: string, value: string) {
-    this.customVariables[name] = value;
-
+    this.customVariables[name] = value; // Store state locally
     return SdkPianoio.setComposerCustomVariable(name, value);
   }
 
   async setUserToken(token: string) {
-    this.userToken = token;
+    this.userToken = token; // Store state locally
     return SdkPianoio.setComposerUserToken(token);
   }
 
   async setUrl(url: string) {
-    this.url = url;
+    this.url = url; // Store state locally
     return SdkPianoio.setComposerUrl(url);
   }
 
-  async execute() {
-    return SdkPianoio.executeComposer();
-  }
-
-  async experienceExecute() {
-    try {
-      let r = await SdkPianoio.experienceExecute();
-      console.log('experienceExecute triggered');
-      console.log('Experience executed:', r);
-    } catch (e) {
-      console.error('Errore nel experienceExecute:', e);
-    }
-  }
-
-  async composerExecutionCompleted() {
-    try {
-      let r = await SdkPianoio.composerExecutionCompleted();
-      console.log('composerExecutionCompleted triggered');
-      console.log('Composer execution completed:', r);
-    } catch (e) {
-      console.error('Errore nel composerExecutionCompleted:', e);
-    }
-  }
-
-  async showForm() {
-    return SdkPianoio.showForm();
-  }
-
-  async showLogin() {
-    try {
-      await SdkPianoio.showLogin();
-      console.log('Login triggered');
-    } catch (e) {
-      console.error('Errore nel login:', e);
-    }
-  }
-
-  async showTemplate() {
-    try {
-      await SdkPianoio.showTemplate();
-      console.log('Template triggered');
-    } catch (e) {
-      console.error('Errore nel Template:', e);
-    }
-  }
-
-  async showRecommendations() {
-    try {
-      await SdkPianoio.showRecommendations();
-      console.log('showRecommendations triggered');
-    } catch (e) {
-      console.error('Errore nel Template:', e);
-    }
-  }
+  // --- Core Execution Method ---
 
-  async nonSite() {
-    try {
-      await SdkPianoio.nonSite();
-      console.log('nonSite triggered');
-    } catch (e) {
-      console.error('Errore nel Template:', e);
-    }
+  /**
+   * Executes the Piano experience with the current configuration.
+   * This is the primary method to get a decision from the Piano backend.
+   * @returns A promise that resolves with the event data object from the native SDK.
+   */
+  async executeExperience() {
+    // This now correctly calls the native method AND returns the result.
+    return SdkPianoio.executeExperience();
   }
 
-  async userSegmentTrue() {
-    try {
-      await SdkPianoio.userSegmentTrue();
-      console.log('userSegmentTrue triggered');
-    } catch (e) {
-      console.error('Errore nel userSegmentTrue:', e);
-    }
-  }
-
-  async userSegmentFalse() {
-    try {
-      await SdkPianoio.userSegmentFalse();
-      console.log('userSegmentFalse triggered');
-    } catch (e) {
-      console.error('Errore nel userSegmentFalse:', e);
-    }
-  }
-
-  async meterActive() {
-    try {
-      await SdkPianoio.meterActive();
-      console.log('Template meterActive');
-    } catch (e) {
-      console.error('Errore nel meterActive:', e);
-    }
-  }
-
-  async meterExpired() {
-    try {
-      await SdkPianoio.meterExpired();
-      console.log('meterExpired triggered');
-    } catch (e) {
-      console.error('Errore nel meterExpired:', e);
-    }
-  }
+  // --- Static Helper Methods ---
 
   static async isInitialized(): Promise<boolean> {
     try {
@@ -164,15 +86,13 @@ class PianoComposer {
   }
 
   static async getComposerFromSdkIOS() {
-    const result = await SdkPianoio.getComposer();
-
-    return result;
+    return SdkPianoio.getComposer();
   }
 
   async toString() {
     return `PianoComposer {
             aid: ${this.aid},
-            tags: ${this.tags},
+            tags: ${this.tags.join(',')},
             zoneId: ${this.zoneId},
             referrer: ${this.referrer},
             customVariables: ${JSON.stringify(this.customVariables)},

package/src/debug.ts

@@ -0,0 +1,19 @@
+import { NativeModules, Platform } from 'react-native';
+
+export const debugNativeModule = () => {
+  console.log('🔍 Debugging Native Module...');
+  console.log('Platform:', Platform.OS);
+  console.log('Available Native Modules:', Object.keys(NativeModules));
+
+  const SdkPianoio = NativeModules.SdkPianoio;
+  console.log('SdkPianoio module:', SdkPianoio);
+
+  if (SdkPianoio) {
+    console.log('✅ SdkPianoio module found!');
+    console.log('Available methods:', Object.keys(SdkPianoio));
+  } else {
+    console.log('❌ SdkPianoio module NOT found!');
+  }
+
+  return SdkPianoio;
+};

package/src/index.tsx

@@ -1,5 +1,6 @@
 // import SdkPianoio from './NativeSdkPianoio';
 export { default as PianoComposer } from './PianoComposer';
+export { debugNativeModule } from './debug';
 
 // export const {
 //   initializeComposer,

package/ios/ComposerPiano.swift

@@ -1,304 +0,0 @@
-//
-//  ComposerPiano.swift
-//  SdkPianoio
-//
-//
-import Foundation
-import PianoComposer
-import PianoOAuth
-import PianoConsents
-import PianoTemplate
-import React
-
-import SwiftUI
-
-
-@objcMembers public class ComposerPianoImpl: NSObject {
-  private var composer: PianoComposer?;
-  private var delegateHelper : MyComposerDelegate?;
-  public static var aid = "";
-  
-  @objc public func initializeComposer(_ aid: String) -> PianoComposer? {
-    ComposerPianoImpl.aid = aid;
-    let tokenService = TokenService();
-    delegateHelper = MyComposerDelegate(tokenService: tokenService);
-    composer = PianoComposer(aid: ComposerPianoImpl.aid, endpoint: PianoEndpoint.productionEurope);
-    composer = delegateHelper?.setComposerAndDelegate(composer!);
-    return composer;
-  }
-  
-  @objc public func addTag(_ tag: String) -> PianoComposer? {
-    return composer?.tag(tag);
-  }
-  @objc public func addTagToComposer(_ composer: PianoComposer, tag: String) {
-    composer.tag(tag);
-  }
-  
-  @objc public func addTags(_ tags: [String]) -> PianoComposer? {
-    return composer?.tags(tags);
-  }
-  
-  @objc public func setZoneId(_ zoneId: String) -> PianoComposer? {
-    return composer?.zoneId(zoneId);
-  }
-  
-  @objc public func setReferrer(_ referrer: String) -> PianoComposer? {
-    return composer?.referrer(referrer);
-  }
-  
-  @objc public func setUrl(_ url: String) -> PianoComposer? {
-    return composer?.url(url);
-  }
-  
-  @objc public func setCustomVariable(_ name: String, value: String) -> PianoComposer? {
-    return composer?.customVariable(name: name, value: value);
-  }
-  
-  @objc public func setUserToken(_ token: String) -> PianoComposer? {
-    return composer?.userToken(token);
-  }
-  
-  @objc public func executeComposer() {
-    print("Esecuzione composer")
-    DispatchQueue.main.async( group: nil, qos: .unspecified, flags: [], execute: {
-      guard let rootVC = UIApplication.shared.connectedScenes
-                .compactMap({ $0 as? UIWindowScene })
-                .first(where: { $0.activationState == .foregroundActive })?.windows
-                .first(where: { $0.isKeyWindow })?.rootViewController else {
-        
-        return
-      }
-      if let composer = self.composer {
-        print("Va nell'esecuzione yaay")
-
-        composer.execute()
-      } else {
-        print("⚠️ Composer è nil")
-      }
-    })
-  }
-  
-  // Delegate handler
-  @objc public func executeExperience(_ completion: @escaping (NSNumber) -> Void) {
-    let eventDict: [String: Any] = [
-        "eventType": "login"
-    ]
-    let xpEvent = XpEvent(dict: eventDict)
-
-    guard let composer = composer, let _ = composer.delegate else {
-        completion(NSNumber(value: false))
-        return
-    }
-
-    delegateHelper?.executeExperience(composer: composer, event: xpEvent, params: nil)
-  }
-  
-  @objc public func composerExecutionCompleted() {
-    let eventDict: [String: Any] = [
-        "eventType": "login"
-    ]
-    let xpEvent = XpEvent(dict: eventDict)
-    
-    if(composer != nil && composer!.delegate != nil ) {
-      delegateHelper?.composerExecutionCompleted(composer: composer!);
-    }
-  }
-  
-  @objc public func showLogin() {
-    let eventDict: [String: Any] = [
-        "eventType": "login"
-    ];
-
-    let xpEvent = XpEvent(dict: eventDict);
-    
-    if(composer != nil && composer!.delegate != nil ) {
-      delegateHelper?.myShowLogin(composer: composer!, event: xpEvent, params: nil);
-    }
-  }
-  
-  @objc public func showTemplate() {
-      DispatchQueue.main.async {
-          guard let rootVC = UIApplication.shared
-                  .connectedScenes
-                  .compactMap({ $0 as? UIWindowScene })
-                  .flatMap({ $0.windows })
-                  .first(where: { $0.isKeyWindow })?
-                  .rootViewController else {
-              print("⚠️ rootViewController non trovato")
-              return
-          }
-
-          let tokenService = self.delegateHelper!.tokenService
-          let view = ShowTemplateView(tokenService: tokenService)
-          let hostingController = UIHostingController(rootView: view)
-          hostingController.modalPresentationStyle = .fullScreen
-
-          rootVC.present(hostingController, animated: true, completion: nil)
-      }
-  }
-  
-  @objc public func showForm() {
-    let eventDict: [String: Any] = [
-        "eventType": "form"
-    ];
-
-    let xpEvent = XpEvent(dict: eventDict);
-    
-    if(composer != nil && composer!.delegate != nil ) {
-      delegateHelper?.myShowForm(composer: composer!, event: xpEvent, params: nil);
-    }
-  }
-  
-  @objc public func  showRecommendations() {
-    let eventDict: [String: Any] = [
-        "eventType": "recommendations"
-    ];
-
-    let xpEvent = XpEvent(dict: eventDict);
-    
-    if(composer != nil && composer!.delegate != nil ) {
-      delegateHelper?.showRecommendations(composer: composer!, event: xpEvent, params: nil)
-    }
-  }
-  
-  @objc public func nonSite() {
-    let eventDict: [String: Any] = [
-        "eventType": "nonSite"
-    ]
-
-    let xpEvent = XpEvent(dict: eventDict)
-
-    if(composer != nil && composer!.delegate != nil ) {
-      delegateHelper?.nonSite(composer: composer!, event: xpEvent)
-    }
-  }
-
-  @objc public func userSegmentTrue() {
-    let eventDict: [String: Any] = [
-        "eventType": "userSegmentTrue"
-    ]
-
-    let xpEvent = XpEvent(dict: eventDict)
-
-    if(composer != nil && composer!.delegate != nil ) {
-      delegateHelper?.userSegmentTrue(composer: composer!, event: xpEvent)
-    }
-  }
-
-  @objc public func userSegmentFalse() {
-    let eventDict: [String: Any] = [
-        "eventType": "userSegmentFalse"
-    ]
-
-    let xpEvent = XpEvent(dict: eventDict)
-
-    if(composer != nil && composer!.delegate != nil ) {
-      delegateHelper?.userSegmentFalse(composer: composer!, event: xpEvent)
-    }
-  }
-
-  @objc public func meterActive() {
-    let eventDict: [String: Any] = [
-        "eventType": "meterActive"
-    ]
-
-    let xpEvent = XpEvent(dict: eventDict)
-    
-    if(composer != nil && composer!.delegate != nil ) {
-      delegateHelper?.meterActive(composer: composer!, event: xpEvent, params: nil)
-    }
-  }
-
-  @objc public func meterExpired() {
-    let eventDict: [String: Any] = [
-        "eventType": "meterExpired"
-    ]
-
-    let xpEvent = XpEvent(dict: eventDict)
-    
-    if(composer != nil && composer!.delegate != nil ) {
-      delegateHelper?.meterExpired(composer: composer!, event: xpEvent, params: nil)
-    }
-  }
-
-  @objc public func experienceExecute() {
-    let eventDict: [String: Any] = [
-        "eventType": "experienceExecute"
-    ]
-
-    let xpEvent = XpEvent(dict: eventDict)
-    
-    if(composer != nil && composer!.delegate != nil ) {
-      delegateHelper?.experienceExecute(composer: composer!, event: xpEvent, params: nil)
-    }
-  }
-  
-
-  
-  public func findViewBySelector(selector: String) -> UIView? {
-    return nil;
-  }
-
-  
-  // method to get values and helpers
-  @objc public func getAid() -> String {
-    if(composer != nil){
-      return composer?.aid ?? "";
-    } else {
-      return "";
-    }
-  }
-  
-  @objc public func getTags() -> [String] {
-      if let tags = composer?.tags, !tags.isEmpty {
-          return Array(tags)  // Restituisce l'array dei tag se presenti e non vuoti
-      } else {
-          return []  // Restituisce un array vuoto se non ci sono tag
-      }
-  }
-  
-  @objc public func getComposer() -> PianoComposer? {
-    return composer;
-  }
-  
-  @objc public func getZoneId() -> String {
-      return composer?.zoneId ?? ""
-  }
-
-  @objc public func getReferrer() -> String {
-      return composer?.referrer ?? ""
-  }
-
-  @objc public func getUrl() -> String {
-      return composer?.url ?? ""
-  }
-
-  @objc public func getUserToken() -> String {
-      return composer?.userToken ?? ""
-  }
-  
-  @objc public func addTagsToComposer(_ composer: PianoComposer, tags: [String]) {
-      composer.tags(tags)
-  }
-
-  @objc public func setCustomVariable(_ composer: PianoComposer, name: String, value: String) {
-      composer.customVariable(name: name, value: value)
-  }
-
-  @objc public func setReferrer(_ composer: PianoComposer, referrer: String) {
-      composer.referrer(referrer)
-  }
-
-  @objc public func setUrl(_ composer: PianoComposer, url: String) {
-      composer.url(url)
-  }
-
-  @objc public func setUserToken(_ composer: PianoComposer, token: String) {
-      composer.userToken(token)
-  }
-
-  @objc public func setZoneId(_ composer: PianoComposer, zoneId: String) {
-      composer.zoneId(zoneId)
-  }
-
-}

package/ios/SdkPianoio.h

@@ -1,4 +0,0 @@
-#import <React/RCTBridgeModule.h>
-
-@interface SdkPianoio : NSObject <RCTBridgeModule>
-@end