@osano/osano-cmp-react-native 0.12.0 → 0.14.0

package/src/native/OsanoCmp.ts

@@ -1,4 +1,5 @@
 import { NativeModules, Platform } from 'react-native';
+import NativeOsanoCmpSdk from '../NativeOsanoCmpSdk';
 
 const LINKING_ERROR =
 	`The package 'osano-cmp-react-native' doesn't seem to be linked. Make sure: \n\n` +
@@ -6,17 +7,12 @@ const LINKING_ERROR =
 	'- You rebuilt the app after installing the package\n' +
 	'- You are not using Expo Go\n';
 
-const OsanoCmpNativeModule = NativeModules.OsanoCmpSdk;
-const OsanoCmp = OsanoCmpNativeModule
-	? OsanoCmpNativeModule
-	: new Proxy(
-			{},
-			{
-				get() {
-					throw new Error(LINKING_ERROR);
-				},
-			},
-		);
+// Use TurboModule if available, fallback to legacy NativeModules
+const OsanoCmp = NativeOsanoCmpSdk ?? NativeModules.OsanoCmpSdk;
+
+if (!OsanoCmp) {
+	throw new Error(LINKING_ERROR);
+}
 
 export function getDeviceId(): Promise<string | null | undefined> {
 	return OsanoCmp.getDeviceId();
@@ -30,3 +26,32 @@ export function getStorage(key: string): Promise<string | null | undefined> {
 export function clearStorage(key: string): Promise<void> {
 	return OsanoCmp.clearStorage(key);
 }
+export function setStorageToDefault(
+	key: string,
+	value: string,
+): Promise<string> {
+	return OsanoCmp.setStorageToDefault
+		? OsanoCmp.setStorageToDefault(key, value)
+		: Promise.resolve(value);
+}
+export function setIntStorageToDefault(
+	key: string,
+	value: number,
+): Promise<number> {
+	return OsanoCmp.setIntStorageToDefault
+		? OsanoCmp.setIntStorageToDefault(key, value)
+		: Promise.resolve(value);
+}
+export function setBoolStorageToDefault(
+	key: string,
+	value: boolean,
+): Promise<boolean> {
+	return OsanoCmp.setBoolStorageToDefault
+		? OsanoCmp.setBoolStorageToDefault(key, value)
+		: Promise.resolve(value);
+}
+export function clearStorageFromDefault(key: string): Promise<void> {
+	return OsanoCmp.clearStorageFromDefault
+		? OsanoCmp.clearStorageFromDefault(key)
+		: Promise.resolve();
+}

package/src/services/consent.ts

@@ -1,22 +1,30 @@
 import {
 	ConsentCategory,
 	ConsentCategory as ConsentCategoryType,
+	env,
 } from '../constants';
+import { NativeModules, Platform } from 'react-native';
 import { clearStorage, getStorage, setStorage } from '../native/OsanoCmp';
 
 import API from '../utils/API';
 import type { Config } from '../types/consent-config';
 import type { ConsentManager } from '../ConsentManager';
-import { Platform } from 'react-native';
 import { TextEncoder } from 'text-encoding';
-import { env } from '../constants';
 import { merge } from '../utils';
+import { osanoLogger } from '../utils/OsanoLogger';
 import { sha512 } from 'js-sha512';
 
 const Buffer = require('buffer').Buffer;
 
 const { CONSENT_URI, LOOKUPS_URI, OSANO_ORIGIN } = env;
 
+const IS_OFFICIAL_SAMPLE: boolean = (NativeModules as any)?.OsanoCmpSdk
+	?.IS_OFFICIAL_SAMPLE;
+
+const CONSENTING_PLATFORM_TAG = IS_OFFICIAL_SAMPLE
+	? `${Platform.OS}.sample-react-native`
+	: `${Platform.OS}.react-native`;
+
 const overrideConfig: Partial<Config> = {
 	// Override config here
 	variant: 'two',
@@ -52,13 +60,14 @@ function createConsentPayload(
 	cmp: ConsentManager,
 	consent?: ConsentCategoryType[],
 ): ConsentPayload {
+	osanoLogger.debug(`Consenting Platform: ${CONSENTING_PLATFORM_TAG}`);
 	return Object.fromEntries(
 		Object.entries({
 			customerId: cmp.customerId,
 			configId: cmp.configId,
 			consented: consent ?? cmp.consent,
 			consentingDomain: cmp.consentingDomain,
-			consentingPlatform: `${Platform.OS}.react-native`,
+			consentingPlatform: CONSENTING_PLATFORM_TAG,
 			deviceId: cmp.deviceId,
 			extUsrData: cmp.extUsrData,
 		}).filter(([, value]) => value !== undefined),
@@ -81,7 +90,7 @@ function createConsentRecordPayload(
 			osnoConfigId: cmp.configId,
 			consented: consentedCategories.join(','),
 			consentingDomain: cmp.consentingDomain,
-			consentingPlatform: `${Platform.OS}.react-native`,
+			consentingPlatform: CONSENTING_PLATFORM_TAG,
 			userConsentId: cmp.deviceId,
 			extUsrData: hashedExtUsrData,
 		}).filter(([, value]) => value !== undefined),
@@ -100,24 +109,19 @@ const storeConsent = async (
 			resolve(cmp.consent ?? []);
 			return cmp.consent;
 		};
-		switch (Platform.OS) {
-			case 'ios':
-			case 'android':
+		setStorage(
+			`${STORAGE_KEY}_last_recorded_consent_date`,
+			JSON.stringify(new Date()),
+		)
+			.then(() => {
 				setStorage(
-					`${STORAGE_KEY}_last_recorded_consent_date`,
-					JSON.stringify(new Date()),
+					`${STORAGE_KEY}_${cmp.configId}`,
+					JSON.stringify(cmp.consent),
 				)
-					.then(() => {
-						setStorage(
-							`${STORAGE_KEY}_${cmp.configId}`,
-							JSON.stringify(cmp.consent),
-						)
-							.then(resConsent)
-							.catch(reject);
-					})
+					.then(resConsent)
 					.catch(reject);
-				break;
-		}
+			})
+			.catch(reject);
 	});
 };
 
@@ -128,14 +132,7 @@ export const clearConsent = async (cmp: ConsentManager) => {
 			resolve([ConsentCategory.ESSENTIAL]);
 			return cmp.consent;
 		};
-		switch (Platform.OS) {
-			case 'android':
-			case 'ios':
-				clearStorage(`${STORAGE_KEY}_${cmp.configId}`).then(resConsent);
-				break;
-			default:
-				break;
-		}
+		clearStorage(`${STORAGE_KEY}_${cmp.configId}`).then(resConsent);
 	});
 };
 
