@osano/osano-cmp-react-native 0.1.0

package/src/iab/tcf/v2.0/reducer.js

@@ -0,0 +1,327 @@
+import { ACCEPT, DENY, Locale } from '../../../constants';
+import {
+	getPurposeIds,
+	getPurposeOptOuts,
+	getSpecialFeatureOptIns,
+	getVendorIds,
+	getVendorListVersion,
+	getVendorOptOuts,
+	getVendors,
+} from '../selectors';
+import {
+	setAllPurposeConsent,
+	setAllSpecialFeatureConsent,
+	setAllVendorConsent,
+	setPurposeConsent,
+	setSpecialFeatureConsent,
+	setVendorConsent,
+	updatePurposeList,
+	updateVendorListBegin,
+	updateVendorListFailure,
+	updateVendorListSuccess,
+} from '../actions';
+
+import { types as ActionTypes } from '../../../redux/actions';
+import { genericReducer } from '../../../redux/helpers';
+import { isSaved } from '../../../redux/selectors';
+import { makeParseConsentString } from '../consent';
+import { merge } from '../../../utils';
+
+export const initialState = {
+	iab: {
+		tcf: {
+			v2: {
+				purposeOptouts: {},
+				specialFeatureOptins: {},
+				stacks: [],
+				vendorListError: null,
+				vendorListLoading: false,
+				vendorListLoaded: false,
+				vendorListVersion: 0,
+				vendors: {},
+				vendorOptouts: {},
+			},
+		},
+	},
+};
+
+const processPurposeList = (purposeList, language = 'en') => {
+	const lang = language.slice(0, 2);
+	const { purposes, specialPurposes, features, specialFeatures, stacks } =
+		purposeList || {};
+	Locale.override(
+		{
+			iab: {
+				v2: { purposes, specialPurposes, features, specialFeatures, stacks },
+			},
+		},
+		lang,
+	);
+};
+
+const updateOptions = (state, options) => {
+	const { iab = {} } = options || {};
+	const {
+		v2: {
+			vendorListVersion = getVendorListVersion(state),
+			purposes = getPurposeIds(state),
+			vendors = getVendors(state),
+		} = {},
+	} = iab;
+
+	const newState = merge(
+		{ ...state },
+		{
+			iab: {
+				tcf: {
+					v2: {
+						vendorListVersion,
+						vendor: {
+							consents: {},
+						},
+					},
+				},
+			},
+		},
+	);
+	newState.iab.tcf.v2.vendors = vendors;
+	if (!isSaved(state)) {
+		// Only default the vendors to true if we have not already consented
+		newState.iab.tcf.v2.purposeOptouts = purposes.reduce((p, purposeId) => {
+			p[`${purposeId}`] = false;
+			return p;
+		}, {});
+		newState.iab.tcf.v2.vendorOptouts = Object.keys(vendors).reduce(
+			(v, vendorId) => {
+				v[`${vendorId}`] = false;
+				return v;
+			},
+			{},
+		);
+	}
+
+	return newState;
+};
+
+const updateSpecialFeatureConsent = (
+	state,
+	specialFeatureIds,
+	acceptOrDeny,
+) => {
+	const specialFeatureOptins = { ...getSpecialFeatureOptIns(state) };
+	for (const specialFeatureId of specialFeatureIds) {
+		if (acceptOrDeny === ACCEPT) {
+			specialFeatureOptins[`${specialFeatureId}`] = true;
+		} else {
+			delete specialFeatureOptins[`${specialFeatureId}`];
+		}
+	}
+	const newState = merge(
+		{ ...state },
+		{
+			iab: {
+				tcf: {
+					v2: {
+						specialFeatureOptins: {},
+					},
+				},
+			},
+		},
+	);
+	newState.iab.tcf.v2.specialFeatureOptins = specialFeatureOptins;
+	return newState;
+};
+
+const updatePurposeConsent = (state, purposeIds, acceptOrDeny) => {
+	const consents = { ...getPurposeOptOuts(state) };
+	// ACCEPT on "I Object" means OptOut is TRUE
+	for (const purposeId of purposeIds) {
+		if (acceptOrDeny === ACCEPT) {
+			consents[`${purposeId}`] = true;
+		} else {
+			delete consents[`${purposeId}`];
+		}
+	}
+	const newState = merge(
+		{ ...state },
+		{
+			iab: {
+				tcf: {
+					v2: {
+						purposeOptouts: {},
+					},
+				},
+			},
+		},
+	);
+	newState.iab.tcf.v2.purposeOptouts = consents;
+	return newState;
+};
+
+const updateVendorConsent = (state, vendorIds, acceptOrDeny) => {
+	const consents = { ...getVendorOptOuts(state) };
+	for (const vendorId of vendorIds) {
+		if (acceptOrDeny === DENY) {
+			consents[`${vendorId}`] = true;
+		} else {
+			delete consents[`${vendorId}`];
+		}
+	}
+	const newState = merge(
+		{ ...state },
+		{
+			iab: {
+				tcf: {
+					v2: {
+						vendorOptouts: {},
+					},
+				},
+			},
+		},
+	);
+	newState.iab.tcf.v2.vendorOptouts = consents;
+	return newState;
+};
+
+export default function makeReducer(initOptions) {
+	return genericReducer(initialState, {
+		[ActionTypes.init]: updateOptions,
+		[ActionTypes.updateConfig]: (state, config) =>
+			updateOptions(state, { config }),
+		[ActionTypes.setConsent]: (state, { category }) => {
+			/* "category" is a misleading name if it is an object. It is actually a
+        consent object and the manager middleware
+        (src/redux/middleware/manager.js) injects an IAB state so that it can be
+        serialized and saved to the user's device. */
+			if (typeof category === 'object') {
+				// We are only interested in this type for consent string parsing
+				const {
+					iab: {
+						v2: { p: purposeOptouts = {}, v: vendorOptouts = {} } = {},
+						euconsent: tcString,
+					} = {},
+				} = category;
+				const newState = merge(
+					{ ...state },
+					{
+						iab: {
+							tcf: {
+								v2: {
+									purposeOptouts,
+									vendorOptouts,
+								},
+							},
+						},
+					},
+				);
+				if (tcString && typeof tcString === 'string') {
+					const { specialFeatureOptins = {} } =
+						makeParseConsentString(initOptions)(tcString);
+					newState.iab.tcf.v2.specialFeatureOptins = specialFeatureOptins;
+				}
+				return newState;
+			}
+			return state;
+		},
+		[setSpecialFeatureConsent.type]: (
+			state,
+			{ specialFeatureId, acceptOrDeny },
+		) => {
+			return updateSpecialFeatureConsent(
+				state,
+				[specialFeatureId],
+				acceptOrDeny,
+			);
+		},
+		[setAllSpecialFeatureConsent.type]: (state, { acceptOrDeny }) => {
+			const specialFeatureIds = new Set(
+				Object.values(getVendors(state))
+					.map(vendor => vendor.specialPurposes)
+					.reduce((acc, ids) => acc.concat(ids), []),
+			);
+			return updateSpecialFeatureConsent(
+				state,
+				specialFeatureIds,
+				acceptOrDeny,
+			);
+		},
+		[setPurposeConsent.type]: (state, { purposeId, acceptOrDeny }) => {
+			return updatePurposeConsent(state, [purposeId], acceptOrDeny);
+		},
+		[setAllPurposeConsent.type]: (state, { acceptOrDeny }) => {
+			const purposeIds = getPurposeIds(state);
+			return updatePurposeConsent(state, purposeIds, acceptOrDeny);
+		},
+		[setVendorConsent.type]: (state, { vendorId, acceptOrDeny }) => {
+			return updateVendorConsent(state, [vendorId], acceptOrDeny);
+		},
+		[setAllVendorConsent.type]: (state, { acceptOrDeny }) => {
+			const vendorIds = getVendorIds(state);
+			return updateVendorConsent(state, vendorIds, acceptOrDeny);
+		},
+		[updatePurposeList.type]: (state, { purposeList, language = 'en' }) => {
+			processPurposeList(purposeList, language);
+			return state;
+		},
+		[updateVendorListBegin.type]: state => {
+			return merge(state, {
+				iab: {
+					tcf: {
+						v2: {
+							vendorListError: null,
+							vendorListLoading: true,
+						},
+					},
+				},
+			});
+		},
+		[updateVendorListSuccess.type]: (state, vendorList) => {
+			if (!vendorList) {
+				return state;
+			}
+			const { v2: settings = {} } = state?.iab?.tcf || {};
+			const {
+				vendorListVersion:
+					providedVendorListVersion = settings?.vendorListVersion,
+				vendors = {},
+			} = vendorList;
+			const parsedVendorListVersion = parseInt(providedVendorListVersion, 10);
+			const vendorListVersion = Math.max(
+				settings?.vendorListVersion || 0,
+				isNaN(parsedVendorListVersion) ? 0 : parsedVendorListVersion,
+			);
+			processPurposeList(vendorList);
+			const newState = merge(
+				{ ...state },
+				{
+					iab: {
+						tcf: {
+							v2: {
+								vendorListError: null,
+								vendorListLoading: false,
+								vendorListLoaded: true,
+								vendorListVersion,
+								vendors:
+									parsedVendorListVersion > vendorListVersion ? vendors : {},
+							},
+						},
+					},
+				},
+			);
+			return newState;
+		},
+		[updateVendorListFailure.type]: (state, { statusText = null } = {}) => {
+			return merge(state, {
+				iab: {
+					tcf: {
+						v2: {
+							vendorListError: statusText,
+							vendorListLoading: false,
+							vendorListLoaded: state?.iab?.tcf?.v2?.vendorListLoaded || false,
+						},
+					},
+				},
+			});
+		},
+	});
+}

