@bubblsdk/react-native-sdk 3.0.0

package/ios/BubblSdkBridge.m

@@ -0,0 +1,83 @@
+#import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>
+
+@interface RCT_EXTERN_MODULE(BubblSdk, RCTEventEmitter)
+
+RCT_EXTERN_METHOD(boot:(NSDictionary *)config
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(shutdown:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(startLocationTracking:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(stopLocationTracking:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(refresh:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(refreshGeofence:(double)latitude
+                  longitude:(double)longitude
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(handleLocationUpdate:(double)latitude
+                  longitude:(double)longitude
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(refreshPush:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(getConfiguration:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(getPrivacyText:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(updateSegments:(NSArray *)tags
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(setCorrelationId:(NSString *)value
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(clearCorrelationId:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(setDefaultNotificationModalEnabled:(BOOL)enabled
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(registerPushToken:(NSString *)token
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(handleFirebasePayload:(NSDictionary *)payload
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(showNotification:(NSDictionary *)payload
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(handleNotificationPayload:(NSDictionary *)payload
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(handleNotificationOpen:(NSDictionary *)payload
+                  action:(NSString *)action
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(openNotificationModal:(NSDictionary *)payload
+                  action:(NSString *)action
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(handleNotificationCta:(NSDictionary *)payload
+                  action:(NSString *)action
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(handleNotificationMediaViewed:(NSDictionary *)payload
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(handleNotificationSurveyRequested:(NSDictionary *)payload
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(track:(NSDictionary *)event
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(submitSurveyResponse:(NSDictionary *)response
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(flush:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(diagnostics:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+@end

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@bubblsdk/react-native-sdk",
+  "version": "3.0.0",
+  "description": "React Native wrapper for Bubbl SDK v3 native Android and iOS cores.",
+  "main": "src/index.ts",
+  "module": "src/index.ts",
+  "types": "src/index.ts",
+  "react-native": "src/index.ts",
+  "source": "src/index.ts",
+  "repository": {
+    "type": "git",
+    "url": "git+https://devops.bubbl.tech/bubbl/renewed-sdk.git",
+    "directory": "react-native"
+  },
+  "license": "SEE LICENSE IN LICENSE",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "node ../scripts/validate-wrapper-surfaces.mjs --react-native",
+    "test": "node ../scripts/validate-wrapper-surfaces.mjs --react-native",
+    "typecheck": "node ../scripts/validate-wrapper-surfaces.mjs --react-native"
+  },
+  "files": [
+    "android/build.gradle",
+    "android/src",
+    "ios/BubblSdk.swift",
+    "ios/BubblSdkBridge.m",
+    "src",
+    "BubblReactNativeSdk.podspec",
+    "react-native.config.js",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE"
+  ],
+  "peerDependencies": {
+    "react": "*",
+    "react-native": ">=0.76"
+  },
+  "codegenConfig": {
+    "name": "BubblSdkSpec",
+    "type": "modules",
+    "jsSrcsDir": "src/specs",
+    "android": {
+      "javaPackageName": "tech.bubbl.reactnative"
+    }
+  }
+}

package/react-native.config.js

@@ -0,0 +1,11 @@
+module.exports = {
+  dependency: {
+    platforms: {
+      android: {
+        sourceDir: './android',
+        packageImportPath: 'import tech.bubbl.reactnative.BubblSdkPackage;',
+        packageInstance: 'new BubblSdkPackage()',
+      },
+    },
+  },
+};

package/src/index.ts

@@ -0,0 +1,292 @@
+import {
+  NativeEventEmitter,
+  NativeModules,
+  type EmitterSubscription,
+} from 'react-native';
+import NativeBubblSdk from './specs/NativeBubblSdk';
+
+export type BubblEnvironment = 'development' | 'nightly' | 'staging' | 'production';
+export type BubblLogLevel = 'off' | 'error' | 'warn' | 'info' | 'debug';
+export type BubblNotificationRenderingMode = 'sdkDefault' | 'hostRendered' | 'eventOnly';
+export type BubblNotificationSource = 'firebase' | 'apns' | 'runtime' | 'geofence' | 'manual';
+
+export type BubblConfig = {
+  apiKey: string;
+  environment?: BubblEnvironment;
+  runtimeBaseUrl?: string | null;
+  transmissionBaseUrl?: string | null;
+  ingestBaseUrl?: string | null;
+  segments?: string[];
+  correlationId?: string | null;
+  defaultDistanceMeters?: number;
+  refreshIntervalSeconds?: number;
+  enablePushHandling?: boolean;
+  enableLocationTracking?: boolean;
+  notificationRenderingMode?: BubblNotificationRenderingMode;
+  enableDefaultNotificationModal?: boolean;
+  enableDefaultSurveyUi?: boolean;
+  logLevel?: BubblLogLevel;
+};
+
+export type BubblBootResult = {
+  ready: boolean;
+  fromCache: boolean;
+  deviceRegistered: boolean;
+  requiresPermission: string[];
+  warnings: string[];
+};
+
+export type BubblLocation = {
+  latitude: number;
+  longitude: number;
+};
+
+export type BubblGeofenceTransitionType = 'enter' | 'exit';
+
+export type BubblGeofenceTransition = {
+  type: BubblGeofenceTransitionType;
+  campaignId?: string | null;
+  locationId?: string | null;
+  location: BubblLocation;
+};
+
+export type BubblGeofenceVertex = BubblLocation;
+
+export type BubblGeofencePolygon = {
+  campaignId?: string | null;
+  campaignName?: string | null;
+  locationId?: string | null;
+  vertices: BubblGeofenceVertex[];
+};
+
+export type BubblGeofenceCircle = {
+  campaignId?: string | null;
+  campaignName?: string | null;
+  locationId?: string | null;
+  center: BubblGeofenceVertex;
+  radius: number;
+};
+
+export type BubblGeofenceSnapshot = {
+  stats: {
+    campaignsTotal: number;
+    polygonsTotal: number;
+  };
+  polygons: BubblGeofencePolygon[];
+  circles: BubblGeofenceCircle[];
+};
+
+export type BubblTrackEvent = {
+  type: string;
+  activity: string;
+  locationId?: string | null;
+  curatedNotificationId?: string | null;
+  latitude?: number | null;
+  longitude?: number | null;
+};
+
+export type BubblSurveyAnswer = {
+  questionId: string;
+  type: string;
+  value?: string | null;
+  choiceIds?: string[];
+};
+
+export type BubblSurveyResponse = {
+  curatedNotificationId: string;
+  locationId?: string | null;
+  answers: BubblSurveyAnswer[];
+};
+
+export type BubblNotificationPayload = {
+  id: string;
+  title: string;
+  body: string;
+  source?: BubblNotificationSource;
+  locationId?: string | null;
+  curatedNotificationId?: string | null;
+  correlationId?: string | null;
+  media?: BubblNotificationMedia | null;
+  cta?: BubblNotificationCta | null;
+  survey?: BubblNotificationSurvey | null;
+  raw?: Record<string, string>;
+};
+
+export type BubblNotificationMedia = {
+  url: string;
+  type?: string | null;
+  altText?: string | null;
+};
+
+export type BubblNotificationCta = {
+  label: string;
+  url?: string | null;
+  action?: string | null;
+};
+
+export type BubblNotificationSurvey = {
+  questions?: BubblSurveyQuestion[];
+};
+
+export type BubblSurveyQuestion = {
+  id: string;
+  title: string;
+  type: string;
+  choices?: BubblSurveyChoice[];
+};
+
+export type BubblSurveyChoice = {
+  id: string;
+  label: string;
+};
+
+export type BubblNotificationDisplayResult = {
+  displayed: boolean;
+  reason?: string | null;
+};
+
+export type BubblDiagnostics = {
+  sdkVersion: string;
+  platform: 'react-native';
+  booted: boolean;
+  pendingIngestCount: number;
+  pushTokenSuffix?: string | null;
+};
+
+export type BubblEvent =
+  | { type: 'ready' }
+  | { type: 'diagnostic'; diagnostics: BubblDiagnostics }
+  | { type: 'notificationReceived'; payload: BubblNotificationPayload }
+  | { type: 'notificationDisplayed'; payload: BubblNotificationPayload }
+  | { type: 'notificationTapped'; payload: BubblNotificationPayload; action?: string | null }
+  | { type: 'notificationCtaTapped'; payload: BubblNotificationPayload; action?: string | null }
+  | { type: 'notificationMediaViewed'; payload: BubblNotificationPayload }
+  | { type: 'notificationSurveyRequested'; payload: BubblNotificationPayload }
+  | { type: 'locationUpdated'; location: BubblLocation }
+  | { type: 'geofenceSnapshot'; snapshot: BubblGeofenceSnapshot }
+  | { type: 'geofenceEntered'; transition: BubblGeofenceTransition }
+  | { type: 'geofenceExited'; transition: BubblGeofenceTransition }
+  | { type: 'error'; code: string; message: string };
+
+export type BubblEventSubscription = Pick<EmitterSubscription, 'remove'>;
+
+const EVENT_NAME = 'BubblSdkEvent';
+
+type NativeBubblSdkShape = NonNullable<typeof NativeBubblSdk>;
+
+function nativeModule(): NativeBubblSdkShape {
+  const module = NativeBubblSdk ?? NativeModules.BubblSdk;
+  if (!module) {
+    throw new Error('BubblSdk native module is not linked.');
+  }
+
+  return module as NativeBubblSdkShape;
+}
+
+function eventEmitter(): NativeEventEmitter {
+  return new NativeEventEmitter(NativeModules.BubblSdk ?? (NativeBubblSdk as object | null));
+}
+
+function validateApiKey(config: BubblConfig): void {
+  if (!config.apiKey?.trim()) {
+    throw new Error('apiKey is required');
+  }
+}
+
+export const Bubbl = {
+  async boot(config: BubblConfig): Promise<BubblBootResult> {
+    validateApiKey(config);
+    return nativeModule().boot(config) as Promise<BubblBootResult>;
+  },
+  async shutdown(): Promise<void> {
+    return nativeModule().shutdown();
+  },
+  async startLocationTracking(): Promise<void> {
+    return nativeModule().startLocationTracking();
+  },
+  async stopLocationTracking(): Promise<void> {
+    return nativeModule().stopLocationTracking();
+  },
+  async refresh(): Promise<void> {
+    return nativeModule().refresh();
+  },
+  async refreshGeofence(location: BubblLocation): Promise<void> {
+    return nativeModule().refreshGeofence(location.latitude, location.longitude);
+  },
+  async handleLocationUpdate(location: BubblLocation): Promise<void> {
+    return nativeModule().handleLocationUpdate(location.latitude, location.longitude);
+  },
+  async refreshPush(): Promise<void> {
+    return nativeModule().refreshPush();
+  },
+  async getConfiguration(): Promise<Record<string, unknown> | null> {
+    return nativeModule().getConfiguration() as Promise<Record<string, unknown> | null>;
+  },
+  async getPrivacyText(): Promise<string> {
+    return nativeModule().getPrivacyText();
+  },
+  async updateSegments(tags: string[]): Promise<void> {
+    return nativeModule().updateSegments(tags);
+  },
+  async setCorrelationId(value: string): Promise<void> {
+    return nativeModule().setCorrelationId(value);
+  },
+  async clearCorrelationId(): Promise<void> {
+    return nativeModule().clearCorrelationId();
+  },
+  async setDefaultNotificationModalEnabled(enabled: boolean): Promise<void> {
+    return nativeModule().setDefaultNotificationModalEnabled(enabled);
+  },
+  async disableDefaultNotificationModal(): Promise<void> {
+    return nativeModule().setDefaultNotificationModalEnabled(false);
+  },
+  async enableDefaultNotificationModal(): Promise<void> {
+    return nativeModule().setDefaultNotificationModalEnabled(true);
+  },
+  async registerPushToken(token: string): Promise<void> {
+    return nativeModule().registerPushToken(token);
+  },
+  async handleFirebasePayload(payload: Record<string, string>): Promise<BubblNotificationPayload | null> {
+    return nativeModule().handleFirebasePayload(payload) as Promise<BubblNotificationPayload | null>;
+  },
+  async showNotification(payload: BubblNotificationPayload): Promise<BubblNotificationDisplayResult> {
+    return nativeModule().showNotification(payload) as Promise<BubblNotificationDisplayResult>;
+  },
+  async handleNotificationPayload(payload: BubblNotificationPayload): Promise<BubblNotificationDisplayResult> {
+    return nativeModule().handleNotificationPayload(payload) as Promise<BubblNotificationDisplayResult>;
+  },
+  async handleNotificationOpen(payload: BubblNotificationPayload, action?: string | null): Promise<void> {
+    return nativeModule().handleNotificationOpen(payload, action);
+  },
+  async openNotificationModal(payload: BubblNotificationPayload, action?: string | null): Promise<boolean> {
+    return nativeModule().openNotificationModal(payload, action);
+  },
+  async handleNotificationCta(payload: BubblNotificationPayload, action?: string | null): Promise<void> {
+    return nativeModule().handleNotificationCta(payload, action);
+  },
+  async handleNotificationMediaViewed(payload: BubblNotificationPayload): Promise<void> {
+    return nativeModule().handleNotificationMediaViewed(payload);
+  },
+  async handleNotificationSurveyRequested(payload: BubblNotificationPayload): Promise<void> {
+    return nativeModule().handleNotificationSurveyRequested(payload);
+  },
+  async track(event: BubblTrackEvent): Promise<void> {
+    return nativeModule().track(event);
+  },
+  async submitSurveyResponse(response: BubblSurveyResponse): Promise<void> {
+    return nativeModule().submitSurveyResponse(response);
+  },
+  async flush(): Promise<{ pendingCount: number }> {
+    return nativeModule().flush() as Promise<{ pendingCount: number }>;
+  },
+  async diagnostics(): Promise<BubblDiagnostics> {
+    return nativeModule().diagnostics() as Promise<BubblDiagnostics>;
+  },
+  events: {
+    addListener(listener: (event: BubblEvent) => void): BubblEventSubscription {
+      return eventEmitter().addListener(EVENT_NAME, listener);
+    },
+  },
+};
+
+export default Bubbl;

package/src/specs/NativeBubblSdk.ts

@@ -0,0 +1,52 @@
+import type { TurboModule } from 'react-native';
+import { TurboModuleRegistry } from 'react-native';
+
+export type BubblBootOptions = {
+  apiKey: string;
+  environment?: string;
+  runtimeBaseUrl?: string | null;
+  transmissionBaseUrl?: string | null;
+  ingestBaseUrl?: string | null;
+  segments?: string[];
+  correlationId?: string | null;
+  defaultDistanceMeters?: number;
+  refreshIntervalSeconds?: number;
+  enablePushHandling?: boolean;
+  enableLocationTracking?: boolean;
+  notificationRenderingMode?: string;
+  enableDefaultNotificationModal?: boolean;
+  enableDefaultSurveyUi?: boolean;
+  logLevel?: string;
+};
+
+export interface Spec extends TurboModule {
+  boot(config: BubblBootOptions): Promise<Object>;
+  shutdown(): Promise<void>;
+  startLocationTracking(): Promise<void>;
+  stopLocationTracking(): Promise<void>;
+  refresh(): Promise<void>;
+  refreshGeofence(latitude: number, longitude: number): Promise<void>;
+  handleLocationUpdate(latitude: number, longitude: number): Promise<void>;
+  refreshPush(): Promise<void>;
+  getConfiguration(): Promise<Object | null>;
+  getPrivacyText(): Promise<string>;
+  updateSegments(tags: string[]): Promise<void>;
+  setCorrelationId(value: string): Promise<void>;
+  clearCorrelationId(): Promise<void>;
+  setDefaultNotificationModalEnabled(enabled: boolean): Promise<void>;
+  registerPushToken(token: string): Promise<void>;
+  handleFirebasePayload(payload: Object): Promise<Object | null>;
+  showNotification(payload: Object): Promise<Object>;
+  handleNotificationPayload(payload: Object): Promise<Object>;
+  handleNotificationOpen(payload: Object, action?: string | null): Promise<void>;
+  openNotificationModal(payload: Object, action?: string | null): Promise<boolean>;
+  handleNotificationCta(payload: Object, action?: string | null): Promise<void>;
+  handleNotificationMediaViewed(payload: Object): Promise<void>;
+  handleNotificationSurveyRequested(payload: Object): Promise<void>;
+  track(event: Object): Promise<void>;
+  submitSurveyResponse(response: Object): Promise<void>;
+  flush(): Promise<Object>;
+  diagnostics(): Promise<Object>;
+}
+
+export default TurboModuleRegistry.get<Spec>('BubblSdk');