react-native-grovs-wrapper/lib/module/index.js

Grovs react native SDK

"use strict";

// index.ts - Unified wrapper with backward compatibility
import { NativeModules, NativeEventEmitter } from 'react-native';
import { log } from "./Logger.js";
const LINKING_ERROR = `The package 'react-native-grovs-wrapper' doesn't seem to be linked. Make sure you properly integrated the native bindings.`;

// Feature detection for Turbo Modules
const isTurboModuleEnabled = global.RN$Bridgeless === true;
function hasOnDeeplinkReceived(obj) {
  return typeof obj === 'object' && obj !== null && 'onDeeplinkReceived' in obj && typeof obj.onDeeplinkReceived === 'function' && typeof obj.onDeeplinkReceived(() => {}).remove === 'function';
}
function hasAddDeeplinkListener(obj) {
  return typeof obj === 'object' && obj !== null && 'addDeeplinkListener' in obj && typeof obj.addDeeplinkListener === 'function';
}
let GrovsWrapperModule;
if (isTurboModuleEnabled) {
  try {
    // Try to import Turbo Module
    GrovsWrapperModule = require('./NativeGrovsWrapper').default;
    log('info', 'Turbo modules enabled - using Turbo modules');
  } catch (e) {
    log('info', 'Turbo modules enabled but not available - falling back to legacy bridge');
    GrovsWrapperModule = NativeModules.GrovsWrapper;
  }
} else {
  // Use legacy bridge
  GrovsWrapperModule = NativeModules.GrovsWrapper;
  log('info', 'Turbo modules disabled - falling back to legacy bridge');
}
if (!GrovsWrapperModule) {
  log('error', LINKING_ERROR);
  throw new Error(LINKING_ERROR);
}
class GrovsWrapper {
  listeners = new Set();
  constructor() {
    this.module = GrovsWrapperModule;
    if (hasAddDeeplinkListener(this.module)) {
      log('info', 'Has native addDeeplinkListener - registering addDeeplinkListener');
      this.module.addDeeplinkListener();
    }
    if (NativeModules.GrovsWrapper) {
      log('info', 'Has NativeModules.GrovsWrapper - registering adding event listener');
      const emitter = new NativeEventEmitter(NativeModules.GrovsWrapper);
      emitter.addListener('onGrovsDeeplinkReceived', data => {
        this.triggerDeeplink(data);
      });
    }
  }

  /**
   * Set user identifier
   * @param identifier - User identifier
   */
  setIdentifier(identifier) {
    this.module.setIdentifier(identifier);
  }

  /**
   * Set push token
   * @param pushToken - Push notification token
   */
  setPushToken(pushToken) {
    this.module.setPushToken(pushToken);
  }

  /**
   * Set user attributes
   * @param attributes - User attributes
   */
  setAttributes(attributes) {
    this.module.setAttributes(attributes);
  }

  /**
   * Enable/disable SDK
   * @param enabled - SDK enabled state
   */
  setSDK(enabled) {
    this.module.setSDK(enabled);
  }

  /**
   * Set debug level
   * @param level - Debug level
   */
  setDebug(level) {
    this.module.setDebug(level);
  }

  /**
   * Generate a deep link
   * @param title - Link title
   * @param subtitle - Link subtitle
   * @param imageURL - Image URL
   * @param data - Additional data
   * @param tags - Tags array
   * @param customRedirects - Custom redirects configuration
   * @param showPreview - Show preview flag
   * @returns Generated link
   */
  async generateLink(title, subtitle, imageURL, data, tags, customRedirects, showPreviewIos, showPreviewAndroid) {
    try {
      const link = await this.module.generateLink(title, subtitle, imageURL, data, tags, customRedirects, showPreviewIos, showPreviewAndroid);
      return link;
    } catch (error) {
      throw new Error(`Failed to generate link: ${error.message}`);
    }
  }

  /**
   * Display messages
   */
  async displayMessages() {
    try {
      await this.module.displayMessages();
    } catch (error) {
      throw new Error(`Failed to display messages: ${error.message}`);
    }
  }

  /**
   * Get number of unread messages
   * @returns Number of unread messages
   */
  async numberOfUnreadMessages() {
    try {
      const count = await this.module.numberOfUnreadMessages();
      return count;
    } catch (error) {
      throw new Error(`Failed to get unread messages count: ${error.message}`);
    }
  }

  /**
   * Event emitter for deeplink received events
   * @returns Event emitter with addListener and removeAllListeners methods
   */
  onDeeplinkReceived(callback) {
    log('info', 'Registering deeplink received');
    if (hasOnDeeplinkReceived(this.module)) {
      log('info', 'Using turbo module - using onDeeplinkReceived');
      const sub = this.module.onDeeplinkReceived(callback);
      return {
        remove: () => sub.remove()
      };
    }
    log('info', 'Bridge mode - registering callback');
    this.listeners.add(callback);
    this.markReadyToHandleDeeplinks();
    return {
      remove: () => {
        this.listeners.delete(callback);
      }
    };
  }
  markReadyToHandleDeeplinks() {
    this.module.markReadyToHandleDeeplinks();
  }

  // Trigger all listeners when a deeplink is received
  triggerDeeplink(data) {
    for (const cb of this.listeners) {
      cb(data);
    }
  }
}

// Export singleton instance
export default new GrovsWrapper();

// Also export class for advanced usage
export { GrovsWrapper };

// Export types for TypeScript users
//# sourceMappingURL=index.js.map