@osano/osano-cmp-react-native 0.11.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/selectors.ts

@@ -30,6 +30,7 @@ export const isDialogOpen = (state: OsanoState) =>
 
 export const isGPCSupportEnabled = (state: OsanoState) =>
 	!!state.config?.gpcSupport &&
+	typeof navigator !== 'undefined' &&
 	// Native browser support uses Navigator.prototype
 	(Object.hasOwnProperty.call(navigator, 'globalPrivacyControl') ||
 		// Browser extension support uses the Navigator instance on window

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;
@@ -305,6 +306,71 @@ export const fetchConfig = (customerId: string, configId: string) => {
 		})
 		.catch(() => {
 			// Consent not found or network/server error
-			return null;
+			throw new Error('Error fetching config');
 		});
 };
+
+export const getStoredConfig = async (
+	configId: string,
+): Promise<Config | null> => {
+	try {
+		const config = await getStorage(`${STORAGE_KEY}_${configId}_config`);
+		if (config) {
+			return JSON.parse(config) as Config;
+		}
+	} catch (error) {
+		// Failed to retrieve config
+	}
+	return null;
+};
+
+export const storeConfig = async (
+	configId: string,
+	config: Config,
+): Promise<void> => {
+	try {
+		await Promise.all([
+			setStorage(`${STORAGE_KEY}_${configId}_config`, JSON.stringify(config)),
+			setStorage(
+				`${STORAGE_KEY}_${configId}_config_last_stored_at`,
+				JSON.stringify(new Date()),
+			),
+		]);
+	} catch (error) {
+		throw new Error('Failed to store config');
+	}
+};
+
+export const getConfigLastStoredAt = async (
+	configId: string,
+): Promise<Date | null> => {
+	try {
+		const lastStoredAt = await getStorage(
+			`${STORAGE_KEY}_${configId}_config_last_stored_at`,
+		);
+		if (lastStoredAt) {
+			return new Date(JSON.parse(lastStoredAt));
+		}
+	} catch (error) {
+		// Failed to retrieve last stored at
+	}
+	return null;
+};
+
+/**
+ * Determine if a cached config is stale
+ *
+ * @async
+ * @param {string} configId
+ * @returns {Promise<boolean>}
+ */
+export const hasStaleConfig = async (configId: string): Promise<boolean> => {
+	const lastStoredAt = await getConfigLastStoredAt(configId);
+	if (!lastStoredAt) {
+		return true;
+	}
+	const now = new Date();
+	const diff = now.getTime() - lastStoredAt.getTime();
+	const diffInMinutes = Math.floor(diff / 60000);
+	return diffInMinutes > 1440; // 24 hours = 1440 minutes
+};

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/consent-config.d.ts

@@ -70,9 +70,6 @@ export type Config = {
 	type?: Flavor;
 	variant: 'one' | 'two' | 'three' | 'four' | 'five' | 'six' | '' | undefined;
 	country: string;
-	region: string;
-	iab: Iab;
-	palette: Palette;
 	additionalLinks: string[][];
 	iabEnabled: boolean;
 };

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/EventEmitter.ts

