@osano/osano-cmp-react-native 0.9.0 → 0.10.0

package/lib/typescript/src/iab/gpp/selectors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"selectors.d.ts","sourceRoot":"","sources":["../../../../../src/iab/gpp/selectors.js"],"names":[],"mappings":"AAIO,iDAC2D;AAC3D,uDAOL;AACK,mDACuD;AACvD,uEAEM;AACN,gEACgD"}

package/lib/typescript/src/iab/gpp/types.d.ts

@@ -0,0 +1,3 @@
+export type Gpp = unknown;
+export type Gpp_v2 = Gpp;
+//# sourceMappingURL=types.d.ts.map

package/lib/typescript/src/iab/gpp/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../src/iab/gpp/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,GAAG,GAAG,OAAO,CAAC;AAE1B,MAAM,MAAM,MAAM,GAAG,GAAG,CAAC"}

package/lib/typescript/src/iab/gpp/v1/constants.d.ts

@@ -0,0 +1,9 @@
+export const apiName: "__gpp";
+export const gppSection: "gpp";
+export const iframeName: "__gppLocator";
+export const version: "1.0";
+export namespace initOptions {
+    export { gppSection };
+    export { version };
+}
+//# sourceMappingURL=constants.d.ts.map

package/lib/typescript/src/iab/gpp/v1/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../../../../src/iab/gpp/v1/constants.js"],"names":[],"mappings":"AAAA,8BAA+B;AAE/B,+BAAgC;AAChC,wCAAyC;AACzC,4BAA6B"}

package/lib/typescript/src/iab/gpp/v1/index.d.ts

@@ -0,0 +1,19 @@
+export function createMiddleware({ dispatchEvent }?: {
+    dispatchEvent: any;
+}): (store: any) => (next: any) => (action: any) => any;
+export default v1;
+declare namespace v1 {
+    export let api: {
+        bind: (store: any, allApis: any) => (command: any, callback: any, parameter: any) => any;
+        dispatch: (data: any) => void;
+    };
+    export { apiName };
+    export { createMiddleware };
+    export { gppSection };
+    export { iframeName };
+    export let postMessageEventHandler: any;
+}
+import { apiName } from './constants';
+import { gppSection } from './constants';
+import { iframeName } from './constants';
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/src/iab/gpp/v1/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/iab/gpp/v1/index.js"],"names":[],"mappings":"AAYA;;wDAiDC;;;;;;;;;;;;;wBA7D4D,aAAa;2BAAb,aAAa;2BAAb,aAAa"}

package/lib/typescript/src/iab/usp/api.d.ts

@@ -0,0 +1,4 @@
+export default function makeApi(initOptions: any): {
+    bind: (store: any) => (command: string, version: number, callback: requestCallback, parameter?: string | undefined) => any;
+};
+//# sourceMappingURL=api.d.ts.map

package/lib/typescript/src/iab/usp/api.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"api.d.ts","sourceRoot":"","sources":["../../../../../src/iab/usp/api.js"],"names":[],"mappings":"AAEA;oCAMa,MAAM,WACN,MAAM,YACN,eAAe;EA6C3B"}

package/lib/typescript/src/iab/usp/consent.d.ts

@@ -0,0 +1,13 @@
+export function makeParseConsentString({ version: providedVersion }?: {
+    version?: number | undefined;
+}): (uspString: any) => {
+    version: any;
+    notified: any;
+    signatory: any;
+    optOut: any;
+};
+export function makeGetField(initOptions?: {}): (state: any, field: any) => string | 1 | undefined;
+export function makeFormatConsentString(initOptions?: {}): string;
+export function makeConsentFromOptions(initOptions: any): import("./constants").USPConsent;
+export function getConsentDataObject(initOptions: any): import("./constants").USPData;
+//# sourceMappingURL=consent.d.ts.map

package/lib/typescript/src/iab/usp/consent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"consent.d.ts","sourceRoot":"","sources":["../../../../../src/iab/usp/consent.js"],"names":[],"mappings":"AAKO;;;;;;;EAqBL;AAEK,mGAsBL;AAQK,2DAFM,MAAM,CA8BjB;AAQK,0DAFM,OAAO,aAAa,EAAE,UAAU,CA6B5C;AAQM,wDAFM,OAAO,aAAa,EAAE,OAAO,CAsBzC"}