@@ -154,19 +151,12 @@ const retrieveConsent = async (cmp: ConsentManager) => {
 			}
 			throw new Error('Consent not found');
 		};
-		switch (Platform.OS) {
-			case 'ios':
-			case 'android':
-				getStorage(`${STORAGE_KEY}_${cmp.configId}`)
-					.then(resConsent)
-					.catch(() => {
-						// Consent not found
-						clearConsent(cmp).then(resolve);
-					});
-				break;
-			default:
-				break;
-		}
+		getStorage(`${STORAGE_KEY}_${cmp.configId}`)
+			.then(resConsent)
+			.catch(() => {
+				// Consent not found
+				clearConsent(cmp).then(resolve);
+			});
 	});
 };
 
@@ -182,15 +172,7 @@ const retrieveLastConsentTimestamp = async () => {
 				return '';
 			}
 		};
-		switch (Platform.OS) {
-			case 'ios':
-			case 'android':
-				getStorage(`${STORAGE_KEY}_last_recorded_consent_date`).then(resValue);
-				break;
-			default:
-				// nothing
-				break;
-		}
+		getStorage(`${STORAGE_KEY}_last_recorded_consent_date`).then(resValue);
 	});
 };
 
@@ -270,6 +252,7 @@ export const fetchConsent = async (cmp: ConsentManager) => {
 						ConsentCategoryType[category as keyof typeof ConsentCategoryType],
 				);
 				await storeConsent(cmp, remoteConsentCategories);
