@osano/osano-cmp-react-native 0.1.0 → 0.2.0

package/src/iab/tcf/middleware.ts

@@ -0,0 +1,217 @@
+// @ts-nocheck
+import { CLEAR_CONSENT, CLOSE, RELOAD, SET_CONFIG } from '../../actions';
+import type { IabMiddlewareFactory, Tcf_v2 } from './types';
+import type { OsanoAction, OsanoState } from '../../types/store';
+import {
+	SET_ALL_PURPOSE_CONSENT,
+	SET_ALL_SPECIAL_FEATURE_CONSENT,
+	SET_ALL_VENDOR_CONSENT,
+	setConsent,
+} from './actions';
+import { SET_CONSENT_DATA, setConsentData } from '../actions';
+import { clearStorage, getStorage, setStorage } from '../../native/OsanoCmp';
+import { getConsentString, getPurposeIds } from './selectors';
+import {
+	idRecordToBinaryString,
+	updatePurposeOptOuts,
+	updateSpecialFeatureOptIns,
+	updateVendorOptOuts,
+} from './helpers';
+import { makeFormatConsentString, makeParseConsentString } from './consent';
+
+import type { ConsentManager } from '../../ConsentManager';
+import type { IabInitOptions } from './types';
+import type { IabState } from '../types';
+import { Platform } from 'react-native';
+import type { Store } from '../../hooks/useThunkReducer';
+
+export const makeMiddleware: IabMiddlewareFactory = (
+	initOptions: IabInitOptions,
+) => {
+	const { createConsentPayload, gppSection, version } = initOptions;
+	const parseConsentString = makeParseConsentString(initOptions);
+	const formatConsentString = makeFormatConsentString(initOptions);
+	return (store: Store<OsanoState & IabState, OsanoAction>) =>
+		(next: (action: OsanoAction) => OsanoState & IabState) =>
+		(action: OsanoAction) => {
+			const oldState = store.getState();
+			const newState = next(action);
+			const { type, payload } = action;
+			const { config, configId } = newState;
+			newState.iab.tcf = newState.iab.tcf || {};
+			newState.iab.tcf.v2 = newState.iab.tcf.v2 || ({} as Tcf_v2);
+			switch (type) {
+				case RELOAD:
+				case SET_CONFIG: {
+					const { config } = payload;
+					const resConsent = (jsonString: string | null | undefined) => {
+						let payload = createConsentPayload();
+						if (jsonString) {
+							try {
+								payload = JSON.parse(jsonString) as ReturnType<
+									typeof createConsentPayload
+								>;
+								// Store the TcString
+								store.dispatch(
+									setConsentData(
+										gppSection,
+										formatConsentString(config, newState),
+									),
+								);
+							} catch (e) {
+								payload = createConsentPayload();
+							}
+						}
+						store.dispatch(setConsent(payload));
+					};
+					switch (Platform.OS) {
+						case 'ios':
+						case 'android':
+							getStorage(`${gppSection}_${configId}`)
+								.then(resConsent)
+								.catch(() => {
+									// Consent not found
+									clearStorage(`${gppSection}_${configId}`);
+								});
+							break;
+						default:
+							try {
+								resConsent(
+									window.localStorage.getItem(`${gppSection}_${configId}`),
+								);
+							} catch (e) {
+								window.localStorage.removeItem(`${gppSection}_${configId}`);
+							}
+							break;
+					}
+					break;
+				}
+				case CLEAR_CONSENT: {
+					switch (Platform.OS) {
+						case 'ios':
+						case 'android':
+							clearStorage(`${gppSection}_${configId}`);
+							break;
+						default:
+							try {
+								window.localStorage.removeItem(`${gppSection}_${configId}`);
+							} catch {}
+							break;
+					}
+					store.dispatch(setConsentData(gppSection, ''));
+					break;
+				}
+				case SET_ALL_PURPOSE_CONSENT: {
+					const acceptOrDeny = payload;
+					const purposeIds = getPurposeIds();
+					newState.iab.tcf!.v2!.purposeOptouts = updatePurposeOptOuts(
+						newState,
+						version,
+						purposeIds,
+						acceptOrDeny,
+					);
+					break;
+				}
+
+				case SET_ALL_SPECIAL_FEATURE_CONSENT: {
+					const acceptOrDeny = payload;
+					const specialFeatureIds: Set<number> = new Set(
+						Object.values(config?.getVendors() || {})
+							.map((vendor: any) => vendor.specialPurposes)
+							.reduce((acc, ids) => acc.concat(ids), []),
+					);
+					newState.iab.tcf!.v2!.specialFeatureOptins =
+						updateSpecialFeatureOptIns(
+							newState,
+							version,
+							Array.from(specialFeatureIds),
+							acceptOrDeny,
+						);
+					break;
+				}
+
+				case SET_ALL_VENDOR_CONSENT: {
+					const acceptOrDeny = payload;
+					const vendorIds = config?.getVendorIds() ?? [];
+					newState.iab.tcf!.v2!.vendorOptouts = updateVendorOptOuts(
+						newState,
+						version,
+						vendorIds,
+						acceptOrDeny,
+					);
+					break;
+				}
+
+				case CLOSE: {
+					const { config } = payload as ConsentManager;
+					store.dispatch(
+						setConsentData(gppSection, formatConsentString(config, newState)),
+					);
+					break;
+				}
+
+				case SET_CONSENT_DATA: {
+					// by the time we get here in the middleware, the reducers should have already set the tcString
+					const { gppSection, value } = action.payload;
+					if (gppSection === initOptions.gppSection) {
+						const { cmpId, cmpVersion, storageKey } = initOptions;
+						const currentTcString = getConsentString(oldState, initOptions);
+						if (value === currentTcString) {
+							// no change
+							break;
+						}
+						console.log(`\nSetting new consent string\n -> ${value}`);
+						const consent = parseConsentString(value);
+						setStorage(storageKey, value);
+						setStorage('IABTCF_CmpSdkID', cmpId.toString());
+						setStorage('IABTCF_CmpSdkVersion', cmpVersion.toString());
+						setStorage('IABTCF_PolicyVersion', version);
+						setStorage('IABTCF_PublisherCC', consent.publisherCC);
+						setStorage('IABTCF_gdprApplies', consent.gdprApplies ? '1' : '0');
+						setStorage(
+							'IABTCF_PurposeOneTreatment',
+							consent.purposeOneTreatment ? '1' : '0',
+						);
+						setStorage(
+							'IABTCF_UseNonStandardTexts',
+							consent.useNonStandardStacks ? '1' : '0',
+						);
+
+						// The following all have to be binary strings
+						setStorage(
+							'IABTCF_VendorConsents',
+							idRecordToBinaryString(consent.vendor.consents),
+						);
+						setStorage(
+							'IABTCF_VendorLegitimateInterests',
+							idRecordToBinaryString(consent.vendor.legitimateInterests),
+						);
+						setStorage(
+							'IABTCF_PurposeConsents',
+							idRecordToBinaryString(consent.purpose.consents),
+						);
+						setStorage(
+							'IABTCF_PurposeLegitimateInterests',
+							idRecordToBinaryString(consent.purpose.legitimateInterests),
+						);
+						setStorage(
+							'IABTCF_SpecialFeaturesOptIns',
+							idRecordToBinaryString(consent.specialFeatureOptins),
+						);
+						// Publisher restrictions are not yet supported
+						/*
+							'IABTCF_PublisherRestrictions',
+							'IABTCF_PublisherConsent'
+							'IABTCF_PublisherLegitimateInterests'
+							'IABTCF_PublisherCustomPurposesConsents'
+							'IABTCF_PublisherCustomPurposesLegitimateInterests'
+						*/
+					}
+				}
+			}
+
+			return newState;
+		};
+};
+
+export default makeMiddleware;

