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

package/src/iab/gpp/constants.js

@@ -0,0 +1,49 @@
+// Comment-out the sections that we do not implement as they aren't necessary
+// for functionality.
+export const SECTIONS = {
+	// tcfeuv1: 1,
+	tcfeuv2: 2,
+	// GPP header section is ID 3
+	// GPP signal integrity section is ID 4
+	tcfcav1: 5,
+	uspv1: 6,
+	// usnatv1: 7,
+	// uscav1: 8,
+	// usvav1: 9,
+	// uscov1: 10,
+	// usutv1: 11,
+	// usctv1: 12,
+};
+
+/**
+ * GPP's defined CMP status codes
+ * @enum {string}
+ */
+export const CmpStatusCodes = {
+	STUB: 'stub',
+	LOADED: 'loaded',
+	ERROR: 'error',
+};
+
+/**
+ * GPP's defined CMP display status codes
+ * @enum {string}
+ */
+export const CmpDisplayStatusCodes = {
+	VISIBLE: 'visible',
+	HIDDEN: 'hidden',
+	DISABLED: 'disabled',
+};
+
+/**
+ * The GPP API's events
+ * @enum {string}
+ */
+export const EventNames = {
+	LISTENER_REGISTERED: 'listenerRegistered',
+	LISTENER_REMOVED: 'listenerRemoved',
+	CMP_STATUS_CHANGED: 'cmpStatus',
+	CMP_DISPLAY_STATUS_CHANGED: 'cmpDisplayStatus',
+	ERROR: 'error',
+	SECTION_CHANGED: 'sectionChange',
+};

package/src/iab/gpp/encoders/AbstractBase64UrlEncoder.ts

@@ -0,0 +1,89 @@
+/**
+ * Adapted from IABTechLab's GPP JavaScript Reference Implementation
+ *
+ * https://github.com/IABTechLab/iabgpp-es/blob/42060d7ac2b6d0ee70fc1b5bcd33fc447bf5123c/modules/cmpapi/src/encoder/datatype/encoder/AbstractBase64UrlEncoder.ts
+ *
+ * @license
+ * Copyright 2023 IABTechLab
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+import { InvalidBase64UrlError, InvalidBitStringError } from './errors';
+import {
+	decode as intDecode,
+	encode as intEncode,
+} from './FixedIntegerEncoder';
+
+/**
+ * Base 64 URL character set. Different from standard Base64 char set in that
+ * '+' and '/' are replaced with '-' and '_'.
+ */
+const DICT = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_';
+// prettier-ignore
+const REVERSE_DICT: Record<string,number> = Object.freeze({
+    0: 52, 1: 53, 2: 54, 3: 55, 4: 56, 5: 57, 6: 58, 7: 59, 8: 60, 9: 61, A: 0,
+    B: 1, C: 2, D: 3, E: 4, F: 5, G: 6, H: 7, I: 8, J: 9, K: 10, L: 11, M: 12,
+    N: 13, O: 14, P: 15, Q: 16, R: 17, S: 18, T: 19, U: 20, V: 21, W: 22, X: 23,
+    Y: 24, Z: 25, a: 26, b: 27, c: 28, d: 29, e: 30, f: 31, g: 32, h: 33, i: 34,
+    j: 35, k: 36, l: 37, m: 38, n: 39, o: 40, p: 41, q: 42, r: 43, s: 44, t: 45,
+    u: 46, v: 47, w: 48, x: 49, y: 50, z: 51, '-': 62, _: 63,
+});
+
+export const makeEncode =
+	(pad: (str: string) => string) => (bitString: string) => {
+		// should only be 0 or 1
+		if (!/^[01]*$/.test(bitString)) {
+			throw new InvalidBitStringError(bitString);
+		}
+
+		bitString = pad(bitString);
+
+		let str = '';
+
+		let index = 0;
+		while (index <= bitString.length - 6) {
+			const s = bitString.substring(index, index + 6);
+			const n = intDecode(s);
+			const c = DICT.charAt(n);
+			str += c;
+
+			index += 6;
+		}
+
+		return str;
+	};
+
+export const decode = (str: string) => {
+	// should contain only characters from the base64url set
+	if (!/^[A-Za-z0-9\-_]*$/.test(str)) {
+		throw new InvalidBase64UrlError(str);
+	}
+
+	let bitString = '';
+
+	for (let i = 0; i < str.length; i++) {
+		const c = str.charAt(i);
+
+		const n = REVERSE_DICT[`${c}`]!;
+		const s = intEncode(n, 6);
+		bitString += s;
+	}
+
+	return bitString;
+};
+
+export default {
+	decode,
+	makeEncode,
+};

