React Native SDK (demo)

1                         Consent Backend
2                               |
3                +--------------+--------------+
4                |                             |
5        Android Native SDK             iOS Native SDK
6     (consent logic, storage,      (consent logic, storage,
7      consent UI, networking)       consent UI, networking)
8                |                             |
9        +-------+-------+             +-------+-------+
10        |               |             |               |
11     Flutter      React Native     Flutter      React Native
12     plugin       native module    plugin       native module
13    (Kotlin)        (Kotlin)       (Swift)        (Swift)
14        |               |             |               |
15        +-------+-------+-------------+-------+-------+
16                |                             |
17          Dart API (Flutter)        TypeScript API (React Native)
18                |                             |
19                +--------- Host application --+

1# DEMO / FICTIONAL package — not published on npm
2npm install @digitalanumati/react-native-consent
3 
4# iOS: install the native pods (pulls in DigitalAnumatiConsent)
5cd ios && pod install && cd ..

1// android/build.gradle (library) — pulls in the native SDK
2dependencies {
3    implementation "com.facebook.react:react-android"
4    implementation "com.digitalanumati:consent-sdk:1.0.0" // DEMO / FICTIONAL
5    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.9.0"
6}

1# react-native-digital-anumati-consent.podspec
2Pod::Spec.new do |s|
3  s.name          = 'react-native-digital-anumati-consent'
4  s.version       = '1.0.0'
5  s.summary       = 'DEMO / FICTIONAL React Native bridge for the Digital Anumati consent SDK.'
6  s.homepage      = 'https://github.com/example/react-native-digital-anumati-consent'
7  s.license       = 'MIT'
8  s.authors       = 'Demo'
9  s.platforms     = { :ios => '15.0' }
10  s.source        = { :git => 'https://github.com/example/react-native-digital-anumati-consent.git', :tag => s.version.to_s }
11  s.source_files  = 'ios/**/*.{h,m,swift}'
12  s.swift_version = '5.9'
13  s.dependency 'React-Core'
14  s.dependency 'DigitalAnumatiConsent', '~> 1.0' # DEMO / FICTIONAL
15end

1import { DigitalAnumatiConsent, type ConsentError } from '@digitalanumati/react-native-consent';
2 
3// 1. Initialize once, at app start.
4await DigitalAnumatiConsent.initialize({
5  siteKey: 'demo-site-key-123',
6  applicationId: 'demo-mobile-app-123',
7  environment: 'uat',
8});
9 
10// 2. Listen to SDK events.
11const subscription = DigitalAnumatiConsent.addListener((event) => {
12  console.log('Consent event', event.type);
13});
14 
15// 3. Ask for consent if the user hasn't decided yet.
16const status = await DigitalAnumatiConsent.getConsentStatus();
17if (status === 'NOT_DETERMINED') {
18  try {
19    const result = await DigitalAnumatiConsent.showConsent();
20    console.log('Consent status', result.status);
21  } catch (e) {
22    if ((e as ConsentError).code !== 'USER_CANCELLED') throw e;
23  }
24}
25 
26// 4. Read or change preferences, or revoke.
27const preferences = await DigitalAnumatiConsent.getConsentPreferences();
28await DigitalAnumatiConsent.updateConsent({ analytics: true, personalization: false, advertising: false });
29await DigitalAnumatiConsent.revokeConsent();
30 
31// Later:
32subscription.remove();

1useEffect(() => {
2  const subscription = DigitalAnumatiConsent.addListener((event) => {
3    switch (event.type) {
4      case 'CONSENT_ACCEPTED':
5      case 'CONSENT_REJECTED':
6      case 'CONSENT_UPDATED':
7        setStatus(event.result!.status);
8        break;
9      case 'CONSENT_REVOKED':
10        setStatus('NOT_DETERMINED');
11        break;
12      case 'CONSENT_ERROR':
13        console.warn('Consent error', event.error?.code);
14        break;
15    }
16  });
17  return () => subscription.remove();
18}, []);