package/src/iab/tcf/v2.0/shared-constants.js

@@ -0,0 +1,17 @@
+import { CMP_ID } from '../../constants';
+import { IAB_CMP_VERSION } from '@osano-cmp';
+
+const version = '2.0';
+/**
+ * We'll use this value of the GVL when the customer's config doesn't contain
+ * one. It's from March 2023.
+ */
+const FALLBACK_GVL_VERSION = 187;
+
+export const baseInitOptions = {
+	version,
+	cmpId: CMP_ID,
+	cmpVersion: IAB_CMP_VERSION,
+	fallbackGvlVersion: FALLBACK_GVL_VERSION,
+	defaultTimestamp: Date.now(),
+};

package/src/iab/tcf/v2.0/tcfcav1-constants.js

@@ -0,0 +1,115 @@
+import {
+	BitEncoder,
+	DateEncoder,
+	EncodableOptimizedFixedRange,
+	IdBitMapEncoder,
+	IntEncoder,
+	LangEncoder,
+} from './encoders';
+import {
+	dateFormatter,
+	fixedValuesArrayFormatter,
+	idsOnlyArrayFormatter,
+} from './formatters';
+
+import { baseInitOptions } from './shared-constants';
+import compressedBase64UrlEncoder from '../../gpp/encoders/CompressedBase64UrlEncoder';
+import { createUTCTimestampInDeciseconds } from './helpers';
+
+// gppSection is the key in redux state that stores the consent string.
+const gppSection = 'tcfcav1';
+/**
+ * This string is a stub with only the base values so that consent.js has a
+ * string to start with. Its values are essentially blank and will be replaced
+ * by real values when a string is created for the user.
+ */
+const BOOTSTRAP_TCSTRING = 'COsdsoAOsdsoAAAAAAAAAACAAAAAAAAAAAAAAAAA';
+
+/**
+ * @typedef CoreField
+ * @type {array}
+ * @property {string} 0 - The name of the field in the GPPModel
+ * <https://github.com/IABTechLab/iabgpp-es/blob/42060d7ac2b6d0ee70fc1b5bcd33fc447bf5123c/README.md#fields>
+ * @property {number} 1 - The number of bits to encode the field
+ * @property {Encoder} 2 - The encoder to use for this field
+ * @property {string} 3 - The path to the value in our TCF object
+ * @property {string} [4] - The formatter to use for this field for the client API calls
+ */
+
+/**
+ * The core fields of the TCString for TCF-Canada v1.
+ * @type {CoreField[]}
+ */
+const coreFieldSequence = [
+	['Version', 6, IntEncoder, 'version'],
+	['Created', 36, DateEncoder, 'created', dateFormatter],
+	['LastUpdated', 36, DateEncoder, 'lastUpdated', dateFormatter],
+	['CmpId', 12, IntEncoder, 'cmpId'],
+	['CmpVersion', 12, IntEncoder, 'cmpVersion'],
+	['ConsentScreen', 6, IntEncoder, 'currentScreen'],
+	['ConsentLanguage', 12, LangEncoder, 'consentLanguage'],
+	['VendorListVersion', 12, IntEncoder, 'gvlVersion'],
+	['TcfPolicyVersion', 6, IntEncoder, 'tcfPolicyVersion'],
+	['UseNonStandardStacks', 1, BitEncoder, 'useNonStandardStacks'],
+	[
+		'SpecialFeatureExpressConsent',
+		12,
+		IdBitMapEncoder,
+		'specialFeatureOptins',
+		fixedValuesArrayFormatter,
+	],
+	[
+		'PurposesExpressConsent',
+		24,
+		IdBitMapEncoder,
+		'purpose.consents',
+		fixedValuesArrayFormatter,
+	],
+	[
+		'PurposesImpliedConsent',
+		24,
+		IdBitMapEncoder,
+		'purpose.legitimateInterests',
+		fixedValuesArrayFormatter,
+	],
+	// Vendor Consents
+	[
+		'VendorExpressConsent',
+		Number.POSITIVE_INFINITY,
+		EncodableOptimizedFixedRange,
+		'vendor.consents',
+		idsOnlyArrayFormatter,
+	],
+	// Vendor Legitimate Interests
+	[
+		'VendorImpliedConsent',
+		Number.POSITIVE_INFINITY,
+		EncodableOptimizedFixedRange,
+		'vendor.legitimateInterests',
+		idsOnlyArrayFormatter,
+	],
+];
+
+const version = parseInt(baseInitOptions.version, 10);
+const staticFields = {
+	version,
+	cmpId: baseInitOptions.cmpId,
+	cmpVersion: baseInitOptions.cmpVersion,
+	tcfPolicyVersion: version,
+	useNonStandardStacks: true,
+};
+
+const dynamicFields = {
+	created: createUTCTimestampInDeciseconds,
+	lastUpdated: createUTCTimestampInDeciseconds,
+};
+
+export const initOptions = {
+	...baseInitOptions,
+	coreFieldSequence,
+	gppSection,
+	tcString: BOOTSTRAP_TCSTRING,
+	staticFields,
+	dynamicFields,
+	encoder: compressedBase64UrlEncoder,
+};