package/src/iab/gpp/encoders/BooleanEncoder.ts

@@ -0,0 +1,39 @@
+/**
+ * Adapted from IABTechLab's GPP JavaScript Reference Implementation
+ *
+ * https://github.com/IABTechLab/iabgpp-es/blob/42060d7ac2b6d0ee70fc1b5bcd33fc447bf5123c/modules/cmpapi/src/encoder/datatype/encoder/BooleanEncoder.ts
+ *
+ * @license
+ * Copyright 2023 IABTechLab
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+/**
+ * encode a TCString boolean
+ */
+export const encode = (bool: boolean) => {
+	return bool ? '1' : '0';
+};
+/**
+ * decode a TCString boolean
+ */
+export const decode = (bitString: string) => {
+	// fewer operations than !!parseInt(value, 2)
+	return bitString === '1';
+};
+
+export default {
+	decode,
+	encode,
+};

package/src/iab/gpp/encoders/CompressedBase64UrlEncoder.ts

@@ -0,0 +1,41 @@
+/**
+ * Adapted from IABTechLab's GPP JavaScript Reference Implementation
+ *
+ * https://github.com/IABTechLab/iabgpp-es/blob/42060d7ac2b6d0ee70fc1b5bcd33fc447bf5123c/modules/cmpapi/src/encoder/datatype/encoder/CompressedBase64UrlEncoder.ts
+ *
+ * @license
+ * Copyright 2023 IABTechLab
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+import { decode, makeEncode } from './AbstractBase64UrlEncoder';
+
+const pad = (bitString: string) => {
+	while (bitString.length % 8 > 0) {
+		bitString += '0';
+	}
+	while (bitString.length % 6 > 0) {
+		bitString += '0';
+	}
+	return bitString;
+};
+
+export const encode = makeEncode(pad);
+
+export { decode } from './AbstractBase64UrlEncoder';
+
+export default {
+	decode,
+	encode,
+};

package/src/iab/gpp/encoders/DatetimeEncoder.ts

@@ -0,0 +1,46 @@
+/**
+ * Adapted from IABTechLab's GPP JavaScript Reference Implementation
+ *
+ * https://github.com/IABTechLab/iabgpp-es/blob/42060d7ac2b6d0ee70fc1b5bcd33fc447bf5123c/modules/cmpapi/src/encoder/datatype/encoder/DatetimeEncoder.ts
+ *
+ * @license
+ * Copyright 2023 IABTechLab
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+import {
+	decode as intDecode,
+	encode as intEncode,
+} from './FixedIntegerEncoder';
+
+export const encode = (date: Date | number, numBits: number = 36) => {
+	let deciseconds: number;
+	if (date instanceof Date) {
+		deciseconds = Math.round(date.getTime() / 100);
+	} else {
+		deciseconds = date;
+	}
+	return intEncode(deciseconds, numBits);
+};
+
+export const decode = (bitString: string) => {
+	const date = new Date(intDecode(bitString) * 100);
+
+	return date;
+};
+
+export default {
+	decode,
+	encode,
+};

package/src/iab/gpp/encoders/EncodableOptimizedFixedRange.ts

@@ -0,0 +1,213 @@
+// This is our own implementation but is analogous to
+// https://github.com/IABTechLab/iabgpp-es/blob/42060d7ac2b6d0ee70fc1b5bcd33fc447bf5123c/modules/cmpapi/src/encoder/datatype/EncodableOptimizedFixedRange.ts
+
+import BooleanEncoder from './BooleanEncoder';
+import { default as FixedIdBitMapEncoder } from './FixedIdBitMapEncoder';
+import IntEncoder from './FixedIntegerEncoder';
+
+export const BitLength = {
+	encodingType: 1,
+	maxId: 16,
+	numEntries: 12,
+	singleOrRange: 1,
+	vendorId: 16,
+};
+
+const HEADER_LENGTH = BitLength.maxId + BitLength.encodingType;
+const RANGE_MINIMUM_LENGTH =
+	BitLength.vendorId + BitLength.singleOrRange + BitLength.numEntries;
+
+const ENCODING_TYPE = {
+	FIELD: 0,
+	RANGE: 1,
+};
+
+const buildRangeEncoding = (ranges: (number | string)[][]) => {
+	// describe the number of entries to follow
+	const numEntries = ranges.length;
+	let rangeString = IntEncoder.encode(numEntries, BitLength.numEntries);
+
+	// each range
+	ranges.forEach((range /*: number[]*/) => {
+		// is this range a single?
+		const single = range.length === 1;
+
+		// first is the indicator of whether this is a single id or range (two)
+		// 0 is single and range is 1
+		rangeString += BooleanEncoder.encode(!single);
+
+		// second is the first (or only) vendorId
+		rangeString += IntEncoder.encode(`${range[0]}`, BitLength.vendorId);
+
+		if (!single) {
+			// add the second id if it exists
+			rangeString += IntEncoder.encode(`${range[1]}`, BitLength.vendorId);
+		}
+	});
+
+	return rangeString;
+};
+
+const encode = (value: Record<number, boolean>) => {
+	// Filter out any falsey values and convert the keys to numbers
+	const vendorIds = Object.entries(value)
+		.filter(([, v]) => !!v)
+		.map(([id]) => {
+			const parsedId = parseInt(id, 10);
+			if (isNaN(parsedId) || parsedId < 1 || /^\d+$/.test(id) === false) {
+				throw new Error(`Invalid vendor ID: ${id}`);
+			}
+			return parsedId;
+		});
+	const vendorSet = new Set(vendorIds);
+	const maxId = Math.max(0, ...vendorIds);
+	// collectors for range encoding
+	const ranges = []; // : number[][]
+	let range = []; // : number[]
+
+	// bit field will be just the encoded value of the ID corresponding to the
+	// position in the bit field
+	let bitField = '';
+	// A range is a minimum of 29 bits, so if the max vendor ID in this value
+	// is less than that then we know that a bitfield encoding will be shorter
+	// than any range encoding.
+	let rangeIsSmaller = maxId > RANGE_MINIMUM_LENGTH;
+
+	const bitFieldLength = HEADER_LENGTH + maxId;
+
+	// grows as we add to the range
+	let rangeLength = HEADER_LENGTH + BitLength.numEntries;
+
+	for (let vendorId = 1; vendorId <= maxId; vendorId++) {
+		const vendorIsOn = vendorSet.has(vendorId);
+
+		// build our bitfield no matter what
+		bitField += BooleanEncoder.encode(vendorIsOn);
+
+		// For each vendor ID up to maxId, we're re-evaluating whether the range
+		// grows larger than the bitfield. If it does, we'll abandon building
+		// the range
+		rangeIsSmaller = rangeIsSmaller && rangeLength < bitFieldLength;
+		if (rangeIsSmaller && vendorIsOn) {
+			const isEndOfRange = !vendorSet.has(vendorId + 1);
+			if (isEndOfRange) {
+				range.push(vendorId);
+
+				// add to the range length the additional vendorId
+				rangeLength += BitLength.vendorId;
+
+				// store the array in our bigger array
+				ranges.push(range);
+
+				// clear the array for the next range
+				range = [];
+			} else if (range.length === 0) {
+				// this is the first  value for this range
+				range.push(vendorId);
+
+				// update our count with new range overhead
+				rangeLength += BitLength.singleOrRange;
+				rangeLength += BitLength.vendorId;
+			}
+		}
+	}
+
+	rangeIsSmaller = rangeIsSmaller && rangeLength < bitFieldLength;
+
+	// since both encodings need the maxId, start with that
+	const encodedMaxId = IntEncoder.encode(maxId, BitLength.maxId);
+	return (
+		encodedMaxId +
+		(rangeIsSmaller
+			? ENCODING_TYPE.RANGE.toString() + buildRangeEncoding(ranges)
+			: ENCODING_TYPE.FIELD.toString() + bitField)
+	);
+};
+
+const decode = (bitString: string) => {
+	if (!bitString) {
+		return { bitLength: 0, value: {} };
+	}
+	let index = 0;
+
+	const maxId = IntEncoder.decode(
+		bitString.substr(index, BitLength.maxId),
+		BitLength.maxId,
+	);
+	index += BitLength.maxId;
+	const encodingType = IntEncoder.decode(
+		bitString.charAt(index),
+		BitLength.encodingType,
+	);
+	index += BitLength.encodingType;
+
+	/**
+	 * Range is handled in batches so we'll need a different decoding scheme
+	 */
+	if (encodingType === ENCODING_TYPE.RANGE) {
+		const vendorIds = new Set();
+
+		const numEntries = IntEncoder.decode(
+			bitString.substr(index, BitLength.numEntries),
+			BitLength.numEntries,
+		);
+
+		index += BitLength.numEntries;
+
+		// loop through each group of entries
+		for (let i = 0; i < numEntries; i++) {
+			// Ranges can represent a single id or a range of ids.
+			const isIdRange = BooleanEncoder.decode(bitString.charAt(index));
+
+			index += BitLength.singleOrRange;
+
+			/**
+			 * regardless of whether or not it's a single entry or range, the next
+			 * set of bits is a vendor ID
+			 */
+			const firstId = IntEncoder.decode(
+				bitString.substr(index, BitLength.vendorId),
+				BitLength.vendorId,
+			);
+
+			index += BitLength.vendorId;
+
+			// if it's a range, the next set of bits is the second id
+			if (isIdRange) {
+				const secondId = IntEncoder.decode(
+					bitString.substr(index, BitLength.vendorId),
+					BitLength.vendorId,
+				);
+
+				index += BitLength.vendorId;
+
+				// we'll need to set or unset all the vendor ids between the first and second
+				for (let j = firstId; j <= secondId; j++) {
+					vendorIds.add(j);
+				}
+			} else {
+				vendorIds.add(firstId);
+			}
+		}
+
+		const decodedValue: Record<number, boolean> = {};
+		for (let vendorId = 1; vendorId <= maxId; vendorId++) {
+			decodedValue[vendorId] = vendorIds.has(vendorId);
+		}
+		return { bitLength: index, value: decodedValue };
+	}
+
+	// Bitfield decoding
+	const bitField = bitString.substr(index, maxId);
+
+	index += maxId;
+	return {
+		bitLength: index,
+		value: FixedIdBitMapEncoder.decode(bitField, maxId),
+	};
+};
+
+export default {
+	decode,
+	encode,
+};