1react-native-digital-anumati-consent/     # DEMO / FICTIONAL package
2├── src/
3│   ├── index.ts                        # public exports
4│   ├── types.ts                        # ConsentStatus, ConsentPreferences, ConsentResult, errors, events
5│   └── DigitalAnumatiConsent.ts        # Promise API + NativeEventEmitter
6├── android/
7│   ├── build.gradle                    # depends on com.digitalanumati:consent-sdk
8│   └── src/main/java/com/digitalanumati/consent/reactnative/
9│       ├── DigitalAnumatiConsentModule.kt   # Kotlin bridge
10│       └── DigitalAnumatiConsentPackage.kt
11├── ios/
12│   ├── DigitalAnumatiConsentModule.swift    # Swift bridge
13│   └── DigitalAnumatiConsentModule.m        # exports the Swift class to React Native
14├── example/                            # anumati-react-native-demo
15│   ├── src/App.tsx
16│   ├── android/
17│   └── ios/
18├── __tests__/DigitalAnumatiConsent.test.ts
19├── react-native-digital-anumati-consent.podspec
20├── package.json
21├── react-native.config.js
22├── tsconfig.json
23└── README.md

1{
2  "name": "@digitalanumati/react-native-consent",
3  "version": "1.0.0",
4  "description": "DEMO / FICTIONAL React Native bridge for the Digital Anumati native consent SDKs",
5  "private": true,
6  "main": "src/index.ts",
7  "types": "src/index.ts",
8  "react-native": "src/index.ts",
9  "files": ["src", "android", "ios", "react-native-digital-anumati-consent.podspec", "react-native.config.js"],
10  "peerDependencies": {
11    "react": ">=18",
12    "react-native": ">=0.72"
13  },
14  "devDependencies": {
15    "@types/jest": "^29.5.0",
16    "jest": "^29.7.0",
17    "react-native": "^0.76.0",
18    "typescript": "^5.4.0"
19  },
20  "jest": {
21    "preset": "react-native"
22  }
23}

1// react-native.config.js — autolinking hints for the Android package class
2module.exports = {
3  dependency: {
4    platforms: {
5      android: {
6        packageImportPath: 'import com.digitalanumati.consent.reactnative.DigitalAnumatiConsentPackage;',
7        packageInstance: 'new DigitalAnumatiConsentPackage()',
8      },
9      ios: {},
10    },
11  },
12};

1{
2  "compilerOptions": {
3    "target": "ES2020",
4    "module": "ESNext",
5    "moduleResolution": "bundler",
6    "jsx": "react-native",
7    "strict": true,
8    "noEmit": true,
9    "skipLibCheck": true
10  },
11  "include": ["src", "__tests__"]
12}

1// src/types.ts — mirrors the native SDK types. No consent logic lives in JavaScript.
2export type Environment = 'uat' | 'production';
3 
4export type ConsentStatus = 'NOT_DETERMINED' | 'GRANTED' | 'DENIED' | 'PARTIAL';
5 
6export type ConsentCategory = 'NECESSARY' | 'ANALYTICS' | 'PERSONALIZATION' | 'ADVERTISING';
7 
8export interface ConsentPreferences {
9  necessary: true; // always on; the native SDK enforces this
10  analytics: boolean;
11  personalization: boolean;
12  advertising: boolean;
13}
14 
15/** What updateConsent() accepts — "necessary" can't be changed. */
16export type ConsentPreferencesUpdate = Omit<ConsentPreferences, 'necessary'>;
17 
18export interface ConsentResult {
19  status: ConsentStatus;
20  preferences: ConsentPreferences;
21  timestamp: number; // epoch millis
22}
23 
24export type ConsentErrorCode =
25  | 'INITIALIZATION_FAILED'
26  | 'INVALID_CONFIGURATION'
27  | 'INVALID_SITE_KEY'
28  | 'INVALID_APPLICATION_ID'
29  | 'NETWORK_ERROR'
30  | 'CONSENT_LOAD_FAILED'
31  | 'CONSENT_SAVE_FAILED'
32  | 'USER_CANCELLED'
33  | 'UNKNOWN_ERROR';
34 
35/** Shape of a rejected promise from any SDK call. */
36export interface ConsentError extends Error {
37  code: ConsentErrorCode;
38}
39 
40export type ConsentEventType =
41  | 'SDK_INITIALIZED'
42  | 'CONSENT_SHOWN'
43  | 'CONSENT_ACCEPTED'
44  | 'CONSENT_REJECTED'
45  | 'CONSENT_UPDATED'
46  | 'CONSENT_REVOKED'
47  | 'CONSENT_ERROR';
48 
49export interface ConsentEvent {
50  type: ConsentEventType;
51  result?: ConsentResult; // ACCEPTED, REJECTED, UPDATED
52  error?: { code: ConsentErrorCode; message: string }; // CONSENT_ERROR
53}
54 
55export interface InitializeOptions {
56  siteKey: string;
57  applicationId: string;
58  environment?: Environment; // defaults to 'uat'
59}

