smartech-reactnative-nudges/lib/module/index.js

This package contains bridges to integrate SmartechNudges native sdk in React Native App.

import { DeviceEventEmitter, NativeEventEmitter, Platform } from 'react-native';
import SmartechNudges from './specs/NativeSmartechNudges';

// TurboModule is working correctly for new architecture

// Try to use TurboModule first (new arch), fallback to legacy modules (old arch)
// React Native automatically chooses newarch/oldarch modules based on architecture
const HanselRnNative = SmartechNudges;
const HanselUserRnNative = SmartechNudges;
const HanselConfigsRnNative = SmartechNudges;
const HanselTrackerRnNative = SmartechNudges;
const HanselLogsRnNative = SmartechNudges;

// Create event emitter for cross-platform events
const HanselEventEmitter = Platform.select({
  ios: new NativeEventEmitter(SmartechNudges),
  android: DeviceEventEmitter
});

// Store event subscriptions for cleanup
const eventMap = {};

// ===== HanselRn Module =====
export const HanselRn = {
  getInteractionMaps: function (callback) {
    HanselRnNative.getInteractionMaps(callback);
  },
  onBackButtonPressed: function () {
    return HanselRnNative.onBackButtonPressed();
  },
  onSetScreen: function (screenName) {
    HanselRnNative.onSetScreen(screenName);
  },
  onUnsetScreen: function () {
    HanselRnNative.onUnsetScreen();
  },
  showToast: function (text, longDuration) {
    HanselRnNative.showToast(text, longDuration);
  },
  setTypeface: function (fontFileName) {
    HanselRnNative.setTypeface(fontFileName);
  },
  setAppFont: function (fontName) {
    HanselRnNative.setAppFont(fontName);
  },
  setNativeID: function () {
    HanselRnNative.setNativeID();
  }
};

// ===== HanselUser Module =====
export const HanselUserRn = {
  putStringAttribute: function (key, value) {
    HanselUserRnNative.putStringAttribute(key, value);
  },
  putDoubleAttribute: function (key, value) {
    HanselUserRnNative.putDoubleAttribute(key, value);
  },
  putBooleanAttribute: function (key, value) {
    HanselUserRnNative.putBooleanAttribute(key, value);
  },
  putPrivateStringAttribute: function (key, value) {
    HanselUserRnNative.putPrivateStringAttribute(key, value);
  },
  putPrivateDoubleAttribute: function (key, value) {
    HanselUserRnNative.putPrivateDoubleAttribute(key, value);
  },
  putPrivateBooleanAttribute: function (key, value) {
    HanselUserRnNative.putPrivateBooleanAttribute(key, value);
  },
  setUserId: function (userId) {
    HanselUserRnNative.setUserId(userId);
  },
  clearAttribute: function (key) {
    HanselUserRnNative.clearAttribute(key);
  },
  clear: function () {
    HanselUserRnNative.clear();
  }
};

// ===== HanselConfigs Module =====
export const HanselConfigsRn = {
  getString: function (configName, fallbackValue, callback) {
    HanselConfigsRnNative.getString(configName, fallbackValue, callback);
  },
  getBoolean: function (configName, fallbackValue, callback) {
    HanselConfigsRnNative.getBoolean(configName, fallbackValue, callback);
  },
  getDouble: function (configName, fallbackValue, callback) {
    HanselConfigsRnNative.getDouble(configName, fallbackValue, callback);
  },
  getList: function (configName, defaultValue, callback) {
    HanselConfigsRnNative.getList(configName, defaultValue, callback);
  },
  getJSONArray: function (configName, defaultValue, callback) {
    HanselConfigsRnNative.getJSONArray(configName, defaultValue, callback);
  },
  getJSONObject: function (configName, defaultValue, callback) {
    HanselConfigsRnNative.getJSONObject(configName, defaultValue, callback);
  }
};

// ===== HanselTracker Module =====
export const HanselTrackerRn = {
  logEvent: function (eventName, vendor, hanselProperties, callback) {
    HanselTrackerRnNative.logEvent(eventName, vendor, hanselProperties, callback);
  },
  getHanselData: function (eventName, vendor, properties, callback) {
    HanselTrackerRnNative.getHanselData(eventName, vendor, properties, callback);
  },
  isUsedInMap: function (event, vendor, properties, callback) {
    HanselTrackerRnNative.isUsedInMap(event, vendor, properties, callback);
  },
  registerHanselTrackerListener: function () {
    HanselTrackerRnNative.registerHanselTrackerListener();
  },
  registerHanselActionListenerWithActionName: function (actionName) {
    HanselTrackerRnNative.registerHanselActionListenerWithActionName(actionName);
  },
  registerHanselDeeplinkListener: function () {
    HanselTrackerRnNative.registerHanselDeeplinkListener();
  },
  deRegisterListener: function () {
    HanselTrackerRnNative.deRegisterListener();
  },
  removeHanselActionListenerForAction: function (actionName) {
    HanselTrackerRnNative.removeHanselActionListenerForAction(actionName);
  },
  // Event listener methods
  addListener: function (eventName, handler) {
    if (HanselEventEmitter) {
      const subscription = HanselEventEmitter.addListener(eventName, handler);
      eventMap[eventName] = subscription;
      return subscription;
    }
    return undefined;
  },
  removeListener: function (eventName) {
    if (eventMap[eventName]) {
      eventMap[eventName].remove();
      delete eventMap[eventName];
    }
  }
};

// ===== HanselLogs Module =====
export const HanselLogs = {
  e: function (tag, message) {
    HanselLogsRnNative.e(tag, message);
  }
};

// Export everything as default for backwards compatibility
const SmartechNudgesReact = {
  HanselRn,
  HanselUserRn,
  HanselConfigsRn,
  HanselTrackerRn,
  HanselLogs
};
export default SmartechNudgesReact;
//# sourceMappingURL=index.js.map