package/src/iab/gpp/encoders/FibonacciIntegerEncoder.ts

@@ -0,0 +1,81 @@
+/**
+ * Adapted from IABTechLab's GPP JavaScript Reference Implementation
+ *
+ * https://github.com/IABTechLab/iabgpp-es/blob/42060d7ac2b6d0ee70fc1b5bcd33fc447bf5123c/modules/cmpapi/src/encoder/datatype/encoder/FibonacciIntegerEncoder.ts
+ *
+ * @license
+ * Copyright 2023 IABTechLab
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+export const encode = (value: number) => {
+	const fib = [];
+	if (value >= 1) {
+		fib.push(1);
+
+		if (value >= 2) {
+			fib.push(2);
+
+			let i = 2;
+			while (value >= fib[i - 1]! + fib[i - 2]!) {
+				fib.push(fib[i - 1]! + fib[i - 2]!);
+				i++;
+			}
+		}
+	}
+
+	let bitString = '1';
+	for (let i = fib.length - 1; i >= 0; i--) {
+		const f = fib[i]!;
+		if (value >= f) {
+			bitString = '1' + bitString;
+			value -= f;
+		} else {
+			bitString = '0' + bitString;
+		}
+	}
+
+	return bitString;
+};
+
+export const decode = (bitString: string) => {
+	if (!/^[01]*11$/.test(bitString)) {
+		throw new Error('Invalid bit string');
+	}
+
+	let value = 0;
+
+	const fib: number[] = [];
+	for (let i = 0; i < bitString.length - 1; i++) {
+		if (i === 0) {
+			fib.push(1);
+		} else if (i === 1) {
+			fib.push(2);
+		} else {
+			fib.push(fib[i - 1]! + fib[i - 2]!);
+		}
+	}
+
+	for (let i = 0; i < bitString.length - 1; i++) {
+		if (bitString.charAt(i) === '1') {
+			value += fib[i]!;
+		}
+	}
+	return value;
+};
+
+export default {
+	decode,
+	encode,
+};

package/src/iab/gpp/encoders/FibonacciIntegerRangeEncoder.ts

@@ -0,0 +1,122 @@
+/**
+ * Adapted from IABTechLab's GPP JavaScript Reference Implementation
+ *
+ * https://github.com/IABTechLab/iabgpp-es/blob/42060d7ac2b6d0ee70fc1b5bcd33fc447bf5123c/modules/cmpapi/src/encoder/datatype/encoder/FibonacciIntegerRangeEncoder.ts
+ *
+ * @license
+ * Copyright 2023 IABTechLab
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+import {
+	decode as fibIntDecode,
+	encode as fibIntEncode,
+} from './FibonacciIntegerEncoder';
+import {
+	decode as intDecode,
+	encode as intEncode,
+} from './FixedIntegerEncoder';
+
+import { decode as boolDecode } from './BooleanEncoder';
+
+export const encode = (value: number[]) => {
+	value = value.sort((n1, n2) => n1 - n2);
+
+	const groups = [];
+
+	let offset = 0;
+	let groupStartIndex = 0;
+	while (groupStartIndex < value.length) {
+		let groupEndIndex = groupStartIndex;
+		while (
+			groupEndIndex < value.length - 1 &&
+			value[groupEndIndex]! + 1 === value[groupEndIndex + 1]
+		) {
+			groupEndIndex++;
+		}
+
+		groups.push(value.slice(groupStartIndex, groupEndIndex + 1));
+
+		groupStartIndex = groupEndIndex + 1;
+	}
+
+	let bitString = intEncode(groups.length, 12);
+	for (let i = 0; i < groups.length; i++) {
+		const group = groups[i]!;
+		if (group.length > 0) {
+			const startInt = group[0]!;
+			if (groups.length === 1) {
+				const v = startInt - offset;
+				offset = startInt;
+				bitString += '0' + fibIntEncode(v);
+			} else {
+				const startVal = startInt - offset;
+				offset = startInt;
+				const endInt = group[group.length - 1]!;
+				const endVal = endInt - offset;
+				offset = endInt;
+				bitString += '1' + fibIntEncode(startVal) + fibIntEncode(endVal);
+			}
+		}
+	}
+	return bitString;
+};
+
+export const decode = (bitString: string) => {
+	if (!/^[01]{12,}$/.test(bitString)) {
+		throw new Error('invalid bit string');
+	}
+
+	const value = [];
+	const count = intDecode(bitString.substring(0, 12));
+
+	let offset = 0;
+	let startIndex = 12;
+	for (let i = 0; i < count; i++) {
+		const group = boolDecode(bitString.substring(startIndex, startIndex + 1));
+		startIndex++;
+
+		if (group === true) {
+			let index = bitString.indexOf('11', startIndex);
+			const start =
+				fibIntDecode(bitString.substring(startIndex, index + 2)) + offset;
+			offset = start;
+			startIndex = index + 2;
+
+			index = bitString.indexOf('11', startIndex);
+			const end =
+				fibIntDecode(bitString.substring(startIndex, index + 2)) + offset;
+			offset = end;
+			startIndex = index + 2;
+
+			for (let j = start; j <= end; j++) {
+				value.push(j);
+			}
+		} else {
+			const index = bitString.indexOf('11', startIndex);
+			const val =
+				fibIntDecode(bitString.substring(startIndex, index + 2)) + offset;
+			offset = val;
+			value.push(val);
+			startIndex = index + 2;
+		}
+	}
+
+	return value;
+};
+
+export default {
+	decode,
+	encode,
+};