package/src/iab/tcf/v2.0/tcfeuv2-constants.js

@@ -0,0 +1,117 @@
+import {
+	BitEncoder,
+	DateEncoder,
+	EncodableOptimizedFixedRange,
+	IdBitMapEncoder,
+	IntEncoder,
+	LangEncoder,
+} from './encoders';
+
+import { baseInitOptions } from './shared-constants';
+import { createUTCTimestampInDeciseconds } from './helpers';
+import traditionalBase64UrlEncoder from '../../gpp/encoders/TraditionalBase64UrlEncoder';
+
+export const apiName = '__tcfapi';
+export const iframeName = '__tcfapiLocator';
+
+// gppSection is the key in redux state that stores the consent string.
+const gppSection = 'tcfeuv2';
+/**
+ * This string is a stub with only the base values so that consent.js has a
+ * string to start with. It was generated with <https://iabtcf.com/>.
+ *
+ * Fields set:
+ * - CMP ID: 279
+ * - CMP Version: 1
+ * - Is Service Specific: true
+ * - Use Non-Standard Stacks: true
+ * - Purpose One Treatment: false
+ * - Purpose Consents: 1, 10
+ *
+ * All values will be overridden when a real string is created for the user.
+ */
+const BOOTSTRAP_TCSTRING = 'CPpshUAPpshUAEXABAENAACwAIBAAAAAAAAAAAAAAAAA';
+
+/**
+ * @typedef CoreField
+ * @type {array}
+ * @property {string} 0 - The name of the field in the TCModel
+ * <https://github.com/InteractiveAdvertisingBureau/iabtcf-es/blob/e952844c689351a51b15d71b9dd43ee085c2f7f3/modules/core/src/TCModel.ts>
+ * @property {number} 1 - The number of bits to encode the field
+ * @property {Encoder} 2 - The encoder to use for this field
+ * @property {string} [3] - The path to the value in our TCF object if it is different from the TCModel
+ */
+
+/**
+ * The core fields of the TCString in the order they appear in the TCString
+ * Reference spec doc: https://github.com/InteractiveAdvertisingBureau/GDPR-Transparency-and-Consent-Framework/blob/master/TCFv2/IAB%20Tech%20Lab%20-%20Consent%20string%20and%20vendor%20list%20formats%20v2.md#the-core-string
+ *
+ * Note: some field names conflict with the TCModel<https://github.com/IABTechLab/iabgpp-es/blob/42060d7ac2b6d0ee70fc1b5bcd33fc447bf5123c/modules/cmpapi/src/encoder/field/TcfEuV2Field.ts>. We may need to resolve these conflicts. See comments below for specific fields.
+ * @type {CoreField[]}
+ */
+const coreFieldSequence = [
+	['version', 6, IntEncoder],
+	['created', 36, DateEncoder],
+	['lastUpdated', 36, DateEncoder],
+	['cmpId', 12, IntEncoder],
+	['cmpVersion', 12, IntEncoder],
+	['consentScreen', 6, IntEncoder, 'currentScreen'],
+	['consentLanguage', 12, LangEncoder],
+	['vendorListVersion', 12, IntEncoder, 'gvlVersion'],
+	['policyVersion', 6, IntEncoder, 'tcfPolicyVersion'], // spec doc: "TcfPolicyVersion", TCModel: "PolicyVersion"
+	['isServiceSpecific', 1, BitEncoder],
+	['useNonStandardStacks', 1, BitEncoder],
+	['specialFeatureOptins', 12, IdBitMapEncoder],
+	['purposeConsents', 24, IdBitMapEncoder, 'purpose.consents'], // spec doc: "PurposesConsent", TCModel: "PurposeConsents"
+	[
+		'purposeLegitimateInterests',
+		24,
+		IdBitMapEncoder,
+		'purpose.legitimateInterests',
+	], // spec doc: "PurposesLITransparency", TCModel: "PurposeLegitimateInterests"
+	['purposeOneTreatment', 1, BitEncoder],
+	['publisherCountryCode', 12, LangEncoder, 'publisherCC'], // spec doc: "PublisherCC", TCModel: "PublisherCountryCode"
+	// Vendor Consents
+	[
+		'vendorConsents',
+		Number.POSITIVE_INFINITY,
+		EncodableOptimizedFixedRange,
+		'vendor.consents',
+	], // spec doc does not name this field
+	// Vendor Legitimate Interests
+	[
+		'vendorLegitimateInterests', // spec doc does not name this field
+		Number.POSITIVE_INFINITY,
+		EncodableOptimizedFixedRange,
+		'vendor.legitimateInterests',
+	],
+	// We do not (yet) support publisher restrictions so this field should always be 0
+	['numPubRestrictions', 12, IntEncoder], // This is a meta field and shouldn't be exposed directly via an API
+];
+
+const version = parseInt(baseInitOptions.version, 10);
+const staticFields = {
+	version,
+	cmpId: baseInitOptions.cmpId,
+	cmpVersion: baseInitOptions.cmpVersion,
+	tcfPolicyVersion: version,
+	useNonStandardStacks: true,
+	isServiceSpecific: true,
+	purposeOneTreatment: false,
+	numPubRestrictions: 0,
+};
+
+const dynamicFields = {
+	created: createUTCTimestampInDeciseconds,
+	lastUpdated: createUTCTimestampInDeciseconds,
+};
+
+export const initOptions = {
+	...baseInitOptions,
+	coreFieldSequence,
+	gppSection,
+	tcString: BOOTSTRAP_TCSTRING,
+	staticFields,
+	dynamicFields,
+	encoder: traditionalBase64UrlEncoder,
+};