1// src/DigitalAnumatiConsent.ts
2import { NativeEventEmitter, NativeModules, Platform } from 'react-native';
3import type {
4  ConsentEvent,
5  ConsentPreferences,
6  ConsentPreferencesUpdate,
7  ConsentResult,
8  ConsentStatus,
9  InitializeOptions,
10} from './types';
11 
12const LINKING_ERROR =
13  "The native module 'DigitalAnumatiConsent' isn't linked. " +
14  Platform.select({ ios: "Run 'pod install' in the ios folder, then ", default: '' }) +
15  'rebuild the app.';
16 
17const Native = NativeModules.DigitalAnumatiConsent
18  ? NativeModules.DigitalAnumatiConsent
19  : new Proxy(
20      {},
21      {
22        get() {
23          throw new Error(LINKING_ERROR);
24        },
25      },
26    );
27 
28let emitter: NativeEventEmitter | undefined;
29const getEmitter = () => (emitter ??= new NativeEventEmitter(NativeModules.DigitalAnumatiConsent));
30 
31/**
32 * DEMO / FICTIONAL — a thin Promise wrapper over the native SDKs. Rejected promises carry the
33 * native error code (err.code); consent storage, rules and networking stay in native code.
34 */
35export const DigitalAnumatiConsent = {
36  initialize: (options: InitializeOptions): Promise<void> =>
37    Native.initialize({ environment: 'uat', ...options }),
38 
39  /** Shows the native, SDK-owned consent screen and resolves with the user's choice. */
40  showConsent: (): Promise<ConsentResult> => Native.showConsent(),
41 
42  getConsentStatus: (): Promise<ConsentStatus> => Native.getConsentStatus(),
43 
44  getConsentPreferences: (): Promise<ConsentPreferences> => Native.getConsentPreferences(),
45 
46  updateConsent: (preferences: ConsentPreferencesUpdate): Promise<ConsentResult> =>
47    Native.updateConsent(preferences),
48 
49  revokeConsent: (): Promise<void> => Native.revokeConsent(),
50 
51  isInitialized: (): Promise<boolean> => Native.isInitialized(),
52 
53  /** Subscribes to SDK events. Call .remove() on the returned subscription to stop listening. */
54  addListener: (listener: (event: ConsentEvent) => void) =>
55    getEmitter().addListener('DigitalAnumatiConsentEvent', (event) => listener(event as ConsentEvent)),
56};

1// src/index.ts
2export { DigitalAnumatiConsent } from './DigitalAnumatiConsent';
3export * from './types';