@@ -19,7 +19,6 @@ export class EventEmitter {
 	private _events: Record<string, Function[]> = {};
 
 	on(event: string, listener: Function) {
-		// console.log('EventEmitter.on', event, listener);
 		if (typeof this._events[event] !== 'object') {
 			this._events[event] = [];
 		}
@@ -29,7 +28,6 @@ export class EventEmitter {
 	}
 
 	off(event: string, listener: Function) {
-		// console.log('EventEmitter.off', event, listener);
 		if (typeof this._events[event] === 'object') {
 			const idx = this._events[event]!.indexOf(listener);
 			if (idx > -1) {
@@ -40,7 +38,7 @@ export class EventEmitter {
 
 	emit(event: string, ...args: unknown[]) {
 		if (typeof this._events[event] === 'object') {
-			this._events[event]?.forEach(listener => listener.apply(this, args));
+			this._events[event]?.forEach((listener) => listener.apply(this, args));
 		}
 	}
 

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

@@ -57,7 +57,7 @@ export default class Translator extends EventEmitter {
 	constructor(
 		consentManager: ConsentManager,
 		messages: LocalizedStrings = {},
-		defaultLocale = 'en'
+		defaultLocale = 'en',
 	) {
 		super();
 		this._consentManager = consentManager;
@@ -103,15 +103,15 @@ export default class Translator extends EventEmitter {
 	load(
 		desiredLocale?: string,
 		onLangLoadSuccess?: () => void,
-		onLangLoadFailure?: () => void
+		onLangLoadFailure?: () => void,
 	): Promise<PromiseSettledResult<string | undefined>[]> {
 		const allLocales = desiredLocale
 			? Translator.fallbackLanguages(
-					desiredLocale.toLowerCase().replace(/_/g, '-')
+					desiredLocale.toLowerCase().replace(/_/g, '-'),
 				)
-			: [];
+			: [Translator.DEFAULT_LANGUAGE];
 
-		const locale = allLocales?.shift();
+		const locale = allLocales.shift();
 		const customerId = this._consentManager.customerId;
 		const configId = this._consentManager.configId;
 		this._langLoadFailureSubscription =
@@ -130,7 +130,7 @@ export default class Translator extends EventEmitter {
 				} else {
 					const localesToTry = [...allLocales];
 					globalPromise = this._loading[locale] = fetchGlobalLocalePhrases(
-						locale
+						locale,
 					)
 						.then((phrases) => {
 							this._currentLocale = locale;
@@ -146,7 +146,7 @@ export default class Translator extends EventEmitter {
 							while (nextLocale) {
 								try {
 									this._loading[`${nextLocale}`] = fetchGlobalLocalePhrases(
-										nextLocale
+										nextLocale,
 									).then((phrases) => {
 										this._currentLocale = nextLocale!;
 										this.extend(phrases as LocalizedStrings, nextLocale);
@@ -179,7 +179,7 @@ export default class Translator extends EventEmitter {
 						] = fetchLocalLocalePhrases(
 							this._consentManager.customerId,
 							this._consentManager.configId,
-							locale
+							locale,
 						)
 							.then((phrases) => {
 								this.override(phrases as LocalizedStrings, locale);
@@ -196,7 +196,7 @@ export default class Translator extends EventEmitter {
 											fetchLocalLocalePhrases(
 												this._consentManager.customerId,
 												this._consentManager.configId,
-												nextLocale
+												nextLocale,
 											).then((phrases) => {
 												this.override(phrases as LocalizedStrings, nextLocale);
 												delete this._loading[
@@ -217,7 +217,7 @@ export default class Translator extends EventEmitter {
 								}
 								this.emit(
 									'langLoadFailure',
-									`Locale ${locale} is not available for translation`
+									`Locale ${locale} is not available for translation`,
 								);
 								throw error;
 							});
@@ -231,12 +231,12 @@ export default class Translator extends EventEmitter {
 		} else {
 			this.emit(
 				'langLoadFailure',
-				`Locale ${locale} is not available for translation`
+				`Locale ${locale} is not available for translation`,
 			);
 			this._langLoadFailureSubscription?.remove();
 			this._langLoadSuccessSubscription?.remove();
 			return Promise.reject(
-				new Error(`Locale ${locale} is not available for translation`)
+				new Error(`Locale ${locale} is not available for translation`),
 			);
 		}
 	}
@@ -262,10 +262,10 @@ export default class Translator extends EventEmitter {
 	 * Create a translation template for a particular key path
 	 */
 	template(
-		key: string
+		key: string,
 	): (
 		props: string | il8nProps,
-		defaultPhrase: string
+		defaultPhrase: string,
 	) => string | LocalizedStrings {
 		return (props: string | il8nProps, defaultPhrase: string) =>
 			this.translate(key, props, defaultPhrase);
@@ -277,7 +277,7 @@ export default class Translator extends EventEmitter {
 	translate(
 		path: string | string[],
 		props: string | il8nProps = {},
-		defaultPhrase?: string
+		defaultPhrase?: string,
 	): string | LocalizedStrings {
 		const localePassed = typeof props === 'string';
 		const locale = localePassed ? props : props.locale || this.locale;

package/src/utils/index.ts

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