@osano/osano-cmp-react-native 0.1.0

package/src/iab/tcf/tcfeuv2-api.js

@@ -0,0 +1,264 @@
+import { makeGetConsentDataObject, makeGetField } from './consent';
+
+import { MAX_DATE } from '../../constants';
+import { getConsentString } from './selectors';
+import { setGdprApplies } from './actions';
+
+/**
+ * Extracts the TCData fields from a consentDataObj
+ * @param {object} consentDataObj - Data object returned from getConsentDataObject()
+ */
+function consentToTcData(consentDataObj) {
+	const {
+		tcString,
+		tcfPolicyVersion,
+		cmpVersion,
+		cmpId,
+		gdprApplies,
+		cmpLoaded,
+		eventStatus,
+		cmpStatus,
+		displayStatus,
+		isServiceSpecific,
+		purposeOneTreatment,
+		useNonStandardStacks,
+		publisherCC,
+		purpose,
+		vendor,
+		specialFeatureOptins,
+		publisher,
+	} = consentDataObj;
+	return gdprApplies
+		? {
+				tcString,
+				tcfPolicyVersion,
+				cmpVersion,
+				cmpId,
+				gdprApplies,
+				cmpLoaded,
+				eventStatus,
+				cmpStatus,
+				displayStatus,
+				isServiceSpecific,
+				purposeOneTreatment,
+				useNonStandardStacks,
+				publisherCC: `${publisherCC}`.toUpperCase(),
+				purpose,
+				vendor,
+				specialFeatureOptins,
+				publisher,
+			}
+		: {
+				tcfPolicyVersion,
+				cmpVersion,
+				cmpId,
+				gdprApplies,
+				eventStatus,
+			};
+}
+
+const callbacks = {};
+
+const makeDispatch = apiVersion =>
+	function dispatch(data) {
+		const tcData = consentToTcData(data);
+		Object.entries(callbacks).forEach(([listenerId, { version, callback }]) => {
+			parseInt(apiVersion, 10) === parseInt(version, 10) &&
+				callback(
+					{
+						...tcData,
+						listenerId: parseInt(listenerId, 10),
+					},
+					true,
+				);
+		});
+	};
+
+/**
+ * TCFAPI implementation
+ * @function
+ * @name __tcfapi
+ * @param {string} command - The command to be executed by the API
+ * @param {string} [parameter] - Optional parameter to be passed to the `command`
+ * @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
+ */
+export default function makeApi(initOptions) {
+	const getTCData = (state, version) => {
+		try {
+			const consentDataObj = makeGetConsentDataObject({
+				...initOptions,
+				version,
+			})(state);
+			return consentToTcData(consentDataObj);
+		} catch {
+			// could not retrieve data
+			return undefined;
+		}
+	};
+
+	const getField = makeGetField(initOptions);
+
+	function bind(store) {
+		return function tcfApi(...args) {
+			const state = store.getState();
+			const [command] = args;
+			const [, requestedApiVersion] = args;
+			let apiVersion =
+				requestedApiVersion === null
+					? initOptions.version
+					: parseFloat(`${requestedApiVersion}`);
+			if (typeof apiVersion === 'number') {
+				// Floating point precision for numeric requests
+				if (isNaN(apiVersion)) {
+					apiVersion = 0;
+				} else {
+					const apiString = `${apiVersion}`.split('.');
+					apiVersion =
+						apiString.length === 1
+							? `${apiVersion}.0`
+							: `${apiString[0]}.${apiString[1][0]}`;
+				}
+			}
+			const version = parseInt(apiVersion, 10);
+
+			switch (command) {
+				case 'setGdprApplies': {
+					/**
+					 * shortcut to set gdprApplies if the publisher
+					 * knows that they apply GDPR rules to all
+					 * traffic (see the section on "What does the
+					 * gdprApplies value mean" for more
+					 */
+					let [, , callback, gdprApplies] = args;
+					if (typeof callback === 'function') {
+						switch (version) {
+							case 2: {
+								// Version 2
+								if (args.length > 3 && typeof gdprApplies === 'boolean') {
+									store.dispatch(setGdprApplies(gdprApplies));
+									callback('set', true);
+									return;
+								}
+							}
+						}
+						callback(undefined, false);
+					}
+					break;
+				}
+
+				case 'ping': {
+					const [, , callback] = args;
+					if (typeof callback === 'function') {
+						try {
+							const {
+								cmpId,
+								cmpLoaded,
+								cmpStatus,
+								cmpVersion,
+								displayStatus,
+								gdprApplies,
+								gvlVersion,
+								tcfPolicyVersion,
+							} = makeGetConsentDataObject({
+								...initOptions,
+								version: apiVersion,
+							})(state);
+							callback({
+								// Returned apiVersion is a string
+								apiVersion: `${apiVersion}`,
+								cmpId,
+								cmpLoaded,
+								cmpStatus,
+								cmpVersion,
+								displayStatus,
+								gdprApplies,
+								gvlVersion,
+								tcfPolicyVersion,
+							});
+						} catch (error) {
+							// Could not retrieve data
+							callback(undefined, false);
+						}
+					}
+					break;
+				}
+
+				case 'getField': {
+					const consentString = getConsentString(state, initOptions);
+					const [, , , field] = args;
+					// The spec uses 'TcfPolicyVersion' but the GPP reference
+					// implementation uses 'PolicyVersion' for tcfeuv2 and
+					// TcfPolicyVersion for tcfcav1. We support both.
+					if (field === 'TcfPolicyVersion') {
+						return getField(consentString, 'PolicyVersion');
+					}
+					return getField(consentString, field);
+				}
+
+				case 'getSection': {
+					return getTCData(state, apiVersion);
+				}
+
+				case 'getTCData': {
+					const [, , callback] = args;
+					if (typeof callback === 'function') {
+						const tcData = getTCData(state, apiVersion);
+						callback(tcData, !!tcData);
+					}
+					break;
+				}
+
+				case 'addEventListener': {
+					const [, , callback] = args;
+					if (typeof callback === 'function') {
+						try {
+							let inc = 0;
+							// listenerId must be a number: https://github.com/InteractiveAdvertisingBureau/GDPR-Transparency-and-Consent-Framework/blob/master/TCFv2/IAB%20Tech%20Lab%20-%20CMP%20API%20v2.md#tcdata
+							let listenerId = MAX_DATE - Date.now();
+							do {
+								listenerId -= inc++;
+							} while (callbacks[`${listenerId}`]);
+
+							callbacks[`${listenerId}`] = { version, callback };
+							const consentDataObj = makeGetConsentDataObject({
+								...initOptions,
+								version: apiVersion,
+							})(state);
+							const returnObject = {
+								...consentToTcData(consentDataObj),
+								listenerId,
+							};
+
+							callback(returnObject, true);
+						} catch (error) {
+							// Could not retrieve data
+							callback(undefined, false);
+						}
+					}
+					break;
+				}
+
+				case 'removeEventListener': {
+					const [, , callback, listenerId] = args;
+					delete callbacks[`${listenerId}`];
+					if (typeof callback === 'function') {
+						callback(true);
+					}
+					break;
+				}
+			}
+		};
+	}
+
+	return {
+		bind,
+		dispatch: makeDispatch(initOptions.version),
+	};
+}
+/**
+ * This callback is part of __tcfapi API
+ * @callback __tcfapi~requestCallback
+ * @param {import('./constants').TCFData} uspData
+ * @param {boolean} success
+ */

