@amplytools/react-native-amply-sdk 0.1.0

package/src/index.ts

@@ -0,0 +1,115 @@
+import getNativeModule from './nativeModule';
+import {addSystemEventListener as addSystemEventListenerInternal} from './systemEvents';
+export {useAmplySystemEvents} from './hooks/useAmplySystemEvents';
+export {formatSystemEventLabel} from './systemEventUtils';
+import type {
+  AmplyInitializationConfig,
+  DataSetSnapshot,
+  DataSetType,
+  DeepLinkEvent,
+  EventRecord,
+  TrackEventPayload,
+} from './nativeSpecs/NativeAmplyModule';
+
+let deepLinkRegistered = false;
+const deepLinkSubscriptions = new Set<() => void>();
+
+async function ensureDeepLinkRegistration(): Promise<void> {
+  if (!deepLinkRegistered) {
+    console.log('[Amply] Calling registerDeepLinkListener on native module');
+    getNativeModule().registerDeepLinkListener();
+    deepLinkRegistered = true;
+    console.log('[Amply] registerDeepLinkListener completed');
+  }
+}
+
+function trackDeepLinkSubscription(subscription?: {remove?: () => void}): () => void {
+  let removed = false;
+  const unsubscribe = () => {
+    if (removed) {
+      return;
+    }
+    removed = true;
+    subscription?.remove?.();
+    deepLinkSubscriptions.delete(unsubscribe);
+  };
+  deepLinkSubscriptions.add(unsubscribe);
+  return unsubscribe;
+}
+
+export async function initialize(config: AmplyInitializationConfig): Promise<void> {
+  await getNativeModule().initialize(config);
+}
+
+export function isInitialized(): boolean {
+  return getNativeModule().isInitialized();
+}
+
+export async function track(payload: TrackEventPayload): Promise<void> {
+  await getNativeModule().track(payload);
+}
+
+export async function getRecentEvents(limit: number): Promise<EventRecord[]> {
+  return getNativeModule().getRecentEvents(limit);
+}
+
+export async function getDataSetSnapshot(type: DataSetType): Promise<DataSetSnapshot> {
+  return getNativeModule().getDataSetSnapshot(type);
+}
+
+export async function addDeepLinkListener(
+  listener: (event: DeepLinkEvent) => void
+): Promise<() => void> {
+  await ensureDeepLinkRegistration();
+  const subscription = getNativeModule().onDeepLink(listener);
+  return trackDeepLinkSubscription(subscription);
+}
+
+export async function addSystemEventListener(
+  listener: (event: EventRecord) => void
+): Promise<() => void> {
+  return addSystemEventListenerInternal(listener);
+}
+
+export function removeAllListeners(): void {
+  deepLinkSubscriptions.forEach(unsubscribe => {
+    try {
+      unsubscribe();
+    } catch (error) {
+      console.warn('[Amply] Failed to remove deep link listener', error);
+    }
+  });
+  deepLinkSubscriptions.clear();
+}
+
+export type {
+  AmplyInitializationConfig,
+  DataSetSnapshot,
+  DataSetType,
+  DeepLinkEvent,
+  EventRecord,
+  TrackEventPayload,
+};
+
+export function addSystemEventsListener(
+  listener: (event: EventRecord) => void,
+): Promise<() => void> {
+  return addSystemEventListener(listener);
+}
+
+export const systemEvents = {
+  addListener: addSystemEventsListener,
+};
+
+export default {
+  initialize,
+  isInitialized,
+  track,
+  getRecentEvents,
+  getDataSetSnapshot,
+  addDeepLinkListener,
+  addSystemEventListener,
+  addSystemEventsListener,
+  removeAllListeners,
+  systemEvents,
+};

package/src/nativeModule.ts

@@ -0,0 +1,65 @@
+import {NativeModules, TurboModuleRegistry} from 'react-native';
+import type {Spec} from './nativeSpecs/NativeAmplyModule';
+
+const MODULE_NAME = 'Amply';
+
+let cachedModule: Spec | null = null;
+let attemptedTurboLookup = false;
+let resolvedTurboModule: Spec | null = null;
+
+function loadModule(): Spec | null {
+  const globalWithTurbo = globalThis as typeof globalThis & {
+    __turboModuleProxy?: unknown;
+  };
+
+  if (globalWithTurbo.__turboModuleProxy != null) {
+    if (!attemptedTurboLookup) {
+      attemptedTurboLookup = true;
+      try {
+        resolvedTurboModule = TurboModuleRegistry.getEnforcing<Spec>(MODULE_NAME);
+      } catch (error) {
+        resolvedTurboModule = null;
+        if (__DEV__) {
+          console.warn(
+            "[Amply] TurboModule lookup failed; falling back to legacy NativeModules. " +
+              (error instanceof Error ? error.message : String(error))
+          );
+        }
+      }
+    }
+    if (resolvedTurboModule) {
+      return resolvedTurboModule;
+    }
+  }
+
+  const legacyModule = NativeModules[MODULE_NAME] as Spec | undefined;
+  if (legacyModule) {
+    return legacyModule;
+  }
+
+  return null;
+}
+
+export function getNativeModule(): Spec {
+  if (cachedModule) {
+    return cachedModule;
+  }
+
+  const module = loadModule();
+  if (!module) {
+    throw new Error(
+      `Amply native module '${MODULE_NAME}' not found. ` +
+        'Ensure the module is properly linked and new architecture is enabled.'
+    );
+  }
+
+  cachedModule = module;
+  return cachedModule;
+}
+
+// Testing hook to override the resolved native module.
+export function __setNativeModule(mock: Spec | null): void {
+  cachedModule = mock;
+}
+
+export default getNativeModule;