1// android/src/main/java/com/digitalanumati/consent/reactnative/DigitalAnumatiConsentModule.kt
2package com.digitalanumati.consent.reactnative
3 
4import com.digitalanumati.consent.ConsentError
5import com.digitalanumati.consent.ConsentErrorCode
6import com.digitalanumati.consent.ConsentEvent
7import com.digitalanumati.consent.ConsentListener
8import com.digitalanumati.consent.ConsentPreferences
9import com.digitalanumati.consent.ConsentResult
10import com.digitalanumati.consent.DigitalAnumati
11import com.digitalanumati.consent.Environment
12import com.facebook.react.bridge.Arguments
13import com.facebook.react.bridge.Promise
14import com.facebook.react.bridge.ReactApplicationContext
15import com.facebook.react.bridge.ReactContextBaseJavaModule
16import com.facebook.react.bridge.ReactMethod
17import com.facebook.react.bridge.ReadableMap
18import com.facebook.react.bridge.UiThreadUtil
19import com.facebook.react.bridge.WritableMap
20import com.facebook.react.modules.core.DeviceEventManagerModule
21import kotlinx.coroutines.CoroutineScope
22import kotlinx.coroutines.Dispatchers
23import kotlinx.coroutines.SupervisorJob
24import kotlinx.coroutines.cancel
25import kotlinx.coroutines.launch
26 
27/** DEMO / FICTIONAL — converts JS calls to native SDK calls. No consent logic here. */
28class DigitalAnumatiConsentModule(private val reactContext: ReactApplicationContext) :
29    ReactContextBaseJavaModule(reactContext) {
30 
31    private val scope = CoroutineScope(SupervisorJob() + Dispatchers.Main)
32    private var listenerCount = 0
33 
34    init {
35        // Native SDK event -> WritableMap -> JS "DigitalAnumatiConsentEvent"
36        DigitalAnumati.setEventListener { event ->
37            if (listenerCount > 0) {
38                reactContext
39                    .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
40                    .emit(EVENT_NAME, event.toWritableMap())
41            }
42        }
43    }
44 
45    override fun getName() = NAME
46 
47    // JS object -> ReadableMap -> Kotlin arguments
48    @ReactMethod
49    fun initialize(options: ReadableMap, promise: Promise) = bridge(promise) {
50        DigitalAnumati.initialize(
51            context = reactContext.applicationContext,
52            siteKey = options.stringOrEmpty("siteKey"),
53            applicationId = options.stringOrEmpty("applicationId"),
54            environment = if (options.stringOrEmpty("environment") == "production") {
55                Environment.PRODUCTION
56            } else {
57                Environment.UAT
58            },
59        )
60        promise.resolve(null)
61    }
62 
63    @ReactMethod
64    fun isInitialized(promise: Promise) = promise.resolve(DigitalAnumati.isInitialized())
65 
66    // Kotlin enum -> JS string ("GRANTED")
67    @ReactMethod
68    fun getConsentStatus(promise: Promise) = bridge(promise) {
69        promise.resolve(DigitalAnumati.getConsentStatus().name)
70    }
71 
72    // Kotlin data class -> WritableMap -> JS object
73    @ReactMethod
74    fun getConsentPreferences(promise: Promise) = bridge(promise) {
75        promise.resolve(DigitalAnumati.getConsentPreferences().toWritableMap())
76    }
77 
78    // React methods run on a background thread; the consent screen must start on the UI thread.
79    @ReactMethod
80    fun showConsent(promise: Promise) {
81        val activity = reactContext.currentActivity ?: return promise.reject(
82            ConsentErrorCode.UNKNOWN_ERROR.name,
83            "No foreground activity to present the consent screen.",
84        )
85        UiThreadUtil.runOnUiThread {
86            DigitalAnumati.showConsent(activity, object : ConsentListener {
87                override fun onConsentCompleted(result: ConsentResult) =
88                    promise.resolve(result.toWritableMap())
89 
90                override fun onError(error: ConsentError) =
91                    promise.reject(error.code.name, error.message, error)
92            })
93        }
94    }
95 
96    @ReactMethod
97    fun updateConsent(preferences: ReadableMap, promise: Promise) {
98        scope.launch {
99            bridge(promise) {
100                val result = DigitalAnumati.updateConsent(
101                    ConsentPreferences(
102                        analytics = preferences.booleanOrFalse("analytics"),
103                        personalization = preferences.booleanOrFalse("personalization"),
104                        advertising = preferences.booleanOrFalse("advertising"),
105                    ),
106                )
107                promise.resolve(result.toWritableMap())
108            }
109        }
110    }
111 
112    @ReactMethod
113    fun revokeConsent(promise: Promise) {
114        scope.launch {
115            bridge(promise) {
116                DigitalAnumati.revokeConsent()
117                promise.resolve(null)
118            }
119        }
120    }
121 
122    // Required by NativeEventEmitter on the JS side.
123    @ReactMethod
124    fun addListener(eventName: String) {
125        listenerCount += 1
126    }
127 
128    @ReactMethod
129    fun removeListeners(count: Int) {
130        listenerCount = maxOf(0, listenerCount - count)
131    }
132 
133    override fun invalidate() {
134        DigitalAnumati.setEventListener(null)
135        scope.cancel()
136        super.invalidate()
137    }
138 
139    /** Native ConsentError -> promise.reject(code, message) -> JS Error with err.code. */
140    private inline fun bridge(promise: Promise, block: () -> Unit) {
141        try {
142            block()
143        } catch (e: ConsentError) {
144            promise.reject(e.code.name, e.message, e)
145        } catch (e: Exception) {
146            promise.reject(ConsentErrorCode.UNKNOWN_ERROR.name, e.message, e)
147        }
148    }
149 
150    companion object {
151        const val NAME = "DigitalAnumatiConsent"
152        const val EVENT_NAME = "DigitalAnumatiConsentEvent"
153    }
154}
155 
156// ---- Type conversions (native <-> JS) -------------------------------------------------------
157 
158private fun ReadableMap.stringOrEmpty(key: String): String =
159    if (hasKey(key) && !isNull(key)) getString(key).orEmpty() else ""
160 
161private fun ReadableMap.booleanOrFalse(key: String): Boolean =
162    hasKey(key) && !isNull(key) && getBoolean(key)
163 
164private fun ConsentPreferences.toWritableMap(): WritableMap = Arguments.createMap().apply {
165    putBoolean("necessary", necessary)
166    putBoolean("analytics", analytics)
167    putBoolean("personalization", personalization)
168    putBoolean("advertising", advertising)
169}
170 
171private fun ConsentResult.toWritableMap(): WritableMap = Arguments.createMap().apply {
172    putString("status", status.name)
173    putMap("preferences", preferences.toWritableMap())
174    putDouble("timestamp", timestamp.toDouble()) // JS numbers are doubles
175}
176 
177private fun ConsentEvent.toWritableMap(): WritableMap = Arguments.createMap().apply {
178    putString("type", type.name)
179    result?.let { putMap("result", it.toWritableMap()) }
180    error?.let { err ->
181        putMap(
182            "error",
183            Arguments.createMap().apply {
184                putString("code", err.code.name)
185                putString("message", err.message)
186            },
187        )
188    }
189}