package/src/iab/types.ts

@@ -0,0 +1,67 @@
+import type { Gpp_v2 } from './gpp/types';
+import type { Tcf_v2 } from './tcf/types';
+import type { Usp } from './usp/types';
+
+type GvlVendor = {
+	// v2
+	id: number;
+	name: string;
+	purposes: number[];
+	legIntPurposes: number[];
+	flexiblePurposes: number[];
+	specialPurposes: number[];
+	features: number[];
+	specialFeatures: number[];
+	cookieMaxAgeSeconds: number;
+	usesCookies?: boolean;
+	cookieRefresh?: boolean;
+	usesNonCookieAccess?: boolean;
+	deviceStorageDisclosureUrl?: string;
+};
+
+export type GvlUrl = {
+	langId: string;
+	privacy?: string;
+	legIntClaim?: string;
+};
+
+export type GvlVendor_v2 = GvlVendor & {
+	policyUrl?: string;
+};
+export type GvlVendor_v3 = GvlVendor & {
+	overflow?: {
+		httpGetLimit: number;
+	};
+	urls?: GvlUrl[];
+	dataRetention?: {
+		stdRetention: number;
+		purposes: Record<string, number>;
+		specialPurposes: Record<string, number>;
+	};
+	dataDeclaration?: number[];
+};
+
+export type Iab = {
+	enabled?: boolean;
+	notified?: boolean;
+	signatory?: boolean;
+	hideOptOut?: boolean;
+	eu?: {
+		enabled: boolean;
+		v2?: Tcf_v2;
+		vendors?: number[]; // The vendor ids that are enabled
+	};
+	gpp?: Gpp_v2;
+	tcf?: {
+		enabled: boolean;
+		v2?: Tcf_v2;
+	};
+	usp?: Usp;
+};
+
+export type IabDisclosureType = {
+	name: string;
+	description: string;
+	descriptionLegal: string;
+	illustrations?: Record<string, string>;
+};