package/lib/typescript/src/iab/usp/constants.d.ts

@@ -0,0 +1,77 @@
+export function toYesNoUnFromBool(b: any): "-" | "N" | "Y";
+export function toBoolFromYesNoUn(yn: any): boolean | undefined;
+/**
+ * USPData object supplied to the __uspapi callback method
+ */
+export type USPData = {
+    /**
+     * - indicates the U.S. Privacy spec version
+     */
+    version: number;
+    /**
+     * - Indicates the privacy application and agreement
+     * - String; agreement: “1YNN”, not applicable: “1---”
+     * - Number; 1 applies, 0 doesn’t apply, -1 not set
+     */
+    uspString: (number | string);
+};
+/**
+ * USPConsent object used for creating the USPData `uspString`
+ */
+export type USPConsent = {
+    /**
+     * - indicates the U.S. Privacy spec version
+     */
+    version: number;
+    /**
+     * - Indicates that the end user has been notified of consent agreement
+     */
+    notified: (boolean | undefined);
+    /**
+     * - Indicates that the end user has opted out of data resale
+     */
+    optOut: boolean;
+    /**
+     * - Indicates that the provider has opted into the LSPA from IAB
+     */
+    signatory: (boolean | undefined);
+};
+/**
+ * USPAPIPostMessageData object
+ */
+export type USPAPIPostMessageData = {
+    /**
+     * - The command to be executed by the API
+     */
+    command: string;
+    /**
+     * - Optional parameter to be passed to the `command`
+     */
+    parameter: string;
+    /**
+     * - The version number that the response should adhere to
+     */
+    version: number;
+    /**
+     * - The callback method that should be called with the command result
+     */
+    callId: string;
+};
+/**
+ * USPAPIPostMessageEvent object supplied to the __uspapiLocator iframe postMessage handler
+ */
+export type USPAPIPostMessageEvent = {
+    /**
+     * - The post message data as object or JSON string
+     */
+    data: (string | USPAPIPostMessageData);
+    /**
+     * - Indicates the origin of the window making the post
+     */
+    origin: string;
+    /**
+     * - The window which posted the message
+     */
+    source: Window;
+};
+//# sourceMappingURL=constants.d.ts.map

package/lib/typescript/src/iab/usp/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../../../src/iab/usp/constants.js"],"names":[],"mappings":"AAmCO,2DAAsE;AACtE,gEAGkC;;;;;;;;aApC3B,MAAM;;;;;;eACN,CAAC,MAAM,GAAC,MAAM,CAAC;;;;;;;;;aAQf,MAAM;;;;cACN,CAAC,UAAQ,SAAS,CAAC;;;;;;;;eAEnB,CAAC,UAAQ,SAAS,CAAC;;;;;;;;;aAMnB,MAAM;;;;eACN,MAAM;;;;aACN,MAAM;;;;YACN,MAAM;;;;;;;;;UAMN,CAAC,MAAM,GAAC,qBAAqB,CAAC;;;;YAC9B,MAAM;;;;YACN,MAAM"}

package/lib/typescript/src/iab/usp/index.d.ts

@@ -0,0 +1,10 @@
+declare namespace _default {
+    export { reducer };
+    export namespace versions {
+        export { v1_0 };
+    }
+}
+export default _default;
+import reducer from './reducer';
+import v1_0 from './v1';
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/src/iab/usp/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/iab/usp/index.js"],"names":[],"mappings":";;;;;;;oBAAoB,WAAW;iBACd,MAAM"}

package/lib/typescript/src/iab/usp/reducer.d.ts

@@ -0,0 +1,13 @@
+export namespace initialState {
+    namespace iab {
+        namespace usp {
+            let ccpaApplies: boolean;
+            let notified: undefined;
+            let signatory: undefined;
+            let optOut: boolean;
+        }
+    }
+}
+declare const _default: any;
+export default _default;
+//# sourceMappingURL=reducer.d.ts.map

