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

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,
+};

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

@@ -0,0 +1,59 @@
+/**
+ * Adapted from IABTechLab's GPP JavaScript Reference Implementation
+ *
+ * https://github.com/IABTechLab/iabgpp-es/blob/42060d7ac2b6d0ee70fc1b5bcd33fc447bf5123c/modules/cmpapi/src/encoder/datatype/encoder/FixedBitfieldEncoder.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 boolDecode, encode as boolEncode } from './BooleanEncoder';
+
+import { InvalidBitStringError } from './errors';
+
+export const encode = (value: boolean[], bitStringLength: number) => {
+	let bitString = '';
+	for (let i = 0; i < value.length; i++) {
+		bitString += boolEncode(value[i]!);
+	}
+
+	// String.prototype.padEnd causes CoreJS to include a polyfill for it.
+	bitString =
+		bitString.length >= bitStringLength
+			? bitString
+			: bitString + '0'.repeat(bitStringLength - bitString.length);
+
+	return bitString;
+};
+
+export const decode = (
+	bitString: string,
+	numBits: number = bitString.length,
+) => {
+	if (!/^[01]*$/.test(bitString)) {
+		throw new InvalidBitStringError(bitString);
+	}
+
+	const value = [];
+	for (let i = 0; i < numBits; i++) {
+		value.push(boolDecode(bitString.substring(i, i + 1)));
+	}
+	return value;
+};
+
+export default {
+	decode,
+	encode,
+};

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

@@ -0,0 +1,30 @@
+// This encoder is used to encode and decode ID-to-bit/boolean maps to and from
+// fixed bitfields.It doesn't exactly have an equivalent in the GPP reference
+// implementation but the EncodableFixedBitfield class is similar.
+// https://github.com/IABTechLab/iabgpp-es/blob/42060d7ac2b6d0ee70fc1b5bcd33fc447bf5123c/modules/cmpapi/src/encoder/datatype/EncodableFixedBitfield.ts.
+// The functional difference is that it encodes from and decodes to an array of
+// booleans whereas this encoder encodes from and decodes to an object of
+// ID-to-boolean mappings.
+
+import FixedBitfieldEncoder from './FixedBitfieldEncoder';
+
+export default {
+	encode: (value: Record<number, boolean>, numBits: number) =>
+		FixedBitfieldEncoder.encode(
+			Object.entries(value || {}).reduce((acc, [key, bit]) => {
+				const id = parseInt(key, 10);
+				acc[id - 1] = bit;
+				return acc;
+			}, [] as boolean[]),
+			numBits,
+		),
+
+	decode: (bitString: string, numBits: number) =>
+		FixedBitfieldEncoder.decode(bitString, numBits).reduce(
+			(acc, value, index) => {
+				acc[index + 1] = value;
+				return acc;
+			},
+			{} as Record<number, boolean>,
+		),
+};

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

@@ -0,0 +1,61 @@
+/**
+ * Adapted from IABTechLab's GPP JavaScript Reference Implementation
+ *
+ * https://github.com/IABTechLab/iabgpp-es/blob/42060d7ac2b6d0ee70fc1b5bcd33fc447bf5123c/modules/cmpapi/src/encoder/datatype/encoder/FixedIntegerEncoder.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 { InvalidSizeError } from './errors';
+
+// We use browser native functions to encode/decode integers to/from bit strings
+// instead of the more verbose method in the reference implementation
+
+export const encode = (int: number | string, numBits: number) => {
+	let bitString;
+
+	if (typeof int === 'string') {
+		int = parseInt(int, 10);
+	}
+
+	bitString = int.toString(2);
+
+	if (bitString.length > numBits || int < 0) {
+		throw new InvalidSizeError(int, numBits);
+	}
+
+	// Pad the string if not filling all bits
+	if (bitString.length < numBits) {
+		// pad left
+		bitString = '0'.repeat(numBits - bitString.length) + bitString;
+	}
+
+	return bitString;
+};
+
+export const decode = (bitString: string, numBits?: number) => {
+	if (!bitString) {
+		// Handle falsy values
+		return 0;
+	}
+
+	return parseInt(bitString.slice(0, numBits), 2);
+};
+
+export default {
+	decode,
+	encode,
+};

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

@@ -0,0 +1,87 @@
+/**
+ * Adapted from IABTechLab's GPP JavaScript Reference Implementation
+ *
+ * https://github.com/IABTechLab/iabgpp-es/blob/42060d7ac2b6d0ee70fc1b5bcd33fc447bf5123c/modules/cmpapi/src/encoder/datatype/encoder/FixedIntegerListEncoder.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 { BitStringParametersMatchError, InvalidBitStringError } from './errors';
+import {
+	decode as intDecode,
+	encode as intEncode,
+} from './FixedIntegerEncoder';
+
+export const encode = (
+	value: number[],
+	elementBitStringLength: number,
+	numElements: number,
+) => {
+	let bitString = '';
+	for (let i = 0; i < value.length; i++) {
+		bitString += intEncode(value[i]!, elementBitStringLength);
+	}
+
+	while (bitString.length < elementBitStringLength * numElements) {
+		bitString += '0';
+	}
+
+	return bitString;
+};
+
+export const decode = (
+	bitString: string,
+	elementBitStringLength: number,
+	numElements: number,
+) => {
+	if (!/^[01]*$/.test(bitString)) {
+		throw new InvalidBitStringError(bitString);
+	}
+
+	if (
+		bitString.length > elementBitStringLength * numElements ||
+		bitString.length % elementBitStringLength !== 0
+	) {
+		throw new BitStringParametersMatchError(bitString, {
+			elementBitStringLength,
+			numElements,
+		});
+	}
+
+	while (bitString.length < elementBitStringLength * numElements) {
+		bitString += '0';
+	}
+
+	if (bitString.length > elementBitStringLength * numElements) {
+		bitString = bitString.substring(0, elementBitStringLength * numElements);
+	}
+
+	const value = [];
+	for (let i = 0; i < bitString.length; i += elementBitStringLength) {
+		value.push(intDecode(bitString.substring(i, i + elementBitStringLength)));
+	}
+
+	while (value.length < numElements) {
+		value.push(0);
+	}
+
+	return value;
+};
+
+export default {
+	decode,
+	encode,
+};