package/src/iab/usp/api.js

@@ -0,0 +1,56 @@
+import { getConsentDataObject, makeGetField } from './consent';
+
+export default function makeApi(initOptions) {
+	function bind(store) {
+		/**
+		 * USPAPI implementation
+		 * @function
+		 * @name __uspapi
+		 * @param {string} command - The command to be executed by the API
+		 * @param {number} version - The version number that the response should adhere to
+		 * @param {requestCallback} callback - The callback method that should be called with the command result
+		 * @param {string} [parameter] - Optional parameter to be passed to the `command`
+		 */
+		return function uspApi(command, version, callback, parameter) {
+			const state = store.getState();
+			const getField = makeGetField(initOptions);
+
+			const getUSPData = (
+				providedState,
+				apiVersion = initOptions.apiVersion,
+			) => {
+				try {
+					const consentData = getConsentDataObject({
+						...initOptions,
+						version: apiVersion,
+					})(providedState);
+					return consentData;
+				} catch (error) {
+					// Could not retrieve data
+					return undefined;
+				}
+			};
+
+			switch (command) {
+				case 'getUSPData': {
+					if (typeof callback === 'function') {
+						const uspData = getUSPData(state, version);
+						callback(uspData, !!uspData);
+					}
+					break;
+				}
+
+				case 'getField': {
+					const field = parameter;
+					return getField(state, field);
+				}
+
+				case 'getSection': {
+					return getUSPData(state, version);
+				}
+			}
+		};
+	}
+
+	return { bind };
+}