package/src/iab/tcf/types.ts

@@ -0,0 +1,13 @@
+import type { GvlVendor_v2 } from '../types';
+
+export type Tcf = {
+	gdprApplies: boolean;
+};
+
+export type Tcf_v2 = Tcf & {
+	vendors: Record<number, GvlVendor_v2>;
+	vendorListVersion: number;
+	purposeOptouts: Record<number, boolean>;
+	specialFeatureOptouts: Record<number, boolean>;
+	vendorOptouts: Record<number, boolean>;
+};

package/src/iab/tcf/v2.0/encoders.ts

@@ -0,0 +1,37 @@
+import {
+	BooleanEncoder,
+	DatetimeEncoder,
+	FixedIdBitMapEncoder,
+	FixedIntegerEncoder,
+	FixedStringEncoder,
+	type Codable,
+} from '../../gpp/encoders';
+
+export { EncodableOptimizedFixedRange } from '../../gpp/encoders';
+
+/**
+ * @typedef Encoder
+ * @type {object}
+ * @property {function(string, number?, ...params): {bitLength: number, value: any}} decode
+ * @property {function(any, number?, ...params): string} encode
+ */
+
+// This provides a consistent structure on decode()
+const adaptEncoder = (encoder: Codable) =>
+	({
+		decode: (bitString: string, numBits: number) => ({
+			bitLength: numBits,
+			value: encoder.decode(bitString, numBits),
+		}),
+		encode: encoder.encode,
+	}) as Codable;
+
+export const BitEncoder = adaptEncoder(BooleanEncoder);
+export const DateEncoder = adaptEncoder(DatetimeEncoder);
+// EncodableOptimizedFixedRange already conforms to the expected structure
+export const IdBitMapEncoder = adaptEncoder(FixedIdBitMapEncoder);
+export const IntEncoder = adaptEncoder(FixedIntegerEncoder);
+export const LangEncoder = adaptEncoder({
+	decode: FixedStringEncoder.decode,
+	encode: (value: string) => FixedStringEncoder.encode(value, 2).toUpperCase(),
+});

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

@@ -0,0 +1,14 @@
+export const idsOnlyArrayFormatter = value =>
+	Object.entries(value)
+		.filter(([, v]) => v)
+		.map(([k]) => parseInt(k, 10));
+
+export const fixedValuesArrayFormatter = (idValueMap, length) => {
+	const array = Array.from({ length }).fill(false);
+	Object.entries(idValueMap).forEach(([k, v]) => {
+		array[k - 1] = v;
+	});
+	return array;
+};
+
+export const dateFormatter = timestamp => new Date(timestamp * 100);