package/src/iab/tcf/reducer.ts

@@ -0,0 +1,250 @@
+// @ts-nocheck
+import { CLEAR_CONSENT, CLOSE, RELOAD, SET_CONFIG } from '../../actions';
+import type { OsanoAction, OsanoState } from '../../types/store';
+import {
+	SET_CONSENT,
+	SET_PURPOSE_CONSENT,
+	SET_SPECIAL_FEATURE_CONSENT,
+	SET_VENDOR_CONSENT,
+	UPDATE_PURPOSE_LIST,
+} from './actions';
+import { getVendorListVersion, getVendors } from './selectors';
+import {
+	updatePurposeOptOuts,
+	updateSpecialFeatureOptIns,
+	updateVendorOptOuts,
+} from './helpers';
+
+import type { Config } from '../../types/consent-config';
+import type { ConsentManager } from '../../ConsentManager';
+import type { IabInitOptions } from './types';
+import type { IabState } from '../types';
+import { Platform } from 'react-native';
+import { setStorage } from '../../native/OsanoCmp';
+
+export const initialState = {
+	iab: {
+		consentStrings: {},
+		tcf: {
+			v2: {
+				purposeOptouts: {},
+				specialFeatureOptins: {},
+				stacks: [],
+				vendorListError: null,
+				vendorListLoading: false,
+				vendorListLoaded: false,
+				vendorListVersion: 0,
+				vendors: {},
+				vendorOptouts: {},
+			},
+		},
+	},
+};
+
+const processPurposeList = (_purposeList: any, _language = 'en') => {
+	// const lang = language.slice(0, 2);
+	// const { purposes, specialPurposes, features, specialFeatures, stacks } =
+	// 	purposeList || {};
+	// TODO: Implement Locale
+	// Locale.override(
+	// 	{
+	// 		iab: {
+	// 			v2: { purposes, specialPurposes, features, specialFeatures, stacks },
+	// 		},
+	// 	},
+	// 	lang,
+	// );
+};
+
+const updateOptions = (
+	state: OsanoState & IabState,
+	options: {
+		config: Config;
+		initOptions: IabInitOptions;
+	},
+) => {
+	const { initOptions, config } = options;
+	const { version } = initOptions;
+	const vendorListVersion = getVendorListVersion(config, version);
+	const vendors = getVendors(config, version);
+
+	return {
+		...state,
+		...initialState,
+		iab: {
+			...state.iab,
+			tcf: {
+				v2: {
+					...state.iab.tcf?.v2,
+					vendorListLoaded: true,
+					vendorListVersion,
+					vendors,
+				},
+			},
+		},
+	};
+};
+
+export default function makeReducer(initOptions: IabInitOptions) {
+	const { createConsentPayload, gppSection, version } = initOptions;
+	return (state: OsanoState & IabState, action: OsanoAction) => {
+		const { type, payload } = action;
+		switch (type) {
+			case RELOAD: {
+				const { config } = payload;
+				return updateOptions(state, {
+					config,
+					initOptions,
+				});
+			}
+			case SET_CONFIG: {
+				const { config, customerId, configId } = payload;
+				const consentConfig = config;
+				// Validate that this is the correct config for this customer.
+				if (
+					consentConfig.customerId !== customerId ||
+					consentConfig.configId !== configId
+				) {
+					return state;
+				}
+				return updateOptions(state, {
+					config,
+					initOptions,
+				});
+			}
+
+			case SET_CONSENT: {
+				return {
+					...state,
+					iab: {
+						...state.iab,
+						tcf: {
+							...state.iab.tcf,
+							...payload,
+							v2: {
+								...state.iab.tcf?.v2,
+								...payload.v2,
+							},
+						},
+					},
+				};
+			}
+
+			case CLOSE: {
+				const { config } = payload as ConsentManager;
+				if (config.configId && config.iabEnabled) {
+					const payload = createConsentPayload(state);
+					switch (Platform.OS) {
+						case 'ios':
+						case 'android':
+							setStorage(
+								`${gppSection}_${config.configId}`,
+								JSON.stringify(payload),
+							);
+							break;
+						default:
+							try {
+								window.localStorage.setItem(
+									`${gppSection}_${config.configId}`,
+									JSON.stringify(payload),
+								);
+							} catch (e) {}
+							break;
+					}
+				}
+				return state;
+			}
+
+			case CLEAR_CONSENT: {
+				const payload = createConsentPayload();
+				return {
+					...state,
+					iab: {
+						...state.iab,
+						tcf: {
+							...state.iab.tcf,
+							...payload,
+							v2: {
+								...state.iab.tcf?.v2,
+								...payload.v2,
+							},
+						},
+					},
+				};
+			}
+
+			case SET_SPECIAL_FEATURE_CONSENT: {
+				const { specialFeatureId, acceptOrDeny } = payload;
+				return {
+					...state,
+					iab: {
+						...state.iab,
+						tcf: {
+							...state.iab.tcf,
+							v2: {
+								...state.iab.tcf?.v2,
+								specialFeatureOptins: updateSpecialFeatureOptIns(
+									state,
+									version,
+									[specialFeatureId],
+									acceptOrDeny,
+								),
+							},
+						},
+					},
+				};
+			}
+
+			case SET_PURPOSE_CONSENT: {
+				const { purposeId, acceptOrDeny } = payload;
+				return {
+					...state,
+					iab: {
+						...state.iab,
+						tcf: {
+							...state.iab.tcf,
+							v2: {
+								...state.iab.tcf?.v2,
+								purposeOptouts: updatePurposeOptOuts(
+									state,
+									version,
+									[purposeId],
+									acceptOrDeny,
+								),
+							},
+						},
+					},
+				};
+			}
+
+			case SET_VENDOR_CONSENT: {
+				const { vendorId, acceptOrDeny } = payload;
+				return {
+					...state,
+					iab: {
+						...state.iab,
+						tcf: {
+							...state.iab.tcf,
+							v2: {
+								...state.iab.tcf?.v2,
+								vendorOptouts: updateVendorOptOuts(
+									state,
+									version,
+									[vendorId],
+									acceptOrDeny,
+								),
+							},
+						},
+					},
+				};
+			}
+
+			case UPDATE_PURPOSE_LIST: {
+				const { purposeList, language } = payload;
+				processPurposeList(purposeList, language);
+				return state;
+			}
+		}
+		return state;
+	};
+}