package/lib/typescript/src/iab/usp/reducer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reducer.d.ts","sourceRoot":"","sources":["../../../../../src/iab/usp/reducer.js"],"names":[],"mappings":""}

package/lib/typescript/src/iab/usp/selectors.d.ts

@@ -0,0 +1,9 @@
+export const DOMAIN: "iab.usp";
+export function getStore(state: any): any;
+export function doesCCPAApply(state: any): boolean;
+export function getConsentString(state: any, { gppSection, version: providedVersion }?: {
+    gppSection: any;
+    version: any;
+}): string;
+export function getOptOut(state: any): any;
+//# sourceMappingURL=selectors.d.ts.map

package/lib/typescript/src/iab/usp/selectors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"selectors.d.ts","sourceRoot":"","sources":["../../../../../src/iab/usp/selectors.js"],"names":[],"mappings":"AAIA,+BAAgC;AAEzB,0CAAgD;AAChD,mDACsD;AAEtD;;;WAmBN;AACM,2CAAiD"}

package/lib/typescript/src/iab/usp/types.d.ts

@@ -0,0 +1,5 @@
+export type Usp = {
+    enabled: boolean;
+    ccpaApplies: boolean;
+};
+//# sourceMappingURL=types.d.ts.map

package/lib/typescript/src/iab/usp/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../src/iab/usp/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,GAAG,GAAG;IACjB,OAAO,EAAE,OAAO,CAAC;IACjB,WAAW,EAAE,OAAO,CAAC;CACrB,CAAC"}

package/lib/typescript/src/iab/usp/v1/constants.d.ts

@@ -0,0 +1,9 @@
+export const apiName: "__uspapi";
+export const gppSection: "uspv1";
+export const iframeName: "__uspapiLocator";
+export const version: 1;
+export namespace initOptions {
+    export { gppSection };
+    export { version };
+}
+//# sourceMappingURL=constants.d.ts.map

package/lib/typescript/src/iab/usp/v1/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../../../../src/iab/usp/v1/constants.js"],"names":[],"mappings":"AAAA,iCAAkC;AAElC,iCAAkC;AAClC,2CAA4C;AAC5C,wBAAyB"}

package/lib/typescript/src/iab/usp/v1/index.d.ts

@@ -0,0 +1,16 @@
+export default v1;
+declare namespace v1 {
+    export let api: {
+        bind: (store: any) => (command: string, version: number, callback: requestCallback, parameter?: string | undefined) => any;
+    };
+    export { apiName };
+    export { createMiddleware };
+    export { gppSection };
+    export { iframeName };
+    export let postMessageEventHandler: any;
+}
+import { apiName } from './constants';
+declare function createMiddleware(): (store: any) => (next: any) => (action: any) => any;
+import { gppSection } from './constants';
+import { iframeName } from './constants';
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/src/iab/usp/v1/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/iab/usp/v1/index.js"],"names":[],"mappings":";;;2EAOQ,eAAe;;;;;;;;wBANsC,aAAa;AAY1E,yFA6BC;2BAzC4D,aAAa;2BAAb,aAAa"}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@osano/osano-cmp-react-native",
-	"version": "0.9.0",
+	"version": "0.10.0",
 	"description": "Package and example for the react-native Osano CMP SDK",
 	"main": "lib/commonjs/index",
 	"module": "lib/module/index",
@@ -24,14 +24,10 @@
 		"!**/__fixtures__",
 		"!**/__mocks__",
 		"!**/.*",
-		"!src/iab/usp",
-		"!src/iab/gpp",
 		"!lib/typescript/webdriverio-appium/**",
 		"!lib/typescript/webdriverio-appium/common/**",
 		"!lib/typescript/webdriverio-appium/config/**",