1// android/src/main/java/com/digitalanumati/consent/reactnative/DigitalAnumatiConsentPackage.kt
2package com.digitalanumati.consent.reactnative
3 
4import com.facebook.react.ReactPackage
5import com.facebook.react.bridge.NativeModule
6import com.facebook.react.bridge.ReactApplicationContext
7import com.facebook.react.uimanager.ViewManager
8 
9class DigitalAnumatiConsentPackage : ReactPackage {
10    override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> =
11        listOf(DigitalAnumatiConsentModule(reactContext))
12 
13    override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> =
14        emptyList()
15}

1// ios/DigitalAnumatiConsentModule.swift
2import Foundation
3import React
4import UIKit
5import DigitalAnumatiConsent
6 
7/// DEMO / FICTIONAL — converts JS calls to native SDK calls. No consent logic here.
8/// Named "...Module" so it doesn't clash with the DigitalAnumatiConsent SDK module;
9/// the .m file exports it to JavaScript as "DigitalAnumatiConsent".
10@objc(DigitalAnumatiConsentModule)
11final class DigitalAnumatiConsentModule: RCTEventEmitter {
12    private static let eventName = "DigitalAnumatiConsentEvent"
13    private var hasListeners = false
14 
15    override init() {
16        super.init()
17        // Native SDK event -> NSDictionary -> JS "DigitalAnumatiConsentEvent"
18        DigitalAnumati.setEventHandler { [weak self] event in
19            guard let self, self.hasListeners else { return }
20            self.sendEvent(withName: Self.eventName, body: event.asDictionary)
21        }
22    }
23 
24    override static func requiresMainQueueSetup() -> Bool { false }
25    override func supportedEvents() -> [String]! { [Self.eventName] }
26    override func startObserving() { hasListeners = true }
27    override func stopObserving() { hasListeners = false }
28 
29    // JS object -> NSDictionary -> Swift arguments
30    @objc(initialize:resolver:rejecter:)
31    func initialize(
32        _ options: NSDictionary,
33        resolver resolve: @escaping RCTPromiseResolveBlock,
34        rejecter reject: @escaping RCTPromiseRejectBlock
35    ) {
36        do {
37            try DigitalAnumati.initialize(
38                siteKey: options["siteKey"] as? String ?? "",
39                applicationId: options["applicationId"] as? String ?? "",
40                environment: options["environment"] as? String == "production" ? .production : .uat
41            )
42            resolve(nil)
43        } catch {
44            rejectWith(error, reject)
45        }
46    }
47 
48    @objc(isInitialized:rejecter:)
49    func isInitialized(_ resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
50        resolve(DigitalAnumati.isInitialized)
51    }
52 
53    // Swift enum -> JS string ("GRANTED")
54    @objc(getConsentStatus:rejecter:)
55    func getConsentStatus(_ resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
56        resolve(DigitalAnumati.getConsentStatus().rawValue)
57    }
58 
59    // Swift struct -> NSDictionary -> JS object
60    @objc(getConsentPreferences:rejecter:)
61    func getConsentPreferences(_ resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
62        resolve(DigitalAnumati.getConsentPreferences().asDictionary)
63    }
64 
65    @objc(showConsent:rejecter:)
66    func showConsent(_ resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
67        Task { @MainActor in
68            guard let presenter = RCTPresentedViewController() else {
69                reject("UNKNOWN_ERROR", "No view controller to present from.", nil)
70                return
71            }
72            do {
73                resolve(try await DigitalAnumati.showConsent(from: presenter).asDictionary)
74            } catch {
75                rejectWith(error, reject)
76            }
77        }
78    }
79 
80    @objc(updateConsent:resolver:rejecter:)
81    func updateConsent(
82        _ preferences: NSDictionary,
83        resolver resolve: @escaping RCTPromiseResolveBlock,
84        rejecter reject: @escaping RCTPromiseRejectBlock
85    ) {
86        let update = ConsentPreferences(
87            analytics: preferences["analytics"] as? Bool ?? false,
88            personalization: preferences["personalization"] as? Bool ?? false,
89            advertising: preferences["advertising"] as? Bool ?? false
90        )
91        Task { @MainActor in
92            do {
93                resolve(try await DigitalAnumati.updateConsent(update).asDictionary)
94            } catch {
95                rejectWith(error, reject)
96            }
97        }
98    }
99 
100    @objc(revokeConsent:rejecter:)
101    func revokeConsent(_ resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
102        Task { @MainActor in
103            do {
104                try await DigitalAnumati.revokeConsent()
105                resolve(nil)
106            } catch {
107                rejectWith(error, reject)
108            }
109        }
110    }
111}
112 
113// ---- Helpers and type conversions (native -> JS) --------------------------------------------
114 
115/// Native ConsentError -> reject(code, message) -> JS Error with err.code.
116private func rejectWith(_ error: Error, _ reject: RCTPromiseRejectBlock) {
117    let consentError = error as? ConsentError
118    reject(consentError?.code.rawValue ?? "UNKNOWN_ERROR", consentError?.message ?? error.localizedDescription, error)
119}
120 
121private extension ConsentPreferences {
122    var asDictionary: [String: Bool] {
123        [
124            "necessary": necessary,
125            "analytics": analytics,
126            "personalization": personalization,
127            "advertising": advertising,
128        ]
129    }
130}
131 
132private extension ConsentResult {
133    var asDictionary: [String: Any] {
134        [
135            "status": status.rawValue,
136            "preferences": preferences.asDictionary,
137            "timestamp": timestamp.timeIntervalSince1970 * 1000, // Date -> epoch millis (Double)
138        ]
139    }
140}
141 
142private extension ConsentEvent {
143    var asDictionary: [String: Any] {
144        var map: [String: Any] = ["type": type.rawValue]
145        if let result { map["result"] = result.asDictionary }
146        if let error { map["error"] = ["code": error.code.rawValue, "message": error.message] }
147        return map
148    }
149}