package/src/iab/tcf/selectors.ts

@@ -0,0 +1,192 @@
+import type { TcfVersion, TcfVersionType, Tcf_v2 } from './types';
+import { consentToPurpose, purposeIds } from './constants';
+
+import type { Config } from '../../types/consent-config';
+import { ConsentCategory } from '../../constants';
+import type { IabState } from '../types';
+import type { OsanoState } from '../../types/store';
+import { get } from '../../utils';
+import { initialState } from '../../reducer';
+import { isBrowsingFrom } from '../gpp/selectors';
+
+const DOMAIN = 'iab.tcf';
+
+// Config Selectors
+export const doesGDPRApply = (config: Config, apiVersion?: TcfVersionType) => {
+	return !!get(getConfigData(config, apiVersion), 'gdprApplies') || false;
+};
+export const getStore = (config: Config) => get(config, DOMAIN, {});
+export const isIABEnabled = (config: Config) => config.iab.enabled ?? false;
+
+export const getConfigData = (config: Config, apiVersion = `2`) =>
+	get(config, `${DOMAIN}.v${parseInt(apiVersion, 10)}`, {});
+export const getStateData = <V extends TcfVersionType>(
+	state: Partial<IabState>,
+	apiVersion?: V
+) =>
+	get(
+		state,
+		`${DOMAIN}.v${parseInt(apiVersion ?? '2', 10)}`,
+		{}
+	) as TcfVersion<V>;
+
+export const getCurrentScreen = (state: OsanoState) =>
+	Math.max(0, state.stack.length - 1);
+
+export const getConsentString = (
+	state: IabState,
+	{ gppSection, tcString = '' }: { gppSection?: string; tcString?: string } = {}
+) => {
+	return (
+		(gppSection &&
+			state.iab.consentStrings &&
+			state.iab.consentStrings[gppSection]) ||
+		tcString
+	);
+};
+
+// API Specific Data
+export const getPublisherLegitimateInterests = (/* state, apiVersion */) => {
+	// Placeholder
+	return {};
+};
+export const getPurposeIds = () => [...purposeIds];
+export const getPurposeOptOuts = (
+	state: IabState,
+	apiVersion?: TcfVersionType
+): Record<string, boolean> =>
+	get(getStateData(state, apiVersion), 'purposeOptouts') || {};
+export const getPurposeConsents = (
+	state: OsanoState & IabState,
+	apiVersion?: TcfVersionType
+): Record<string, boolean> => {
+	const consent = getSavedConsent(state) || getConsent(state);
+	const optOutPurposes = getPurposeOptOuts(state, apiVersion);
+	return Object.entries(consentToPurpose(consent, apiVersion)).reduce(
+		(purposeConsents, [purposeId, hasConsented]) => {
+			purposeConsents[`${purposeId}`] =
+				hasConsented && !optOutPurposes[`${purposeId}`];
+			return purposeConsents;
+		},
+		{} as Record<string, boolean>
+	);
+};
+// Established legitimate interest per purpose
+export const getPurposesLITransparency = (
+	state: OsanoState & IabState,
+	apiVersion?: TcfVersionType
+) => {
+	/*
+	 *  PurposesLITransparency
+	 *  For the purposes of a TCString, this indicates that the end user
+	 *  has been given notification of the consent purposes and the
+	 *  opportunity to accept or deny them, or object individually.
+	 */
+	const purposeConsents = getPurposeConsents(state, apiVersion);
+	/** @type {Record<string,boolean>} */
+	const purposeLITransparency: Record<string, boolean> = {};
+	const optOutPurposes = getPurposeOptOuts(state, apiVersion);
+	Object.entries(purposeConsents).forEach(([purposeId]) => {
+		// We are only indicating that the user has been given transparency
+		if (!optOutPurposes[`${purposeId}`]) {
+			// If a user has not specifically objected, we mark the purpose true
+			purposeLITransparency[`${purposeId}`] = true;
+		}
+	});
+	/**
+	 * Purpose 1 is never allowed to be true for legitimate interest transparency
+	 */
+	delete purposeLITransparency[`${1}`];
+	return purposeLITransparency;
+};
+export const getSpecialFeatureOptIns = (
+	state: IabState,
+	apiVersion?: TcfVersionType
+): Record<string, boolean> =>
+	get(getStateData(state, apiVersion), 'specialFeatureOptins') || {};
+export const getVendors = (config: Config, apiVersion?: string) =>
+	(get(getConfigData(config, apiVersion), 'vendors') ||
+		{}) as Tcf_v2['vendors'];
+export const getVendorData = (
+	state: Config,
+	{ apiVersion, vendorId }: { apiVersion?: string; vendorId: string }
+) => get(getVendors(state, apiVersion), `${vendorId}`) || {};
+export const getVendorIds = (config: Config, apiVersion?: string) =>
+	Object.keys(getVendors(config, apiVersion)).map((vendorId) =>
+		Number.parseInt(vendorId, 10)
+	) || [];
+export const getVendorOptOuts = (
+	state: Partial<IabState>,
+	apiVersion?: TcfVersionType
+): Record<string, boolean> =>
+	get(getStateData(state, apiVersion), 'vendorOptouts') || {};
+export const getVendorListError = (
+	state: IabState,
+	apiVersion?: TcfVersionType
+) => get(getStateData(state, apiVersion), 'vendorListError', 0);
+export const getVendorListVersion = (
+	config: Config,
+	apiVersion?: TcfVersionType
+) => get(getConfigData(config, apiVersion), 'vendorListVersion');
+
+export const hasActed = (state: OsanoState, gppSection: string) =>
+	!!get(state, ['iab', 'hasActed', gppSection]);
+export const hasConsentedToSpecialFeature = (
+	state: IabState,
+	{
+		apiVersion,
+		specialFeatureId,
+	}: { apiVersion?: TcfVersionType; specialFeatureId: string }
+) => !!getSpecialFeatureOptIns(state, apiVersion)[`${specialFeatureId}`];
+export const hasOptedOutOfVendor = (
+	state: IabState,
+	{ apiVersion, vendorId }: { apiVersion?: TcfVersionType; vendorId: string }
+) => !!getVendorOptOuts(state, apiVersion)[`${vendorId}`];
+export const hasOptedOutOfPurpose = (
+	state: IabState,
+	{ apiVersion, purposeId }: { apiVersion?: TcfVersionType; purposeId: string }
+) => !!getPurposeOptOuts(state, apiVersion)[`${purposeId}`];
+
+export const isTcfApplicable = (state: Config) =>
+	(doesGDPRApply(state) || isBrowsingFrom(state, 'ca')) &&
+	!!get(getStore(state), 'enabled', isIABEnabled(state));
+export const isVendorListLoaded = (
+	state: Config,
+	apiVersion?: TcfVersionType
+) => !!get(getStateData(state, apiVersion), 'vendorListLoaded');
+export const isVendorListLoading = (
+	state: Config,
+	apiVersion?: TcfVersionType
+) => !!get(getStateData(state, apiVersion), 'vendorListLoading');
+
+export const getCountryCode = (config: Config) =>
+	`${config.country}`.substring(0, 2).toUpperCase() || null;
+export const getSavedConsent = (state: OsanoState) =>
+	get(state, 'savedConsent', null);
+export const isSaved = (state: OsanoState) => !!getSavedConsent(state);
+
+export const getFinalOptOutValue = (
+	state?: OsanoState,
+	pendingNewValue?: boolean
+) => {
+	if (pendingNewValue === true) {
+		return true;
+	} else if (pendingNewValue === undefined) {
+		const existingOptOut =
+			get(state, ['consent', ConsentCategory.OPT_OUT]) ||
+			initialState.consent[ConsentCategory.OPT_OUT];
+		return existingOptOut;
+	}
+
+	return false;
+};
+
+export const getConsent = (state?: OsanoState) => {
+	const consent: Record<ConsentCategory, boolean | undefined> = {
+		...(get(state, 'consent') || initialState.consent),
+	};
+	// eslint-disable-next-line security/detect-object-injection
+	// TODO implement this
+	consent[ConsentCategory.OPT_OUT] = getFinalOptOutValue(state);
+	return consent;
+};