-		"!lib/typescript/webdriverio-appium/test/**",
-		"!lib/typescript/src/iab/usp",
-		"!lib/typescript/src/iab/gpp"
+		"!lib/typescript/webdriverio-appium/test/**"
 	],
 	"scripts": {
 		"example": "yarn workspace osano-cmp-sdk-example",

package/src/iab/gpp/api.js

@@ -0,0 +1,253 @@
+import {
+	formatConsentString,
+	makeFormatPingData,
+	makeParseConsentString,
+} from './consent';
+
+import { EventNames } from './constants';
+import { MAX_DATE } from '../../constants';
+import { getSupportedApis } from './selectors';
+
+/**
+ * An object that contains the client callback and metadata.
+ * @typedef {Object} EventSubscriber
+ * @property {number} version - The version of the API that the subscriber is
+ * listening to.
+ * @property {function} callback - The callback function that the subscriber
+ * provided. The signature should match the API version.
+ */
+
+/**
+ * The listener ID is a number that is used to identify a subscriber. It is both
+ * a key in the eventSubscribers map and a property that is given back to the
+ * subscriber. It must not change for the lifetime of the subscriber.
+ * @typedef {number} ListenerId
+ */
+
+/**
+ * A map of listener IDs to event subscribers.
+ * @type {Map<ListenerId, EventSubscriber>}
+ */
+const eventSubscribers = new Map();
+
+// Allows us to clear the event subscribers in tests
+export const _clearEventSubscribers =
+	process.env.NODE_ENV === 'jest' ? () => eventSubscribers.clear() : undefined;
+
+const createListenerId = () => {
+	let inc = 0;
+	let listenerId = MAX_DATE - Date.now();
+	do {
+		listenerId -= inc++;
+	} while (eventSubscribers.has(listenerId));
+
+	return listenerId;
+};
+
+/**
+ * Responsible for dispatching events to the subscribers.
+ * @param {number} apiVersion  - The version of the API as defined by the IAB.
+ * @param {object} data  - The data to dispatch to the subscribers.
+ */
+const makeDispatch = apiVersion =>
+	function dispatch(data) {
+		eventSubscribers.forEach(({ version, callback }, listenerId) => {
+			apiVersion === version &&
+				callback({
+					...data,
+					listenerId,
+				});
+		});
+	};
+
+/**
+ * The GPP has its own API but it can also call the older APIs. This function
+ * adapts the newer GPP call signature to the older APIs.
+ */
+const adaptedApis = new Map();
+
+// Allows us to clear the event subscribers in tests
+export const _clearAdaptedApis =
+	process.env.NODE_ENV === 'jest' ? () => adaptedApis.clear() : undefined;
+
+const getAdaptedApi = (clientApi, api) => {
+	// cache the adapted API so that we aren't creating a new function on every call
+	const adaptedApi = adaptedApis.get(clientApi);
+	if (adaptedApi) {
+		return adaptedApi;
+	}
+
+	// If the API is not available, throw an error. If the requested API is the
+	// GPP, throw an error (the GPP should never call itself as a sub-API).
+	if (!api || clientApi === 'gpp') {
+		throw new Error(`API ${clientApi} is not available`);
+	}
+
+	switch (clientApi) {
+		// pre-GPP APIs use the signature (command, version, callback, parameter)
+		case 'tcfeuv2':
+			adaptedApis.set(clientApi, (command, callback, parameter) =>
+				api(command, 2, callback, parameter),
+			);
+			break;
+		case 'uspv1':
+			adaptedApis.set(clientApi, (command, callback, parameter) =>
+				api(command, 1, callback, parameter),
+			);
+			break;
+		default:
+			adaptedApis.set(clientApi, api);
+	}
+
+	return adaptedApis.get(clientApi);
+};
+
+export default function makeApi(initOptions) {
+	const formatPingData = makeFormatPingData(initOptions);
+	const parseConsentString = makeParseConsentString(initOptions);
+	const makeEventSubscriber = callback => ({
+		version: initOptions.version,
+		callback,
+	});
+	const eventListenerReturn = (state, eventName, listenerId, data) => ({
+		eventName,
+		listenerId,
+		data,
+		pingData: formatPingData(state),
+	});
+	const dispatch = makeDispatch(initOptions.version);
+
+	function bind(store, allApis) {
+		const subApiSubscribers = new Map();
+		// The GPP spec says that events dispatched from section APIs should be
+		// dispatched from the GPP API. To do that, we'll subscribe to the
+		// events from the other APIs and re-dispatch them from here.
+		const initDispatchAggregator = () => {
+			if (subApiSubscribers.size > 0) {
+				// We have already initialized the dispatch aggregator
+				return;
+			}
+
+			const supportedApis = getSupportedApis(store.getState());
+			allApis.forEach((api, section) => {
+				if (!supportedApis.includes(section)) {
+					return;
+				}
+
+				const subscriber = data => {
+					// remove our own listener ID from the data object
+					// eslint-disable-next-line @typescript-eslint/no-unused-vars
+					const { listenerId, ...rest } = data;
+
+					dispatch({
+						// Other APIs don't currently have event names but if
+						// they are added this field should be dot-separated,
+						// e.g. `${section}.${data.eventName}`
+						eventName: section,
+						data: rest,
+						pingData: formatPingData(store.getState()),
+					});
+				};
+				subApiSubscribers.set(section, subscriber);
+				getAdaptedApi(section, api)('addEventListener', subscriber);
+			});
+		};
+
+		return function gppApi(command, callback, parameter) {
+			const state = store.getState();
+
+			switch (command) {
+				case 'ping': {
+					return formatPingData(state);
+				}
+
+				case 'addEventListener': {
+					// We wait to initialize the dispatch aggregator until there
+					// is at least one client event listener. Saves a little
+					// performance and ensures that all APIs are available.
+					initDispatchAggregator();
+					const listenerId = createListenerId();
+
+					try {
+						if (typeof callback !== 'function') {
+							throw new Error('Callback must be a function');
+						}
+						eventSubscribers.set(listenerId, makeEventSubscriber(callback));
+						const returnObject = eventListenerReturn(
+							state,
+							EventNames.LISTENER_REGISTERED,
+							listenerId,
+							true,
+						);
+
+						return returnObject;
+					} catch {
+						eventSubscribers.delete(listenerId);
+						return eventListenerReturn(
+							state,
+							EventNames.LISTENER_REGISTERED,
+							0,
+							false,
+						);
+					}
+				}
+
+				case 'removeEventListener': {
+					const listenerId = parseInt(parameter, 10);
+					const removed = eventSubscribers.delete(listenerId);
+					return eventListenerReturn(
+						state,
+						EventNames.LISTENER_REMOVED,
+						listenerId,
+						removed,
+					);
+				}
+
+				case 'hasSection': {
+					const section = parameter;
+					return getSupportedApis(state).includes(`${section}`);
+				}
+
+				/** Note that this command throws if the requested section
+				 * doesn't exist. The spec does not define what should happen in
+				 * this case. Returning nothing could be misleading so an error
+				 * is clearer. */
+				case 'getSection': {
+					const clientApi = parameter;
+					const sectionApi = getAdaptedApi(clientApi, allApis.get(clientApi));
+					return sectionApi('getSection');
+				}
+
+				/** Note that as above, this command throws if the requested
+				 * section does not exist and returns undefined if the field
+				 * doesn't exist. The spec is again silent on this case. */
+				case 'getField': {
+					const [clientApi, ...fieldPath] = parameter.split('.');
+					const sectionApi = getAdaptedApi(clientApi, allApis.get(clientApi));
+					return sectionApi('getField', undefined, fieldPath.join('.'));
+				}
+
+				case 'getGPPData': {
+					const gppString = formatConsentString(state);
+					return gppString ? parseConsentString(gppString, state) : undefined;
+				}
+
+				default: {
+					const mark = command.indexOf('.');
+					if (mark < 0) {
+						throw new Error(`Invalid command: ${command}`);
+					}
+					const clientApi = command.substring(0, mark);
+					const apiCommand = command.substring(mark + 1);
+					const sectionApi = getAdaptedApi(clientApi, allApis.get(clientApi));
+					return sectionApi(apiCommand, callback, parameter);
+				}
+			}
+		};
+	}
+
+	return {
+		bind,
+		dispatch,
+	};
+}

package/src/iab/gpp/consent.js

@@ -0,0 +1,114 @@
+import { CmpDisplayStatusCodes, CmpStatusCodes, SECTIONS } from './constants';
+import {
+	decode as base64Decode,
+	encode as base64Encode,
+} from './encoders/CompressedBase64UrlEncoder';
+import {
+	doesGDPRApply,
+	getConsentString,
+	getSupportedApis,
+	isBrowsingFrom,
+	isUiVisible,
+} from './selectors';
+import {
+	decode as fibRangeDecode,
+	encode as fibRangeEncode,
+} from './encoders/FibonacciIntegerRangeEncoder';
+
+import { CMP_ID } from '../constants';
+
+const ERROR_MESSAGE = 'Invalid GPP string';
+
+/* A note on the GPP version number: According to the GPP spec, the GPP string's
+ * header can only contain an integer version number. However, the API spec for
+ * the PingReturn object requires that the GPP version number is in the format
+ * Major.Minor (e.g. 1.0). It's not a problem for now but will be interesting if
+ * and when they introduce a version 1.1.
+ */
+const HEADER_PREFIX = 'DB'; // Section 3 ('D'), GPP v1 ('B')
+
+export const isSectionApplicable = (sectionId, state) => {
+	switch (sectionId) {
+		// case 1 is TCF v1 and is unsupported
+		case 2: // TCF EU v2
+			return doesGDPRApply(state);
+		// cases 3 and 4 are GPP header and integrity sections and are not applicable
+		case 5: // TCF CA
+			return isBrowsingFrom(state, 'ca');
+		case 6: // USPrivacy v1
+			// case 7: // US National
+			return isBrowsingFrom(state, 'us');
+		// We do not implement the GPP US-state spec
+		// case 8: // US California
+		//     return isBrowsingFrom(state, 'us-ca');
+		// case 9: // US Virginia
+		//     return isBrowsingFrom(state, 'us-va');
+		// case 10: // US Colorado
+		//     return isBrowsingFrom(state, 'us-co');
+		// case 11: // US Utah
+		//     return isBrowsingFrom(state, 'us-ut');
+		// case 12: // US Connecticut
+		//     return isBrowsingFrom(state, 'us-ct');
+		default:
+			return false;
+	}
+};
+
+export const makeFormatPingData = initOptions => state => ({
+	gppVersion: initOptions.version, // '1.0', see note above
+	cmpStatus: CmpStatusCodes.LOADED,
+	cmpDisplayStatus: isUiVisible(state)
+		? CmpDisplayStatusCodes.VISIBLE
+		: CmpDisplayStatusCodes.HIDDEN,
+	supportedAPIs: getSupportedApis(state),
+	cmpId: CMP_ID,
+});
+
+export const makeParseConsentString = initOptions => (gppString, state) => {
+	const [header, ...sections] = gppString.split('~');
+
+	// All GPPv1 strings must start with 'DB'
+	if (header.substring(0, 2) !== HEADER_PREFIX) {
+		throw new Error(`${ERROR_MESSAGE}: Invalid header`);
+	}
+
+	const expectedSections = fibRangeDecode(base64Decode(header.substring(2)));
+
+	if (sections.length !== expectedSections.length) {
+		throw new Error(
+			`${ERROR_MESSAGE}: Number of sections does not match header`,
+		);
+	}
+
+	return {
+		sectionId: 3,
+		gppVersion: 1, // see note above
+		sectionList: expectedSections,
+		applicableSections: expectedSections.filter(sectionId =>
+			isSectionApplicable(sectionId, state),
+		),
+		gppString,
+		pingData: makeFormatPingData(initOptions)(state),
+	};
+};
+
+export const formatConsentString = state => {
+	const consentStrings = getSupportedApis(state)
+		.map(section => ({
+			sectionId: SECTIONS[`${section}`],
+			consentString: getConsentString(state, section),
+		}))
+		.filter(({ consentString }) => consentString !== undefined)
+		.sort((a, b) => a.sectionId - b.sectionId);
+
+	const header = `${HEADER_PREFIX}${base64Encode(
+		fibRangeEncode(consentStrings.map(({ sectionId }) => sectionId)),
+	)}`;
+
+	const sections = [
+		header,
+		...consentStrings.map(({ consentString }) => consentString),
+	];
+
+	return sections.join('~');
+};