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

package/src/iab/gpp/constants.js

@@ -1,49 +0,0 @@
-// 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

@@ -1,89 +0,0 @@
-/**
- * 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

@@ -1,39 +0,0 @@
-/**
- * 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

@@ -1,41 +0,0 @@
-/**
- * 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

@@ -1,46 +0,0 @@
-/**
- * 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

@@ -1,213 +0,0 @@
-// 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

@@ -1,81 +0,0 @@
-/**
- * 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

@@ -1,122 +0,0 @@
-/**
- * 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,
-};