package/src/iab/tcf/v2.0/helpers.ts

@@ -0,0 +1,23 @@
+/*
+ * TCF Amendment - 21 December 2021
+ *  Created and LastUpdated fields have been updated to have the same value
+ *  corresponding to the ** day-level ** timestamp of when the TC String
+ *  was last updated. Timestamp should maintain 36bit depth (deciseconds),
+ *  but hours, minutes, seconds and milliseconds should be 0.
+ */
+
+/**
+ * Creates a timestamp in deciseconds
+ */
+export const createUTCTimestampInDeciseconds = (
+	timestamp: number | string | Date,
+) => {
+	const consentDate = new Date(timestamp);
+	const utc = Date.UTC(
+		consentDate.getUTCFullYear(),
+		consentDate.getUTCMonth(),
+		consentDate.getUTCDate(),
+	);
+	// Make sure the timestamp is > 0 otherwise the TCF Int parser fails
+	return Math.round(Math.max(0, utc) / 100);
+};

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

@@ -0,0 +1,36 @@
+import {
+	apiName,
+	iframeName,
+	initOptions as tcfeuv2InitOptions,
+} from './tcfeuv2-constants';
+
+import makeCreateMiddleware from './middleware';
+import makeReducer from './reducer';
+import makeTcfcav1Api from '../tcfcav1-api';
+import makeTcfeuv2Api from '../tcfeuv2-api';
+import postMessageEventHandler from '../../iframe';
+import { initOptions as tcfcav1InitOptions } from './tcfcav1-constants';
+
+/**
+ * TCF-Canada v1 is nearly identical to TCF-EU v2, just with a few fields left
+ * out and some renamed. As such, it makes use of the same state data as
+ * tcfeuv2, so there is an implicit dependency on tcfeuv2's reducer.
+ */
+
+const tcfeuv2 = {
+	api: makeTcfeuv2Api(tcfeuv2InitOptions),
+	apiName,
+	createMiddleware: makeCreateMiddleware(tcfeuv2InitOptions),
+	gppSection: tcfeuv2InitOptions.gppSection,
+	iframeName,
+	postMessageEventHandler: postMessageEventHandler(apiName, true),
+	reducer: makeReducer(tcfeuv2InitOptions),
+};
+
+const tcfcav1 = {
+	api: makeTcfcav1Api(tcfcav1InitOptions),
+	createMiddleware: makeCreateMiddleware(tcfcav1InitOptions),
+	gppSection: tcfcav1InitOptions.gppSection,
+};
+
+export default { tcfeuv2, tcfcav1 };

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

@@ -0,0 +1,72 @@
+import { makeConsentFromOptions, makeFormatConsentString } from '../consent';
+
+import { types as ActionTypes } from '../../../redux/actions';
+import { CMPEventStatus } from '../constants';
+import { setConsentData } from '../../actions';
+
+export default function makeCreateMiddleware(initOptions) {
+	const consentFromOptions = makeConsentFromOptions(initOptions);
+	const formatConsentString = makeFormatConsentString(initOptions);
+
+	const { gppSection } = initOptions;
+
+	return ({ dispatchEvent } = {}) =>
+		store =>
+		next =>
+		action => {
+			const result = next(action);
+			const { type, payload } = action;
+			const state = store.getState();
+			switch (type) {
+				case ActionTypes.ready: {
+					if (dispatchEvent && payload === 'consent') {
+						const consent = consentFromOptions({}, state);
+						const consentString = formatConsentString(consent, state);
+						dispatchEvent({
+							...consent,
+							tcString: consentString,
+						});
+					}
+					break;
+				}
+				case ActionTypes.showDialog:
+				case ActionTypes.showDoNotSell:
+				case ActionTypes.showDrawer: {
+					const consent = consentFromOptions({}, state);
+					consent.eventStatus = CMPEventStatus.CMP_UI_SHOWN;
+					const consentString = formatConsentString(consent, state);
+					dispatchEvent &&
+						dispatchEvent({
+							...consent,
+							tcString: consentString,
+						});
+					break;
+				}
+				case ActionTypes.saveConsent: {
+					const consent = consentFromOptions({}, state);
+					consent.eventStatus = CMPEventStatus.USER_ACTION_COMPLETE;
+					const consentString = formatConsentString(consent, state);
+					store.dispatch(setConsentData(gppSection, consentString));
+					dispatchEvent &&
+						dispatchEvent({
+							...consent,
+							tcString: consentString,
+						});
+					break;
+				}
+				case ActionTypes.clearConsent: {
+					const consent = consentFromOptions({}, state);
+					consent.eventStatus = CMPEventStatus.USER_ACTION_COMPLETE;
+					const consentString = formatConsentString(consent, state);
+					store.dispatch(setConsentData(gppSection, consentString));
+					dispatchEvent &&
+						dispatchEvent({
+							...consent,
+							tcString: consentString,
+						});
+					break;
+				}
+			}
+			return result;
+		};
+}