react-native-sdk-pianoio 0.3.1 → 0.3.4

package/src/PianoComposer.tsx

@@ -1,184 +1,121 @@
 import SdkPianoio from './NativeSdkPianoio';
 
+/**
+ * A wrapper class for the native SdkPianoio module that provides a clean,
+ * object-oriented API for interacting with the Piano SDK.
+ */
 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;
-
-  private constructor(aid: string) {
-    this.aid = aid;
+  // The constructor is private to force users to use the async `create` method.
+  private constructor() {
+    // This constructor is intentionally empty.
   }
 
+  /**
+   * Creates and initializes a new PianoComposer instance.
+   * This is the main 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);
+    // Call the corrected native initialize method
+    await SdkPianoio.initialize(aid);
+    return new PianoComposer();
   }
 
-  async addTag(tag: string) {
-    this.tags.push(tag);
-    return SdkPianoio.addComposerTag(tag);
-  }
+  // --- Configuration Methods ---
 
-  async addTags(tags: string[]) {
-    this.tags.push(...tags);
-    return SdkPianoio.addComposerTags(tags);
+  async addTag(tag: string): Promise<boolean> {
+    return SdkPianoio.addTag(tag);
   }
 
-  async setZoneId(zoneId: string) {
-    this.zoneId = zoneId;
-    return SdkPianoio.setComposerZoneId(zoneId);
+  async addTags(tags: string[]): Promise<boolean> {
+    return SdkPianoio.addTags(tags);
   }
 
-  async setReferrer(referrer: string) {
-    this.referrer = referrer;
-    return SdkPianoio.setComposerReferrer(referrer);
+  async setZoneId(zoneId: string): Promise<boolean> {
+    return SdkPianoio.setZoneId(zoneId);
   }
 
-  async setCustomVariable(name: string, value: string) {
-    this.customVariables[name] = value;
-
-    return SdkPianoio.setComposerCustomVariable(name, value);
+  async setReferrer(referrer: string): Promise<boolean> {
+    return SdkPianoio.setReferrer(referrer);
   }
 
-  async setUserToken(token: string) {
-    this.userToken = token;
-    return SdkPianoio.setComposerUserToken(token);
+  async setCustomVariable(name: string, value: string): Promise<boolean> {
+    return SdkPianoio.addCustomVariable(name, value);
   }
 
-  async setUrl(url: string) {
-    this.url = url;
-    return SdkPianoio.setComposerUrl(url);
+  async setCustomVariables(variables: { [key: string]: string }): Promise<boolean> {
+    return SdkPianoio.setCustomVariables(variables);
   }
 
-  async execute() {
-    return SdkPianoio.executeComposer();
+  async setUserToken(token: string): Promise<boolean> {
+    return SdkPianoio.setUserToken(token);
   }
 
-  async executeExperience() {
-    try {
-      let r = await SdkPianoio.executeExperience();
-      console.log('executeExperience triggered');
-      console.log('Experience executed:', r);
-    } catch (e) {
-      console.error('Errore nel executeExperience:', e);
-    }
+  async setUrl(url: string): Promise<boolean> {
+    return SdkPianoio.setUrl(url);
   }
 
-  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);
-    }
-  }
+  // --- Authentication Methods ---
 
-  async showForm() {
-    return SdkPianoio.showForm();
+  /**
+   * Signs in the user with Piano.
+   * @returns A promise that resolves with user information.
+   */
+  async signIn(): Promise<any> {
+    return SdkPianoio.signIn();
   }
 
-  async showLogin() {
-    try {
-      await SdkPianoio.showLogin();
-      console.log('Login triggered');
-    } catch (e) {
-      console.error('Errore nel login:', e);
-    }
+  /**
+   * Signs out the current user.
+   * @returns A promise that resolves when sign out is complete.
+   */
+  async signOut(): Promise<any> {
+    return SdkPianoio.signOut();
   }
 
-  async showTemplate() {
-    try {
-      await SdkPianoio.showTemplate();
-      console.log('Template triggered');
-    } catch (e) {
-      console.error('Errore nel Template:', e);
-    }
+  /**
+   * Gets information about the current authenticated user.
+   * @returns A promise that resolves with user information.
+   */
+  async getCurrentUser(): Promise<any> {
+    return SdkPianoio.getCurrentUser();
   }
 
-  async showRecommendations() {
-    try {
-      await SdkPianoio.showRecommendations();
-      console.log('showRecommendations triggered');
-    } catch (e) {
-      console.error('Errore nel Template:', e);
-    }
+  /**
+   * Checks if a user is currently authenticated.
+   * @returns A promise that resolves with the authentication status.
+   */
+  async isAuthenticated(): Promise<any> {
+    return SdkPianoio.isAuthenticated();
   }
 
-  async nonSite() {
-    try {
-      await SdkPianoio.nonSite();
-      console.log('nonSite triggered');
-    } catch (e) {
-      console.error('Errore nel Template:', e);
-    }
-  }
+  // --- Core Execution Method ---
 
-  async userSegmentTrue() {
-    try {
-      await SdkPianoio.userSegmentTrue();
-      console.log('userSegmentTrue triggered');
-    } catch (e) {
-      console.error('Errore nel userSegmentTrue:', 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(): Promise<any> {
+    return SdkPianoio.executeExperience();
   }
 
-  async userSegmentFalse() {
-    try {
-      await SdkPianoio.userSegmentFalse();
-      console.log('userSegmentFalse triggered');
-    } catch (e) {
-      console.error('Errore nel userSegmentFalse:', e);
-    }
-  }
+  // --- Utility and Cleanup Methods ---
 
-  async meterActive() {
-    try {
-      await SdkPianoio.meterActive();
-      console.log('Template meterActive');
-    } catch (e) {
-      console.error('Errore nel meterActive:', e);
-    }
+  /**
+   * Gets the current status of the SDK.
+   * @returns A promise that resolves with status information.
+   */
+  async getStatus(): Promise<any> {
+    return SdkPianoio.getStatus();
   }
 
-  async meterExpired() {
-    try {
-      await SdkPianoio.meterExpired();
-      console.log('meterExpired triggered');
-    } catch (e) {
-      console.error('Errore nel meterExpired:', e);
-    }
-  }
-
-  static async isInitialized(): Promise<boolean> {
-    try {
-      const result = await SdkPianoio.getComposer();
-      return result !== null;
-    } catch (e) {
-      return false;
-    }
-  }
-
-  static async getComposerFromSdkIOS() {
-    const result = await SdkPianoio.getComposer();
-
-    return result;
-  }
-
-  async toString() {
-    return `PianoComposer {
-            aid: ${this.aid},
-            tags: ${this.tags},
-            zoneId: ${this.zoneId},
-            referrer: ${this.referrer},
-            customVariables: ${JSON.stringify(this.customVariables)},
-            userToken: ${this.userToken},
-            url: ${this.url}
-        }`;
+  /**
+   * Clears all configured tags and custom variables.
+   * @returns A promise that resolves when the configuration is cleared.
+   */
+  async clearConfiguration(): Promise<boolean> {
+    return SdkPianoio.clearConfiguration();
   }
 }
 

package/src/index.tsx

@@ -1,16 +1,2 @@
-// import SdkPianoio from './NativeSdkPianoio';
 export { default as PianoComposer } from './PianoComposer';
 export { debugNativeModule } from './debug';
-
-// export const {
-//   initializeComposer,
-//   getComposer,
-//   addComposerTag,
-//   addComposerTags,
-//   setComposerZoneId,
-//   setComposerReferrer,
-//   setComposerUrl,
-//   setComposerCustomVariable,
-//   setComposerUserToken,
-//   executeComposer
-// } = SdkPianoio;

package/android/src/main/AndroidManifestNew.xml

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

package/ios/services/TokenService.swift

@@ -1,70 +0,0 @@
-//
-//  TokenService.swift
-//  Pods
-//
-//  Created by Alessia Sarak on 24.04.2025.
-//
-
-import PianoOAuth
-
-public class TokenService: NSObject, PianoIDDelegate {
-
-    @Published private(set) var initialized = false
-    @Published private(set) var token: PianoIDToken?
-
-    public override init() {
-        /// Set Piano ID settings
-        PianoID.shared.endpoint = PianoEndpoint.sandbox
-        PianoID.shared.aid = ComposerPianoImpl.aid
-
-        super.init()
-
-        PianoID.shared.delegate = self
-
-        token = PianoID.shared.currentToken
-        request { [weak self] _ in
-            DispatchQueue.main.async {
-                self?.initialized = true
-            }
-        }
-    }
-
-    func request(completion: @escaping (PianoIDToken?) -> Void) {
-        if let t = token {
-            if t.isExpired {
-                /// Refresh token if expired
-                PianoID.shared.refreshToken(t.refreshToken) { token, error in
-                    if let t = token {
-                        self.token = t
-                        completion(t)
-                        return
-                    }
-                    completion(nil)
-                }
-            } else {
-                completion(t)
-            }
-            return
-        }
-
-        completion(nil)
-    }
-
-    /// Sign In callback
-    public func signIn(result: PianoIDSignInResult!, withError error: Error!) {
-        if let r = result {
-            token = r.token
-        } else {
-          
-        }
-    }
-
-    /// Sign Out callback
-    public func signOut(withError error: Error!) {
-        token = nil
-    }
-
-    /// Cancel callback
-    public func cancel() {
-    }
-}