@adobe/react-native-aepmessaging 7.1.1 → 7.2.1

package/ios/src/RCTAEPMessaging.swift

@@ -21,6 +21,7 @@ import WebKit
 @objc(RCTAEPMessaging)
 public class RCTAEPMessaging: RCTEventEmitter, MessagingDelegate {
     private var messageCache = [String: Message]()
+    private var jsHandlerMessageCache = [String: Message]()
     private var latestMessage: Message? = nil
     private let semaphore = DispatchSemaphore(value: 0)
     private var shouldSaveMessage = false
@@ -64,7 +65,7 @@ public class RCTAEPMessaging: RCTEventEmitter, MessagingDelegate {
     ) {
         resolve(self.latestMessage != nil ? RCTAEPMessagingDataBridge.transformToMessage(message: self.latestMessage!) : nil)
     }
-
+      
     @objc
     func getPropositionsForSurfaces(
         _ surfaces: [String],
@@ -72,16 +73,29 @@ public class RCTAEPMessaging: RCTEventEmitter, MessagingDelegate {
         withRejecter reject: @escaping RCTPromiseRejectBlock
     ) {
         let surfacePaths = surfaces.map { $0.isEmpty ? Surface() : Surface(path: $0) }
-        Messaging.getPropositionsForSurfaces(surfacePaths) { propositions, error in
+        Messaging.getPropositionsForSurfaces(surfacePaths) { [weak self] propositions, error in
+            guard let self = self else { return }
             guard error == nil else {
                 reject("Unable to Retrieve Propositions", nil, nil)
                 return
             }
-            if (propositions != nil && propositions!.isEmpty) {
-                resolve([String: Any]());
-                return;
+            guard let propositions = propositions, !propositions.isEmpty else {
+                resolve([String: Any]())
+                return
             }
-            resolve(RCTAEPMessagingDataBridge.transformPropositionDict(dict: propositions!))
+
+            // Populate uuid->Proposition map using scopeDetails.activity.id
+            for (_, list) in propositions {
+                for proposition in list {
+                    if let pMap = proposition.asDictionary() {
+                        if let key = RCTAEPMessagingDataBridge.extractActivityId(from: pMap) {
+                            self.propositionByUuid[key] = proposition
+                        }
+                    }
+                }
+            }
+
+            resolve(RCTAEPMessagingDataBridge.transformPropositionDict(dict: propositions))
         }
     }
 
@@ -113,92 +127,81 @@ public class RCTAEPMessaging: RCTEventEmitter, MessagingDelegate {
     ) {
         let mapped = surfaces.map { Surface(path: $0) }
         Messaging.updatePropositionsForSurfaces(mapped)
+        propositionByUuid.removeAll()
         resolve(nil)
     }
 
     /// Message Class Methods
     @objc
-    func clearMessage(
-        _ id: String,
-        withResolver resolve: @escaping RCTPromiseResolveBlock,
-        withRejecter reject: @escaping RCTPromiseRejectBlock
+    func clear(
+        _ id: String
     ) {
         let msg = messageCache[id]
         if msg != nil {
             messageCache.removeValue(forKey: msg!.id)
-            resolve(nil)
+            print("clear: \(id) removed")
+        } else {
+            print("clear: \(id) not found")
         }
-        reject(Constants.CACHE_MISS, nil, nil)
     }
 
     @objc
-    func dismissMessage(
+    func dismiss(
         _ id: String,
-        withSuppressAutoTrack suppressAutoTrack: Bool,
-        withResolver resolve: @escaping RCTPromiseResolveBlock,
-        withRejecter reject: @escaping RCTPromiseRejectBlock
+        suppressAutoTrack: Bool
     ) {
         let msg = messageCache[id]
         if msg != nil {
             msg!.dismiss(suppressAutoTrack: suppressAutoTrack)
-            resolve(nil)
-            return
+            print("dismiss: \(id) to \(suppressAutoTrack)")
+        } else {
+            print("dismiss: \(id) not found")
         }
-        reject(Constants.CACHE_MISS, nil, nil)
     }
 
     @objc
     func setAutoTrack(
         _ id: String,
-        withSuppressAutoTrack suppressAutoTrack: Bool,
-        withResolver resolve: @escaping RCTPromiseResolveBlock,
-        withRejecter reject: @escaping RCTPromiseRejectBlock
+        autoTrack: Bool
     ) {
-
         let msg = messageCache[id]
-        if msg != nil {
-            msg!.autoTrack = suppressAutoTrack
-            resolve(nil)
-            return
+        if (msg != nil) {
+            msg!.autoTrack = autoTrack
+            print("setAutoTrack: \(id) to \(autoTrack)")
+        } else {
+            print("setAutoTrack: \(id) not found")
         }
-        reject(Constants.CACHE_MISS, nil, nil)
     }
 
     @objc
-    private func showMessage(
-        _ id: String,
-        withResolver resolve: @escaping RCTPromiseResolveBlock,
-        withRejecter reject: @escaping RCTPromiseRejectBlock
+    private func show(
+        _ id: String
     ) {
         let msg = messageCache[id]
         if msg != nil {
             msg!.show()
-            resolve(nil)
-            return
+            print("show: \(id) shown")
+        } else {
+            print("show: \(id) not found")
         }
-        reject(Constants.CACHE_MISS, nil, nil)
-
     }
 
     @objc
-    func trackMessage(
+    func track(
         _ id: String,
-        withInteraction interaction: String,
-        withEventType eventType: Int,
-        withResolver resolve: @escaping RCTPromiseResolveBlock,
-        withRejecter reject: @escaping RCTPromiseRejectBlock
+        interaction: String,
+        eventType: Int
     ) {
-
         let msg = messageCache[id]
         let eventType =
             MessagingEdgeEventType.init(rawValue: eventType)
                 ?? MessagingEdgeEventType.dismiss
         if msg != nil {
             msg!.track(interaction, withEdgeEventType: eventType)
-            resolve(nil)
-            return
+            print("track: \(id) to \(interaction) and \(eventType)")
+        } else {
+            print("track: \(id) not found")
         }
-        reject(Constants.CACHE_MISS, nil, nil)
     }
 
     @objc
@@ -249,11 +252,95 @@ public class RCTAEPMessaging: RCTEventEmitter, MessagingDelegate {
         }
     }
 
+    @objc
+    func handleJavascriptMessage(
+        _ messageId: String,
+        handlerName: String
+    ) {
+        guard let message = jsHandlerMessageCache[messageId] else { 
+            print("[RCTAEPMessaging] handleJavascriptMessage: No message found in cache for messageId: \(messageId)")
+            return 
+        }
+
+        message.handleJavascriptMessage(handlerName) { [weak self] content in
+            self?.emitNativeEvent(
+                name: Constants.ON_JAVASCRIPT_MESSAGE_EVENT,
+                body: [
+                    Constants.MESSAGE_ID_KEY: messageId,
+                    Constants.HANDLER_NAME_KEY: handlerName,
+                    Constants.CONTENT_KEY: content ?? ""
+                ]
+            )
+        }
+    }
+
+    /// MARK: - Unified PropositionItem Tracking Methods
+    
+    /**
+     * Tracks interactions with a PropositionItem using the provided interaction and event type.
+     * This method is used by the React Native PropositionItem.track() method.
+     * 
+     * - Parameters:
+     *   - uuid: The UUID mapped to the PropositionItem (derived from activityId)
+     *   - interaction: A custom string value to be recorded in the interaction (optional)
+     *   - eventType: The MessagingEdgeEventType numeric value
+     *   - tokens: Array containing the sub-item tokens for recording interaction (optional)
+     */
+
+    @objc
+    func trackPropositionItem(
+        _ uuid: String,
+        interaction: String?,
+        eventType: Int,
+        tokens: [String]?,
+        withResolver resolve: @escaping RCTPromiseResolveBlock,
+        withRejecter reject: @escaping RCTPromiseRejectBlock
+    ) {
+        NSLog("[MessagingBridge] trackPropositionItem called with eventType=\(eventType), uuid=\(uuid), interaction=\(String(describing: interaction)), tokens=\(String(describing: tokens))")
+
+        guard !uuid.isEmpty else {
+            NSLog("[MessagingBridge] Empty uuid provided; no-op.")
+            resolve(nil)
+            return
+        }
+
+        guard let proposition = propositionByUuid[uuid] else {
+            NSLog("[MessagingBridge] No cached proposition for uuid=\(uuid); no-op.")
+            resolve(nil)
+            return
+        }
+
+        NSLog("[MessagingBridge] Found proposition for uuid=\(uuid). scope=\(proposition.scope), items=\(proposition.items.count)")
+
+        // Event type mapping (Android parity)
+        let edgeEventType = mapEdgeEventType(eventType) ?? .display
+
+        // Track on the first item under this proposition
+        guard let item = proposition.items.first else {
+            NSLog("[MessagingBridge] Proposition for uuid=\(uuid) has no items; no-op.")
+            resolve(nil)
+            return
+        }
+
+        // Direct call without normalization (expecting valid inputs)
+        NSLog("[MessagingBridge] Tracking (direct) uuid=\(uuid), interaction=\(String(describing: interaction)), tokens=\(String(describing: tokens)), eventType=\(edgeEventType.rawValue)")
+        item.track(interaction, withEdgeEventType: edgeEventType, forTokens: tokens)
+
+        NSLog("[MessagingBridge] Tracking complete for uuid=\(uuid)")
+        resolve(nil)
+    }
+
+
+
+    // Map uuid (scopeDetails.activity.id) -> parent Proposition
+    private var propositionByUuid = [String: Proposition]()
+   
     // Messaging Delegate Methods
     public func onDismiss(message: Showable) {
         if let fullscreenMessage = message as? FullscreenMessage,
             let parentMessage = fullscreenMessage.parent
         {
+            jsHandlerMessageCache.removeValue(forKey: parentMessage.id)
             emitNativeEvent(
                 name: Constants.ON_DISMISS_EVENT,
                 body: RCTAEPMessagingDataBridge.transformToMessage(
@@ -267,6 +354,7 @@ public class RCTAEPMessaging: RCTEventEmitter, MessagingDelegate {
         if let fullscreenMessage = message as? FullscreenMessage,
             let message = fullscreenMessage.parent
         {
+            jsHandlerMessageCache[message.id] = message
             emitNativeEvent(
                 name: Constants.ON_SHOW_EVENT,
                 body: RCTAEPMessagingDataBridge.transformToMessage(message: message)
@@ -328,3 +416,20 @@ public class RCTAEPMessaging: RCTEventEmitter, MessagingDelegate {
         RCTAEPMessaging.emitter.sendEvent(withName: name, body: body)
     }
 }
+
+// MARK: - Private helpers
+private extension RCTAEPMessaging {
+    /// Maps JS MessagingEdgeEventType integer values to AEPMessaging.MessagingEdgeEventType cases
+    /// JS enum values: DISMISS=0, INTERACT=1, TRIGGER=2, DISPLAY=3, PUSH_APPLICATION_OPENED=4, PUSH_CUSTOM_ACTION=5
+    func mapEdgeEventType(_ value: Int) -> MessagingEdgeEventType? {
+        switch value {
+        case 0: return .dismiss
+        case 1: return .interact
+        case 2: return .trigger
+        case 3: return .display
+        case 4: return .pushApplicationOpened
+        case 5: return .pushCustomAction
+        default: return nil
+        }
+    }
+}

package/ios/src/RCTAEPMessagingConstants.swift

@@ -16,7 +16,11 @@ class Constants {
     static let ON_SHOW_EVENT = "onShow"
     static let SHOULD_SHOW_MESSAGE_EVENT = "shouldShowMessage"
     static let URL_LOADED_EVENT = "urlLoaded"
+    static let ON_JAVASCRIPT_MESSAGE_EVENT = "onJavascriptMessage"
     static let SUPPORTED_EVENTS = [
-        ON_DISMISS_EVENT, ON_SHOW_EVENT, SHOULD_SHOW_MESSAGE_EVENT, URL_LOADED_EVENT,
+        ON_DISMISS_EVENT, ON_SHOW_EVENT, SHOULD_SHOW_MESSAGE_EVENT, URL_LOADED_EVENT, ON_JAVASCRIPT_MESSAGE_EVENT
     ]
+    static let MESSAGE_ID_KEY = "messageId"
+    static let HANDLER_NAME_KEY = "handlerName"
+    static let CONTENT_KEY = "content"
 }

package/ios/src/RCTAEPMessagingDataBridge.swift

@@ -27,4 +27,23 @@ public class RCTAEPMessagingDataBridge: NSObject {
                 .map({ $0.asDictionary() })
         }
     }
+
+    /// Extracts the activity identifier from a proposition dictionary at scopeDetails.activity.id
+    static func extractActivityId(from propositionDict: [String: Any]) -> String? {
+        guard let scopeDetails = propositionDict["scopeDetails"] as? [String: Any] else {
+            NSLog("[MessagingBridge] Missing scopeDetails on proposition; cannot extract activity.id")
+            return nil
+        }
+
+        guard let activity = scopeDetails["activity"] as? [String: Any] else {
+            NSLog("[MessagingBridge] Missing activity under scopeDetails; cannot extract activity.id")
+            return nil
+        }
+
+        guard let id = activity["id"] as? String, !id.isEmpty else {
+            NSLog("[MessagingBridge] Missing or empty activity.id; skipping uuid cache mapping")
+            return nil
+        }
+        return id
+    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adobe/react-native-aepmessaging",
-  "version": "7.1.1",
+  "version": "7.2.1",
   "description": "Adobe Experience Platform support for React Native apps.",
   "homepage": "https://developer.adobe.com/client-sdks/documentation/",
   "license": "Apache-2.0",
@@ -39,5 +39,5 @@
   "installConfig": {
     "hoistingLimits": "dependencies"
   },
-  "gitHead": "2e43601ac53a6982a643ff43d5af8276c675bf29"
+  "gitHead": "9e1fa8cd101f66602d9f9250fe8aa1f32b341da9"
 }

package/src/Messaging.ts

@@ -37,6 +37,7 @@ export interface NativeMessagingModule {
   updatePropositionsForSurfaces: (surfaces: string[]) => void;
   trackContentCardDisplay: (proposition: MessagingProposition, contentCard: ContentCard) => void;
   trackContentCardInteraction: (proposition: MessagingProposition, contentCard: ContentCard) => void;
+  trackPropositionItem: (itemId: string, interaction: string | null, eventType: number, tokens: string[] | null) => void;
 }
 
 const RCTAEPMessaging: NativeModule & NativeMessagingModule =
@@ -90,17 +91,46 @@ class Messaging {
   static async getPropositionsForSurfaces(
     surfaces: string[]
   ): Promise<Record<string, MessagingProposition[]>> {
-    return await RCTAEPMessaging.getPropositionsForSurfaces(surfaces);
-  }
 
+    const propositionsList = await RCTAEPMessaging.getPropositionsForSurfaces(surfaces);
+    let messagingPropositionsForSurfaces: Record<string, MessagingProposition[]> = {};
+    
+    for (const [surface, propositions] of Object.entries(propositionsList)) {
+      messagingPropositionsForSurfaces[surface] = propositions.map(
+        (proposition) => new MessagingProposition(proposition)
+      );
+    }
+
+    return messagingPropositionsForSurfaces;
+  }
+  
+  /**
+   * @deprecated Use PropositionItem.track(...) instead.
+   */
   static trackContentCardDisplay(proposition: MessagingProposition, contentCard: ContentCard): void {
     RCTAEPMessaging.trackContentCardDisplay(proposition, contentCard);
   }
 
+  /**
+   * @deprecated Use PropositionItem.track(...) instead.
+   */
   static trackContentCardInteraction(proposition: MessagingProposition, contentCard: ContentCard): void {
     RCTAEPMessaging.trackContentCardInteraction(proposition, contentCard);
   }
 
+  /**
+   * Tracks interactions with a PropositionItem using the provided interaction and event type.
+   * This method is used internally by the PropositionItem.track() method.
+   * 
+   * @param {string} itemId - The unique identifier of the PropositionItem
+   * @param {string | null} interaction - A custom string value to be recorded in the interaction
+   * @param {number} eventType - The MessagingEdgeEventType numeric value
+   * @param {string[] | null} tokens - Array containing the sub-item tokens for recording interaction
+   */
+  static trackPropositionItem(itemId: string, interaction: string | null, eventType: number, tokens: string[] | null): void {
+    RCTAEPMessaging.trackPropositionItem(itemId, interaction, eventType, tokens);
+  }
+
   /**
    * Function to set the UI Message delegate to listen the Message lifecycle events.
    * @returns A function to unsubscribe from all event listeners
@@ -110,31 +140,34 @@ class Messaging {
 
     const eventEmitter = new NativeEventEmitter(RCTAEPMessaging);
 
-    eventEmitter.addListener('onShow', (message) =>
-      messagingDelegate?.onShow?.(message)
+    eventEmitter.addListener('onShow', (message: Message) =>
+      messagingDelegate?.onShow?.(new Message(message))
     );
 
-    eventEmitter.addListener('onDismiss', (message) => {
-      messagingDelegate?.onDismiss?.(message);
+    eventEmitter.addListener('onDismiss', (message: Message) => {
+      const messageInstance = new Message(message);
+      messageInstance._clearJavascriptMessageHandlers();
+      messagingDelegate?.onDismiss?.(messageInstance);
     });
 
-    eventEmitter.addListener('shouldShowMessage', (message) => {
+    eventEmitter.addListener('shouldShowMessage', (message: Message) => {
+      const messageInstance = new Message(message);
       const shouldShowMessage =
-        messagingDelegate?.shouldShowMessage?.(message) ?? true;
+        messagingDelegate?.shouldShowMessage?.(messageInstance) ?? true;
       const shouldSaveMessage =
-        messagingDelegate?.shouldSaveMessage?.(message) ?? false;
+        messagingDelegate?.shouldSaveMessage?.(messageInstance) ?? false;
       RCTAEPMessaging.setMessageSettings(shouldShowMessage, shouldSaveMessage);
     });
 
     if (Platform.OS === 'ios') {
-      eventEmitter.addListener('urlLoaded', (event) =>
-        messagingDelegate?.urlLoaded?.(event.url, event.message)
+      eventEmitter.addListener('urlLoaded', (event: {url: string, message: Message}) =>
+        messagingDelegate?.urlLoaded?.(event.url, new Message(event.message))
       );
     }
 
     if (Platform.OS === 'android') {
-      eventEmitter.addListener('onContentLoaded', (event) =>
-        messagingDelegate?.onContentLoaded?.(event.message)
+      eventEmitter.addListener('onContentLoaded', (event: {message: Message}) =>
+        messagingDelegate?.onContentLoaded?.(new Message(event.message))
       );
     }
 

package/src/index.ts

@@ -11,25 +11,27 @@ governing permissions and limitations under the License.
 */
 
 import Messaging from './Messaging';
-import { ContentCard } from './models/ContentCard';
-import { HTMLProposition } from './models/HTMLProposition';
+import { ContentCard, ContentCardData } from './models/ContentCard';
+
 import { InAppMessage } from './models/InAppMessage';
-import { JSONPropositionItem } from './models/JSONPropositionItem';
+import { HTMLProposition, HTMLPropositionData } from './models/HTMLProposition';
+import { JSONPropositionItem, JSONPropositionData } from './models/JSONProposition';
+
 import Message from './models/Message';
 import { MessagingDelegate } from './models/MessagingDelegate';
 import MessagingEdgeEventType from './models/MessagingEdgeEventType';
 import { MessagingProposition } from './models/MessagingProposition';
 import { MessagingPropositionItem } from './models/MessagingPropositionItem';
 import { PersonalizationSchema } from './models/PersonalizationSchema';
+import { PropositionItem, PropositionItemData } from './models/PropositionItem';
 import { Activity, Characteristics } from './models/ScopeDetails';
 
 export {
   Activity,
   Characteristics,
   ContentCard,
-  HTMLProposition,
+  ContentCardData,
   InAppMessage,
-  JSONPropositionItem,
   Messaging,
   Message,
   MessagingDelegate,
@@ -37,4 +39,10 @@ export {
   MessagingProposition,
   MessagingPropositionItem,
   PersonalizationSchema,
+  PropositionItem,
+  PropositionItemData,
+  HTMLProposition,
+  HTMLPropositionData,
+  JSONPropositionItem,
+  JSONPropositionData,
 };

package/src/models/ContentCard.ts

@@ -11,11 +11,12 @@
 */
 
 import { PersonalizationSchema } from './PersonalizationSchema';
+import { PropositionItem, PropositionItemData } from './PropositionItem';
 
 type ContentCardTemplate = 'SmallImage';
 type DismissButtonStyle = 'circle' | 'none' | 'simple';
 
-export interface ContentCard {
+export interface ContentCardData extends PropositionItemData {
   id: string;
   data: {
     contentType: 'application/json';
@@ -45,3 +46,13 @@ export interface ContentCard {
   };
   schema: PersonalizationSchema.CONTENT_CARD;
 }
+
+export class ContentCard extends PropositionItem {
+  declare data: ContentCardData['data']; // Override data type for better typing
+
+  constructor(contentCardData: ContentCardData) {
+    super(contentCardData);
+    this.data = contentCardData.data;
+  }
+
+}

package/src/models/HTMLProposition.ts

@@ -11,11 +11,20 @@
 */
 
 import { PersonalizationSchema } from './PersonalizationSchema';
+import { PropositionItem, PropositionItemData } from './PropositionItem';
 
-export interface HTMLProposition {
-  id: string;
-  data: {
-    content: string;
-  };
-  schema: PersonalizationSchema.HTML_CONTENT;
+export interface HTMLPropositionData extends PropositionItemData {
+	data: {
+		content: string;
+	};
+	schema: PersonalizationSchema.HTML_CONTENT;
 }
+
+export class HTMLProposition extends PropositionItem {
+	declare data: HTMLPropositionData['data'];
+
+	constructor(htmlData: HTMLPropositionData) {
+		super(htmlData);
+		this.data = htmlData.data;
+	}
+}

package/src/models/{JSONPropositionItem.ts → JSONProposition.ts}

@@ -11,11 +11,20 @@
 */
 
 import { PersonalizationSchema } from './PersonalizationSchema';
+import { PropositionItem, PropositionItemData } from './PropositionItem';
 
-export interface JSONPropositionItem {
-  id: string;
-  data: {
-    content: string;
-  };
-  schema: PersonalizationSchema.JSON_CONTENT;
+export interface JSONPropositionData extends PropositionItemData {
+	data: {
+		content: any;
+	};
+	schema: PersonalizationSchema.JSON_CONTENT;
 }
+
+export class JSONPropositionItem extends PropositionItem {
+	declare data: JSONPropositionData['data'];
+
+	constructor(jsonData: JSONPropositionData) {
+		super(jsonData);
+		this.data = jsonData.data;
+	}
+}

package/src/models/Message.ts

@@ -10,9 +10,23 @@ OF ANY KIND, either express or implied. See the License for the specific languag
 governing permissions and limitations under the License.
 */
 
-import { NativeModules } from 'react-native';
+import { NativeEventEmitter, NativeModules, Platform } from 'react-native';
+
 const RCTAEPMessaging = NativeModules.AEPMessaging;
 
+// Registery to store inAppMessage callbacks for each message in Message.handleJavascriptMessage
+// Record - {messageId : {handlerName : callback}}
+const jsMessageHandlers: Record<string, Record<string, (content: string) => void>> = {};
+const handleJSMessageEventEmitter = new NativeEventEmitter(RCTAEPMessaging);
+
+// invokes the callback registered in Message.handleJavascriptMessage with the content received from the inAppMessage webview
+handleJSMessageEventEmitter.addListener('onJavascriptMessage', (event) => {
+  const {messageId, handlerName, content} = event;
+  if (jsMessageHandlers[messageId] && jsMessageHandlers[messageId][handlerName]) {
+    jsMessageHandlers[messageId][handlerName](content);
+  }
+});
+
 class Message {
   id: string;
   autoTrack: boolean;
@@ -47,7 +61,16 @@ class Message {
    * of the autoTrack setting.
    */
   dismiss(suppressAutoTrack?: boolean) {
-    RCTAEPMessaging.dismiss(this.id, suppressAutoTrack ? true : false);
+    // iOS message.dismiss() accepts a boolean parameter to suppress autoTrack
+    // but on android side, message.dismiss() does not accept any parameters
+    if (Platform.OS === 'android') {
+      RCTAEPMessaging.dismiss(this.id);
+    }
+
+    if (Platform.OS === 'ios') {
+      RCTAEPMessaging.dismiss(this.id, suppressAutoTrack ? true : false);
+    }
+    
   }
 
   /**
@@ -67,6 +90,42 @@ class Message {
   clear() {
     RCTAEPMessaging.clear(this.id);
   }
+
+  /**
+   * Adds a handler for named JavaScript messages sent from the message's WebView.
+   * The parameter passed to handler will contain the body of the message passed from the WebView's JavaScript.
+   * @param {string} handlerName: The name of the message that should be handled by the handler
+   * @param {function} handler: The method or closure to be called with the body of the message created in the Message's JavaScript
+   */
+  handleJavascriptMessage(handlerName: string, handler: (content: string) => void) {
+    // Validate parameters
+    if (!handlerName) {
+      console.warn('[AEP Messaging] handleJavascriptMessage: handlerName is required');
+      return;
+    }
+
+    if (typeof handler !== 'function') {
+      console.warn('[AEP Messaging] handleJavascriptMessage: handler must be a function');
+      return;
+    }
+
+    // cache the callback
+    if (!jsMessageHandlers[this.id]) {
+      jsMessageHandlers[this.id] = {};
+    }
+    jsMessageHandlers[this.id][handlerName] = handler;
+    RCTAEPMessaging.handleJavascriptMessage(this.id, handlerName);
+  }
+
+  /**
+   * @internal - For internal use only.
+   * Clears all the javascript message handlers for the message.
+   * This function must be called if the callbacks registered in handleJavascriptMessage are no longer needed.
+   * Failure to call this function may lead to memory leaks.
+   */
+  _clearJavascriptMessageHandlers() {
+    delete jsMessageHandlers[this.id];
+  }
 }
 
 export default Message;