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

package/src/native/OsanoCmp.ts

@@ -30,3 +30,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,17 +1,17 @@
+import { sha512 } from 'js-sha512';
+import { Platform } from 'react-native';
+import { TextEncoder } from 'text-encoding';
+import type { ConsentManager } from '../ConsentManager';
 import {
 	ConsentCategory,
 	ConsentCategory as ConsentCategoryType,
+	env,
 } from '../constants';
 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 { sha512 } from 'js-sha512';
+import API from '../utils/API';
+import { osanoLogger } from '../utils/OsanoLogger';
 
 const Buffer = require('buffer').Buffer;
 
@@ -270,6 +270,7 @@ export const fetchConsent = async (cmp: ConsentManager) => {
 						ConsentCategoryType[category as keyof typeof ConsentCategoryType],
 				);
 				await storeConsent(cmp, remoteConsentCategories);
+
 				return remoteConsentCategories;
 			}
 		} catch (error) {
@@ -278,7 +279,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;
@@ -30,6 +30,8 @@ export interface OsanoProps {
 	onConfigLoadFailure?: () => void;
 	onLangLoadSuccess?: () => void;
 	onLangLoadFailure?: () => 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/index.ts

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