package/src/nativeSpecs/NativeAmplyModule.ts

@@ -0,0 +1,80 @@
+import type {TurboModule} from 'react-native';
+import {TurboModuleRegistry} from 'react-native';
+import type {EventEmitter} from 'react-native/Libraries/Types/CodegenTypes';
+
+type JsonMap = {[key: string]: unknown};
+
+export type AmplyInitializationConfig = {
+  appId: string;
+  apiKeyPublic: string;
+  apiKeySecret?: string | null;
+  endpoint?: string | null;
+  datasetPrefetch?: DataSetType[] | null;
+  defaultConfig?: string | null;
+};
+
+export type EventType = 'custom' | 'system';
+
+export type TrackEventPayload = {
+  name: string;
+  properties?: JsonMap | null;
+};
+
+export type EventRecord = {
+  id?: string | null;
+  name: string;
+  type: EventType;
+  timestamp: number;
+  properties: JsonMap;
+};
+
+export type SystemEventPayload = EventRecord;
+
+export type TriggeredEventCountStrategy = 'total' | 'session' | 'user';
+
+export type TriggeredEventParam = {
+  name: string;
+  value: unknown;
+};
+
+export type TriggeredEventData = {
+  countStrategy: TriggeredEventCountStrategy;
+  params: TriggeredEventParam[];
+  eventName?: string | null;
+};
+
+export type EventsDataSetEvent = {
+  name: string;
+  type: EventType;
+  params: TriggeredEventParam[];
+};
+
+export type DataSetType =
+  | {kind: '@device'}
+  | {kind: '@user'}
+  | {kind: '@session'}
+  | {kind: '@triggeredEvent'; data: TriggeredEventData}
+  | {kind: '@events'; data: EventsDataSetEvent[]};
+
+export type DataSetSnapshot = JsonMap;
+
+export type DeepLinkEvent = {
+  url: string;
+  info: JsonMap;
+  consumed: boolean;
+};
+
+export interface Spec extends TurboModule {
+  initialize(config: AmplyInitializationConfig): Promise<void>;
+  isInitialized(): boolean;
+  track(payload: TrackEventPayload): Promise<void>;
+  getRecentEvents(limit: number): Promise<EventRecord[]>;
+  getDataSetSnapshot(type: DataSetType): Promise<DataSetSnapshot>;
+  registerDeepLinkListener(): void;
+  readonly onSystemEvent: EventEmitter<SystemEventPayload>;
+  readonly onDeepLink: EventEmitter<DeepLinkEvent>;
+  addListener(eventName: string): void;
+  removeListeners(count: number): void;
+}
+
+export default TurboModuleRegistry.getEnforcing<Spec>('Amply');

package/src/systemEventUtils.ts

@@ -0,0 +1,35 @@
+import type {EventRecord} from './nativeSpecs/NativeAmplyModule';
+
+const DEFAULT_LABELS: Record<string, string> = {
+  SdkInitialized: 'SDK initialized',
+  ConfigFetchStarted: 'Config fetch started',
+  ConfigFetchFinished: 'Config fetch finished',
+  SessionStarted: 'Session started',
+  SessionFinished: 'Session finished',
+  CampaignShown: 'Campaign shown',
+  EventTriggered: 'Event triggered',
+  CampaignStarted: 'Campaign processing started',
+  CampaignFinished: 'Campaign finished',
+};
+
+export function formatSystemEventLabel(event: EventRecord): string {
+  if (event.name === 'CampaignShown') {
+    const campaignId = event.properties.campaignId as string | undefined;
+    const source = event.properties.source as string | undefined;
+    return `Campaign shown${campaignId ? ` (${campaignId})` : ''}${
+      source ? ` via ${source}` : ''
+    }`;
+  }
+  if (event.name === 'EventTriggered') {
+    const source = event.properties.sourceEvent as string | undefined;
+    return source ? `Event triggered (${source})` : DEFAULT_LABELS[event.name] ?? event.name;
+  }
+  if (event.name === 'ConfigFetchFinished') {
+    const success = event.properties.success as boolean | undefined;
+    const campaignCount = event.properties.campaignCount as number | undefined;
+    const countLabel =
+      typeof campaignCount === 'number' ? ` (${campaignCount} campaigns)` : '';
+    return success === false ? 'Config fetch failed' : `Config fetch finished${countLabel}`;
+  }
+  return DEFAULT_LABELS[event.name] ?? `System event ${event.name}`;
+}

package/src/systemEvents.ts

@@ -0,0 +1,13 @@
+import getNativeModule from './nativeModule';
+import type {SystemEventPayload} from './nativeSpecs/NativeAmplyModule';
+
+export async function addSystemEventListener(
+  listener: (event: SystemEventPayload) => void,
+): Promise<() => void> {
+  const subscription = getNativeModule().onSystemEvent(listener);
+  return () => subscription?.remove?.();
+}
+
+export const systemEvents = {
+  addListener: addSystemEventListener,
+};