1// ios/DigitalAnumatiConsentModule.m — exports the Swift class to JS as "DigitalAnumatiConsent"
2#import <React/RCTBridgeModule.h>
3#import <React/RCTEventEmitter.h>
4 
5@interface RCT_EXTERN_REMAP_MODULE(DigitalAnumatiConsent, DigitalAnumatiConsentModule, RCTEventEmitter)
6 
7RCT_EXTERN_METHOD(initialize:(NSDictionary *)options
8                  resolver:(RCTPromiseResolveBlock)resolve
9                  rejecter:(RCTPromiseRejectBlock)reject)
10 
11RCT_EXTERN_METHOD(showConsent:(RCTPromiseResolveBlock)resolve
12                  rejecter:(RCTPromiseRejectBlock)reject)
13 
14RCT_EXTERN_METHOD(getConsentStatus:(RCTPromiseResolveBlock)resolve
15                  rejecter:(RCTPromiseRejectBlock)reject)
16 
17RCT_EXTERN_METHOD(getConsentPreferences:(RCTPromiseResolveBlock)resolve
18                  rejecter:(RCTPromiseRejectBlock)reject)
19 
20RCT_EXTERN_METHOD(updateConsent:(NSDictionary *)preferences
21                  resolver:(RCTPromiseResolveBlock)resolve
22                  rejecter:(RCTPromiseRejectBlock)reject)
23 
24RCT_EXTERN_METHOD(revokeConsent:(RCTPromiseResolveBlock)resolve
25                  rejecter:(RCTPromiseRejectBlock)reject)
26 
27RCT_EXTERN_METHOD(isInitialized:(RCTPromiseResolveBlock)resolve
28                  rejecter:(RCTPromiseRejectBlock)reject)
29 
30@end