+
 				return remoteConsentCategories;
 			}
 		} catch (error) {
@@ -278,7 +261,7 @@ export const fetchConsent = async (cmp: ConsentManager) => {
 
 		return consent;
 	} catch (error) {
-		console.error('Error fetching consent:', error);
+		osanoLogger.error('Error fetching consent:', error as Error);
 		// Consent not found or network/server error.
 		const consent = await retrieveConsent(cmp);
 		return consent;

package/src/services/google-consent-mode-mapper.ts

@@ -0,0 +1,122 @@
+import { ConsentCategory } from '../constants';
+import type { GoogleConsentMap } from '../types/google-consent-mode';
+import {
+	GoogleConsentMapImpl,
+	GoogleConsentParameter,
+	GoogleConsentStatus,
+} from '../types/google-consent-mode';
+
+/**
+ * Google Consent Mode Category Mapper
+ *
+ * Converts Osano consent categories to Google Consent Mode v2 parameters.
+ *
+ * **Mapping Logic (matching iOS/Android SDKs):**
+ * - ANALYTICS category → analytics_storage parameter
+ * - MARKETING category → ad_storage, ad_user_data, ad_personalization parameters
+ *
+ * All Google Consent Mode parameters default to "denied" until explicitly granted through category mapping.
+ */
+export class GoogleConsentModeMapper {
+	private static readonly GOOGLE_CATEGORIES_MAP: Record<
+		string,
+		GoogleConsentParameter[]
+	> = {
+		[ConsentCategory.ANALYTICS]: [GoogleConsentParameter.ANALYTICS_STORAGE],
+		[ConsentCategory.MARKETING]: [
+			GoogleConsentParameter.AD_STORAGE,
+			GoogleConsentParameter.AD_USER_DATA,
+			GoogleConsentParameter.AD_PERSONALIZATION,
+		],
+	};
+
+	/**
+	 * Build a Google Consent Map from a set of Osano consent categories
+	 *
+	 * @param categories - Set of Osano consent categories that the user has granted
+	 * @returns GoogleConsentMap with appropriate Google Consent Mode v2 parameters
+	 *
+	 * @example
+	 * ```typescript
+	 * const categories = new Set([ConsentCategory.ANALYTICS, ConsentCategory.MARKETING]);
+	 * const consentMap = GoogleConsentModeMapper.buildGoogleConsentMap(categories);
+	 *
+	 * // Results in:
+	 * // {
+	 * //   analytics_storage: 'granted',
+	 * //   ad_storage: 'granted',
+	 * //   ad_user_data: 'granted',
+	 * //   ad_personalization: 'granted'
+	 * // }
+	 * ```
+	 */
+	static buildGoogleConsentMap(
+		categories: Set<ConsentCategory>,
+	): GoogleConsentMap {
+		// Initialize all parameters to DENIED by default
+		const consentMap: Record<GoogleConsentParameter, GoogleConsentStatus> = {
+			[GoogleConsentParameter.ANALYTICS_STORAGE]: GoogleConsentStatus.DENIED,
+			[GoogleConsentParameter.AD_STORAGE]: GoogleConsentStatus.DENIED,
+			[GoogleConsentParameter.AD_USER_DATA]: GoogleConsentStatus.DENIED,
+			[GoogleConsentParameter.AD_PERSONALIZATION]: GoogleConsentStatus.DENIED,
+		};
+
+		// Apply GRANTED status for mapped categories
+		categories.forEach((category) => {
+			const googleParameters = this.GOOGLE_CATEGORIES_MAP[category];
+
+			if (googleParameters) {
+				googleParameters.forEach((parameter) => {
+					consentMap[parameter] = GoogleConsentStatus.GRANTED;
+				});
+			}
+		});
+
+		return this.createGoogleConsentMap(consentMap);
+	}
+
+	/**
+	 * Create a GoogleConsentMap from a raw consent map
+	 *
+	 * @param consentMap - Raw mapping of Google Consent Mode parameters to status
+	 * @returns GoogleConsentMap implementation with helper methods
+	 */
+	static createGoogleConsentMap(
+		consentMap: Record<GoogleConsentParameter, GoogleConsentStatus>,
+	): GoogleConsentMap {
+		return new GoogleConsentMapImpl(consentMap);
+	}
+
+	/**
+	 * Check if a consent category is mapped to Google Consent Mode parameters
+	 *
+	 * @param category - Osano consent category to check
+	 * @returns true if the category is mapped to Google Consent Mode parameters
+	 */
+	static isGoogleConsentCategory(category: ConsentCategory): boolean {
+		return category in this.GOOGLE_CATEGORIES_MAP;
+	}
+
+	/**
+	 * Get Google Consent Mode parameters for a specific consent category
+	 *
+	 * @param category - Osano consent category
+	 * @returns Array of Google Consent Mode parameters mapped to this category
+	 */
+	static getGoogleParametersForCategory(
+		category: ConsentCategory,
+	): GoogleConsentParameter[] {
+		return this.GOOGLE_CATEGORIES_MAP[category] || [];
+	}
+
+	/**
+	 * Get readonly copy of the categories mapping
+	 *
+	 * @returns Readonly mapping of Osano categories to Google Consent Mode parameters
+	 */
+	static getCategoriesMapping(): Readonly<
+		Record<string, GoogleConsentParameter[]>
+	> {
+		return Object.freeze({ ...this.GOOGLE_CATEGORIES_MAP });
+	}
+}

package/src/types/google-consent-mode.ts

@@ -0,0 +1,122 @@
+/**
+ * Google Consent Mode v2 parameters as defined by Google
+ * @see https://developers.google.com/tag-platform/security/guides/consent?consentmode=advanced
+ */
+export enum GoogleConsentParameter {
+	ANALYTICS_STORAGE = 'analytics_storage',
+	AD_STORAGE = 'ad_storage',
+	AD_USER_DATA = 'ad_user_data',
+	AD_PERSONALIZATION = 'ad_personalization',
+}
+
+/**
+ * Google Consent Mode v2 status values
+ */
+export enum GoogleConsentStatus {
+	GRANTED = 'granted',
+	DENIED = 'denied',
+}
+
+/**
+ * Immutable consent map that provides Google Consent Mode v2 parameters
+ * with their corresponding status values and helper methods.
+ */
+export interface GoogleConsentMap {
+	readonly consentMap: Record<GoogleConsentParameter, GoogleConsentStatus>;
+
+	/**
+	 * Convert the consent map to a string-based record for easier Firebase integration
+	 * @returns Object with string keys and string values
+	 */
+	toStringMap(): Record<string, string>;
+
+	/**
+	 * Check if analytics storage consent is granted
+	 * @returns true if analytics_storage is granted
+	 */
+	isAnalyticsStorageGranted(): boolean;
+
+	/**
+	 * Check if ad storage consent is granted
+	 * @returns true if ad_storage is granted
+	 */
+	isAdStorageGranted(): boolean;
+
+	/**
+	 * Check if ad user data consent is granted
+	 * @returns true if ad_user_data is granted
+	 */
+	isAdUserDataGranted(): boolean;
+
+	/**
+	 * Check if ad personalization consent is granted
+	 * @returns true if ad_personalization is granted
+	 */
+	isAdPersonalizationGranted(): boolean;
+}
+
+/**
+ * Callback function type for Google Consent Mode updates
+ *
+ * This callback is triggered whenever consent status changes and provides
+ * the Google Consent Mode v2 parameters in a format ready for Firebase integration.
+ *
+ * @param consentMap - Object containing the four Google Consent Mode v2 parameters:
+ *   - "analytics_storage": "granted" or "denied"
+ *   - "ad_storage": "granted" or "denied"
+ *   - "ad_user_data": "granted" or "denied"
+ *   - "ad_personalization": "granted" or "denied"
+ */
+export interface GoogleConsentModeCallback {
+	(consentMap: Record<string, string>): void;
+}
+
+/**
+ * Concrete implementation of GoogleConsentMap interface
+ */
+export class GoogleConsentMapImpl implements GoogleConsentMap {
+	readonly consentMap: Record<GoogleConsentParameter, GoogleConsentStatus>;
+
+	constructor(consentMap: Record<GoogleConsentParameter, GoogleConsentStatus>) {
+		// Create immutable copy
+		this.consentMap = Object.freeze({ ...consentMap });
+	}
+
+	toStringMap(): Record<string, string> {
+		const stringMap: Record<string, string> = {};
+
+		Object.entries(this.consentMap).forEach(([parameter, status]) => {
+			stringMap[parameter] = status;
+		});
+
+		return stringMap;
+	}
+
+	isAnalyticsStorageGranted(): boolean {
+		return (
+			this.consentMap[GoogleConsentParameter.ANALYTICS_STORAGE] ===
+			GoogleConsentStatus.GRANTED
+		);
+	}
+
+	isAdStorageGranted(): boolean {
+		return (
+			this.consentMap[GoogleConsentParameter.AD_STORAGE] ===
+			GoogleConsentStatus.GRANTED
+		);
+	}
+
+	isAdUserDataGranted(): boolean {
+		return (
+			this.consentMap[GoogleConsentParameter.AD_USER_DATA] ===
+			GoogleConsentStatus.GRANTED
+		);
+	}
+
+	isAdPersonalizationGranted(): boolean {
+		return (
+			this.consentMap[GoogleConsentParameter.AD_PERSONALIZATION] ===
+			GoogleConsentStatus.GRANTED
+		);
+	}
+}

package/src/types/index.d.ts

@@ -6,7 +6,7 @@ import type {
 } from '../iab/tcf/types';
 import type { IabFrameworkType } from '../iab/types';
 import type { Palette } from './consent-config';
-
+import type { GoogleConsentModeCallback } from './google-consent-mode';
 
 export type OsanoOverrides = {
 	flavor?: FlavorKeys;
@@ -27,9 +27,11 @@ export interface OsanoProps {
 	hideUI?: boolean;
 	hideDisclosures?: boolean;
 	onConfigLoadSuccess?: () => void;
-	onConfigLoadFailure?: () => void;
+	onConfigLoadFailure?: (err: Error) => void;
 	onLangLoadSuccess?: () => void;
-	onLangLoadFailure?: () => void;
+	onLangLoadFailure?: (err: Error) => void;
+	onGoogleConsentUpdate?: GoogleConsentModeCallback;
 	overrides?: OsanoOverrides;
-	extUsrData?: string
+	extUsrData?: string;
+	setLoggingEnabled?: boolean;
 }

package/src/utils/OsanoLogger.ts

@@ -0,0 +1,53 @@
+export class OsanoLogger {
+	private readonly TAG = 'OsanoSDK';
+	private isEnabled = true;
+
+	setEnabled(enabled: boolean): void {
+		this.isEnabled = enabled;
+	}
+
+	getEnabled(): boolean {
+		return this.isEnabled;
+	}
+
+	error(message: string, error?: Error): void {
+		// Always log errors regardless of enabled state
+		if (error) {
+			console.error(`[${this.TAG}] ${message}`, error);
+		} else {
+			console.error(`[${this.TAG}] ${message}`);
+		}
+	}
+
+	warn(message: string): void {
+		if (!this.isEnabled) return;
+		console.warn(`[${this.TAG}] ${message}`);
+	}
+
+	info(message: string): void {
+		if (!this.isEnabled) return;
+		console.info(`[${this.TAG}] ${message}`);
+	}
+
+	debug(message: string): void {
+		if (!this.isEnabled) return;
+		console.debug(`[${this.TAG}] ${message}`);
+	}
+
+	verbose(message: string): void {
+		if (!this.isEnabled) return;
+		console.log(`[${this.TAG}-VERBOSE] ${message}`);
+	}
+
+	metric(name: string, durationMs: number): void {
+		if (!this.isEnabled) return;
+		console.info(`[${this.TAG}-Metrics] ${name}: ${durationMs} ms`);
+	}
+
+	log(message: string): void {
+		if (!this.isEnabled) return;
+		console.log(`[${this.TAG}] ${message}`);
+	}
+}
+
+export const osanoLogger = new OsanoLogger();

package/src/utils/Translator.ts

@@ -103,7 +103,7 @@ export default class Translator extends EventEmitter {
 	load(
 		desiredLocale?: string,
 		onLangLoadSuccess?: () => void,
-		onLangLoadFailure?: () => void,
+		onLangLoadFailure?: (err: Error) => void,
 	): Promise<PromiseSettledResult<string | undefined>[]> {
 		const allLocales = desiredLocale
 			? Translator.fallbackLanguages(

package/src/utils/index.ts

@@ -127,3 +127,5 @@ export function merge(
 }
 
 export function noop() {}
+
+export { osanoLogger as OsanoLogger } from './OsanoLogger';

package/src/views/Dialog/Buttons.tsx

@@ -1,3 +1,5 @@
+import React, { useContext, useMemo } from 'react';
+import { StyleSheet, View, type ViewProps, type ViewStyle } from 'react-native';
 import {
 	AcceptAllButton,
 	AcceptButton,
@@ -6,24 +8,27 @@ import {
 	RejectAllButton,
 	SaveButton,
 } from '../../components/Button';
-import React, { useContext } from 'react';
-import { StyleSheet, View, type ViewProps } from 'react-native';
-
 import { OsanoPrivateContext } from '../../context';
 import { isDialogOpen } from '../../selectors';
 
-export const Buttons: React.FC<ViewProps> = (props) => {
+export const Buttons: React.FC<ViewProps & { buttonStyle?: ViewStyle }> = (
+	props,
+) => {
 	const { style } = props;
 	const { config, getState } = useContext(OsanoPrivateContext);
 
 	const state = getState();
 	const disabled = !isDialogOpen(state);
+	const buttonStyle = useMemo(
+		() => [styles.button, props.buttonStyle],
+		[props.buttonStyle],
+	);
 
 	// Button Group 1
 	if (config?.isConsentImplied) {
 		return config.forceManagePreferencesButton ? (
-			<View style={style}>
-				<ManagePreferencesButton disabled={disabled} style={styles.fullWidth} />
+			<View style={[styles.container, style]}>
+				<ManagePreferencesButton disabled={disabled} style={buttonStyle} />
 			</View>
 		) : null;
 	}
@@ -31,41 +36,46 @@ export const Buttons: React.FC<ViewProps> = (props) => {
 	// Button Group 2
 	if (config?.tcfIsApplicable || config?.isButtonGroupTwo) {
 		return (
-			<View style={style}>
+			<View style={[styles.container, style]}>
 				{config.showManagePreferencesButtonInDialog ? (
-					<ManagePreferencesButton
-						disabled={disabled}
-						style={styles.fullWidth}
-					/>
+					<ManagePreferencesButton disabled={disabled} style={buttonStyle} />
 				) : (
-					<SaveButton disabled={disabled} style={styles.fullWidth} />
+					<SaveButton disabled={disabled} style={buttonStyle} />
 				)}
-				<AcceptAllButton disabled={disabled} style={styles.fullWidth} />
+				<AcceptAllButton disabled={disabled} style={buttonStyle} />
 				{config.rejectAllRequired ? (
-					<RejectAllButton disabled={disabled} style={styles.fullWidth} />
+					<RejectAllButton disabled={disabled} style={buttonStyle} />
 				) : null}
 			</View>
 		);
 	}
 
+	// Default button group
 	return (
-		<View style={style}>
-			<AcceptButton disabled={disabled} style={styles.fullWidth} />
-			<DenyButton disabled={disabled} style={styles.fullWidth} />
+		<View style={[styles.container, style]}>
+			<AcceptButton disabled={disabled} style={buttonStyle} />
+			<DenyButton disabled={disabled} style={buttonStyle} />
 			{config?.rejectAllRequired ? (
-				<RejectAllButton disabled={disabled} style={styles.fullWidth} />
+				<RejectAllButton disabled={disabled} style={buttonStyle} />
 			) : null}
 			{config?.forceManagePreferencesButton ? (
-				<ManagePreferencesButton disabled={disabled} style={styles.fullWidth} />
+				<ManagePreferencesButton disabled={disabled} style={buttonStyle} />
 			) : null}
 		</View>
 	);
 };
 
-export default Buttons;
-
 const styles = StyleSheet.create({
-	fullWidth: {
-		flexBasis: '100%',
+	container: {
+		justifyContent: 'center',
+		alignItems: 'center',
+		gap: 8,
+	},
+	button: {
+		flex: 1,
+		minWidth: 120,
+		maxWidth: 200,
 	},
 });
+
+export default Buttons;