1// example/src/App.tsx — anumati-react-native-demo
2import React, { useCallback, useEffect, useState } from 'react';
3import { Button, SafeAreaView, ScrollView, StyleSheet, Text, View } from 'react-native';
4import {
5  DigitalAnumatiConsent,
6  type ConsentError,
7  type ConsentPreferences,
8  type ConsentStatus,
9  type InitializeOptions,
10} from '@digitalanumati/react-native-consent';
11 
12const CONFIG: InitializeOptions = {
13  siteKey: 'demo-site-key-123',
14  applicationId: 'demo-mobile-app-123',
15  environment: __DEV__ ? 'uat' : 'production',
16};
17 
18const CATEGORIES = ['necessary', 'analytics', 'personalization', 'advertising'] as const;
19 
20export default function App() {
21  const [initialized, setInitialized] = useState(false);
22  const [status, setStatus] = useState<ConsentStatus>('NOT_DETERMINED');
23  const [preferences, setPreferences] = useState<ConsentPreferences | null>(null);
24  const [events, setEvents] = useState<string[]>([]);
25  const [error, setError] = useState<string | null>(null);
26 
27  const refresh = useCallback(async () => {
28    const ready = await DigitalAnumatiConsent.isInitialized();
29    setInitialized(ready);
30    if (!ready) return;
31    setStatus(await DigitalAnumatiConsent.getConsentStatus());
32    setPreferences(await DigitalAnumatiConsent.getConsentPreferences());
33  }, []);
34 
35  const run = useCallback(
36    async (action: () => Promise<unknown>) => {
37      try {
38        await action();
39        setError(null);
40      } catch (e) {
41        const err = e as ConsentError;
42        // USER_CANCELLED only means the screen was closed; keep the previous state.
43        if (err.code !== 'USER_CANCELLED') setError(err.code + ': ' + err.message);
44      }
45      await refresh();
46    },
47    [refresh],
48  );
49 
50  const initialize = useCallback(
51    () =>
52      run(async () => {
53        await DigitalAnumatiConsent.initialize(CONFIG);
54        // First launch (or after a revoke): ask before continuing.
55        if ((await DigitalAnumatiConsent.getConsentStatus()) === 'NOT_DETERMINED') {
56          await DigitalAnumatiConsent.showConsent();
57        }
58      }),
59    [run],
60  );
61 
62  useEffect(() => {
63    const subscription = DigitalAnumatiConsent.addListener((event) => {
64      setEvents((previous) => [event.type, ...previous].slice(0, 10));
65      if (event.result) {
66        setStatus(event.result.status);
67        setPreferences(event.result.preferences);
68      }
69    });
70    initialize();
71    return () => subscription.remove();
72  }, [initialize]);
73 
74  return (
75    <SafeAreaView style={styles.container}>
76      <ScrollView contentContainerStyle={styles.content}>
77        <Text style={styles.title}>Anumati React Native Demo</Text>
78 
79        {/* Home */}
80        <Text>SDK: {initialized ? 'Initialized' : 'Not initialized'}</Text>
81        <Text>Consent: {status}</Text>
82 
83        {/* Consent */}
84        {preferences && (
85          <View style={styles.card}>
86            {CATEGORIES.map((key) => (
87              <Text key={key}>
88                {key}: {preferences[key] ? 'allowed' : 'not allowed'}
89              </Text>
90            ))}
91          </View>
92        )}
93        {error && <Text style={styles.error}>{error}</Text>}
94 
95        <View style={styles.buttons}>
96          <Button title="Initialize SDK" onPress={initialize} />
97          <Button
98            title="Manage Consent"
99            disabled={!initialized}
100            onPress={() => run(DigitalAnumatiConsent.showConsent)}
101          />
102          <Button title="Refresh Consent" disabled={!initialized} onPress={() => run(refresh)} />
103          <Button
104            title="Revoke Consent"
105            disabled={!initialized || status === 'NOT_DETERMINED'}
106            onPress={() => run(DigitalAnumatiConsent.revokeConsent)}
107          />
108        </View>
109 
110        {/* Settings */}
111        <Text style={styles.subtitle}>Settings</Text>
112        <Text>Environment: {CONFIG.environment}</Text>
113        <Text style={styles.subtitle}>Recent events</Text>
114        {events.map((type, index) => (
115          <Text key={index}>{type}</Text>
116        ))}
117      </ScrollView>
118    </SafeAreaView>
119  );
120}
121 
122const styles = StyleSheet.create({
123  container: { flex: 1 },
124  content: { padding: 24, gap: 12 },
125  title: { fontSize: 22, fontWeight: '600' },
126  subtitle: { marginTop: 12, fontWeight: '600' },
127  card: { padding: 12, borderRadius: 8, borderWidth: 1, borderColor: '#d4d4d8', gap: 4 },
128  error: { color: '#b91c1c' },
129  buttons: { gap: 8 },
130});

1Android: native SDK throws ConsentError(code = NETWORK_ERROR)
2      → Kotlin module: promise.reject("NETWORK_ERROR", message, error)
3      → JS: await rejects with Error { code: "NETWORK_ERROR", message }
4 
5iOS:     native SDK throws ConsentError(code: .networkError)
6      → Swift module: reject("NETWORK_ERROR", message, error)
7      → JS: await rejects with Error { code: "NETWORK_ERROR", message }

1React Native app starts
2        ↓
3TypeScript: DigitalAnumatiConsent.initialize({ siteKey, applicationId, environment })
4        ↓
5NativeModules.DigitalAnumatiConsent.initialize(options)   (JS object → ReadableMap / NSDictionary)
6        ↓
7Android: DigitalAnumatiConsentModule.initialize   |   iOS: DigitalAnumatiConsentModule.initialize
8        ↓
9Native SDK: DigitalAnumati.initialize(...)  → emits SDK_INITIALIZED via NativeEventEmitter
10        ↓
11promise.resolve(null)  → await completes in JS
12   or promise.reject(code, message)  → JS Error with err.code

1// __tests__/DigitalAnumatiConsent.test.ts — unit tests for the TypeScript wrapper
2import { NativeModules } from 'react-native';
3import { DigitalAnumatiConsent } from '../src';
4 
5jest.mock('react-native', () => {
6  const RN = jest.requireActual('react-native');
7  RN.NativeModules.DigitalAnumatiConsent = {
8    initialize: jest.fn(() => Promise.resolve()),
9    getConsentStatus: jest.fn(() => Promise.resolve('PARTIAL')),
10    updateConsent: jest.fn(() =>
11      Promise.resolve({
12        status: 'PARTIAL',
13        preferences: { necessary: true, analytics: true, personalization: false, advertising: false },
14        timestamp: 1759054500000,
15      }),
16    ),
17    revokeConsent: jest.fn(() =>
18      Promise.reject(Object.assign(new Error('offline'), { code: 'NETWORK_ERROR' })),
19    ),
20    addListener: jest.fn(),
21    removeListeners: jest.fn(),
22  };
23  return RN;
24});
25 
26test('initialize defaults to UAT', async () => {
27  await DigitalAnumatiConsent.initialize({
28    siteKey: 'demo-site-key-123',
29    applicationId: 'demo-mobile-app-123',
30  });
31  expect(NativeModules.DigitalAnumatiConsent.initialize).toHaveBeenCalledWith({
32    environment: 'uat',
33    siteKey: 'demo-site-key-123',
34    applicationId: 'demo-mobile-app-123',
35  });
36});
37 
38test('passes the native status through unchanged', async () => {
39  await expect(DigitalAnumatiConsent.getConsentStatus()).resolves.toBe('PARTIAL');
40});
41 
42test('updateConsent forwards preferences and returns the result', async () => {
43  const result = await DigitalAnumatiConsent.updateConsent({
44    analytics: true,
45    personalization: false,
46    advertising: false,
47  });
48  expect(result.status).toBe('PARTIAL');
49});
50 
51test('native rejections keep their error code', async () => {
52  await expect(DigitalAnumatiConsent.revokeConsent()).rejects.toMatchObject({ code: 'NETWORK_ERROR' });
53});