@pubtech-ai/core 1.6.0

package/lib/mjs/encoder/field/PurposeRestrictionVectorEncoder.js

@@ -0,0 +1,109 @@
+import { BitLength } from '../BitLength.js';
+import { BooleanEncoder } from './BooleanEncoder.js';
+import { DecodingError } from '../../errors/index.js';
+import { IntEncoder } from './IntEncoder.js';
+import { PurposeRestrictionVector, PurposeRestriction } from '../../model/index.js';
+export class PurposeRestrictionVectorEncoder {
+    static encode(prVector) {
+        // start with the number of restrictions
+        let bitString = IntEncoder.encode(prVector.numRestrictions, BitLength.numRestrictions);
+        // if the vector is empty we'll just return a string with just the numRestricitons being 0
+        if (!prVector.isEmpty()) {
+            // create each restriction group
+            prVector.getRestrictions().forEach((purpRestriction) => {
+                // every restriction group has the purposeId and the restrictionType;
+                bitString += IntEncoder.encode(purpRestriction.purposeId, BitLength.purposeId);
+                bitString += IntEncoder.encode(purpRestriction.restrictionType, BitLength.restrictionType);
+                // now get all the vendors under that restriction
+                const vendors = prVector.getVendors(purpRestriction);
+                const len = vendors.length;
+                /**
+                 * numEntries comes first so we will have to keep a counter and the do
+                 * the encoding at the end
+                 */
+                let numEntries = 0;
+                let startId = 0;
+                let rangeField = '';
+                for (let i = 0; i < len; i++) {
+                    const vendorId = vendors[i];
+                    if (startId === 0) {
+                        numEntries++;
+                        startId = vendorId;
+                    }
+                    // we know that `len` is greater than zero because we entered the loop
+                    const lastVendorId = vendors[len - 1];
+                    const gvlVendorIds = prVector.gvl.vendorIds;
+                    const nextGvlVendor = (vendorId) => {
+                        while (++vendorId <= lastVendorId && !gvlVendorIds.has(vendorId)) {
+                        }
+                        return vendorId;
+                    };
+                    /**
+                     * either end of the loop or there are GVL vendor IDs before the next one
+                     */
+                    if (i === len - 1 || vendors[i + 1] > nextGvlVendor(vendorId)) {
+                        /**
+                         * it's a range entry if we've got something other than the start
+                         * ID
+                         */
+                        const isRange = !(vendorId === startId);
+                        // 0 means single 1 means range
+                        rangeField += BooleanEncoder.encode(isRange);
+                        rangeField += IntEncoder.encode(startId, BitLength.vendorId);
+                        if (isRange) {
+                            rangeField += IntEncoder.encode(vendorId, BitLength.vendorId);
+                        }
+                        // reset the startId so we grab the next id in the list
+                        startId = 0;
+                    }
+                }
+                /**
+                 * now that  the range encoding is built, encode the number of ranges
+                 * and then append the range field to the bitString.
+                 */
+                bitString += IntEncoder.encode(numEntries, BitLength.numEntries);
+                bitString += rangeField;
+            });
+        }
+        return bitString;
+    }
+    static decode(encodedString) {
+        let index = 0;
+        const vector = new PurposeRestrictionVector();
+        const numRestrictions = IntEncoder.decode(encodedString.substr(index, BitLength.numRestrictions), BitLength.numRestrictions);
+        index += BitLength.numRestrictions;
+        for (let i = 0; i < numRestrictions; i++) {
+            // First is purpose ID
+            const purposeId = IntEncoder.decode(encodedString.substr(index, BitLength.purposeId), BitLength.purposeId);
+            index += BitLength.purposeId;
+            // Second Restriction Type
+            const restrictionType = IntEncoder.decode(encodedString.substr(index, BitLength.restrictionType), BitLength.restrictionType);
+            index += BitLength.restrictionType;
+            const purposeRestriction = new PurposeRestriction(purposeId, restrictionType);
+            // Num Entries (number of vendors)
+            const numEntries = IntEncoder.decode(encodedString.substr(index, BitLength.numEntries), BitLength.numEntries);
+            index += BitLength.numEntries;
+            for (let j = 0; j < numEntries; j++) {
+                const isARange = BooleanEncoder.decode(encodedString.substr(index, BitLength.anyBoolean));
+                index += BitLength.anyBoolean;
+                const startOrOnlyVendorId = IntEncoder.decode(encodedString.substr(index, BitLength.vendorId), BitLength.vendorId);
+                index += BitLength.vendorId;
+                if (isARange) {
+                    const endVendorId = IntEncoder.decode(encodedString.substr(index, BitLength.vendorId), BitLength.vendorId);
+                    index += BitLength.vendorId;
+                    if (endVendorId < startOrOnlyVendorId) {
+                        throw new DecodingError(`Invalid RangeEntry: endVendorId ${endVendorId} is less than ${startOrOnlyVendorId}`);
+                    }
+                    for (let k = startOrOnlyVendorId; k <= endVendorId; k++) {
+                        vector.add(k, purposeRestriction);
+                    }
+                }
+                else {
+                    vector.add(startOrOnlyVendorId, purposeRestriction);
+                }
+            }
+        }
+        vector.bitLength = index;
+        return vector;
+    }
+}

package/lib/mjs/encoder/field/VectorEncodingType.d.ts

@@ -0,0 +1,4 @@
+export declare enum VectorEncodingType {
+    FIELD = 0,
+    RANGE = 1
+}

package/lib/mjs/encoder/field/VectorEncodingType.js

@@ -0,0 +1,5 @@
+export var VectorEncodingType;
+(function (VectorEncodingType) {
+    VectorEncodingType[VectorEncodingType["FIELD"] = 0] = "FIELD";
+    VectorEncodingType[VectorEncodingType["RANGE"] = 1] = "RANGE";
+})(VectorEncodingType || (VectorEncodingType = {}));

package/lib/mjs/encoder/field/VendorVectorEncoder.d.ts

@@ -0,0 +1,6 @@
+import { Vector } from '../../model/index.js';
+export declare class VendorVectorEncoder {
+    static encode(value: Vector): string;
+    static decode(value: string, version?: number): Vector;
+    private static buildRangeEncoding;
+}

package/lib/mjs/encoder/field/VendorVectorEncoder.js

@@ -0,0 +1,156 @@
+import { Vector } from '../../model/index.js';
+import { BitLength } from '../index.js';
+import { IntEncoder } from './IntEncoder.js';
+import { BooleanEncoder } from './BooleanEncoder.js';
+import { FixedVectorEncoder } from './FixedVectorEncoder.js';
+import { VectorEncodingType } from './VectorEncodingType.js';
+import { DecodingError } from '../../errors/index.js';
+export class VendorVectorEncoder {
+    static encode(value) {
+        // collectors for range encoding
+        const ranges = [];
+        let range = [];
+        // since both encodings need the maxId, start with that
+        let retrString = IntEncoder.encode(value.maxId, BitLength.maxId);
+        // bit field will be just the vendors as we walk through the vector
+        let bitField = '';
+        let rangeIsSmaller;
+        // some math
+        const headerLength = BitLength.maxId + BitLength.encodingType;
+        const bitFieldLength = headerLength + value.maxId;
+        const minRangeLength = (BitLength.vendorId * 2 + BitLength.singleOrRange + BitLength.numEntries);
+        // gets larger as we walk through the vector
+        let rangeLength = headerLength + BitLength.numEntries;
+        // walk through every value in the vector
+        value.forEach((curValue, i) => {
+            // build our bitfield no matter what
+            bitField += BooleanEncoder.encode(curValue);
+            /**
+             * A range is a minimum of 45 bits, if the number of vendors in this
+             * vector is less than 45 then we know that a bitfield encoding will be
+             * shorter than any range encoding.
+             *
+             * The second check checks while we walk through the vector and abandons
+             * building the ranges once it becomes larger
+             */
+            rangeIsSmaller = (value.maxId > minRangeLength && rangeLength < bitFieldLength);
+            /**
+             * if the curValue is true and our rangeLength is less than the bitField
+             * length, we'll continue to push these ranges into the array.  Once the
+             * ranges become a larger encoding there is no reason to continue
+             * building the structure because we will be choosing the bitfield
+             * encoding
+             */
+            if (rangeIsSmaller && curValue) {
+                /**
+                 * Look ahead to see if this is the last value in our range
+                 */
+                const nextValue = value.has(i + 1);
+                // if there isn't a next value, then we'll wrap up this range
+                if (!nextValue) {
+                    /**
+                     * this is the last value of the range, so we'll push it on to the
+                     * end into position 1
+                     */
+                    range.push(i);
+                    // 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(i);
+                    // update our count with new range overhead
+                    rangeLength += BitLength.singleOrRange;
+                    rangeLength += BitLength.vendorId;
+                }
+            }
+        });
+        if (rangeIsSmaller) {
+            retrString += String(VectorEncodingType.RANGE);
+            retrString += this.buildRangeEncoding(ranges);
+        }
+        else {
+            retrString += String(VectorEncodingType.FIELD);
+            retrString += bitField;
+        }
+        return retrString;
+    }
+    static decode(value, version) {
+        let vector;
+        let index = 0;
+        const maxId = IntEncoder.decode(value.substr(index, BitLength.maxId), BitLength.maxId);
+        index += BitLength.maxId;
+        const encodingType = IntEncoder.decode(value.charAt(index), BitLength.encodingType);
+        index += BitLength.encodingType;
+        /**
+         * Range is handled in batches so we'll need a different decoding scheme
+         */
+        if (encodingType === VectorEncodingType.RANGE) {
+            vector = new Vector();
+            if (version === 1) {
+                if (value.substr(index, 1) === '1') {
+                    throw new DecodingError('Unable to decode default consent=1');
+                }
+                // jump over the default encoding
+                index++;
+            }
+            const numEntries = IntEncoder.decode(value.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(value.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(value.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(value.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++) {
+                        vector.set(j);
+                    }
+                }
+                else {
+                    vector.set(firstId);
+                }
+            }
+        }
+        else {
+            const bitField = value.substr(index, maxId);
+            index += maxId;
+            vector = FixedVectorEncoder.decode(bitField, maxId);
+        }
+        vector.bitLength = index;
+        return vector;
+    }
+    static buildRangeEncoding(ranges) {
+        // describe the number of entries to follow
+        const numEntries = ranges.length;
+        let rangeString = IntEncoder.encode(numEntries, BitLength.numEntries);
+        // each range
+        ranges.forEach((range) => {
+            // 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;
+    }
+}

package/lib/mjs/encoder/field/index.d.ts

@@ -0,0 +1,9 @@
+export * from './BooleanEncoder.js';
+export * from './DateEncoder.js';
+export * from './FieldEncoderMap.js';
+export * from './FixedVectorEncoder.js';
+export * from './IntEncoder.js';
+export * from './LangEncoder.js';
+export * from './PurposeRestrictionVectorEncoder.js';
+export * from './VectorEncodingType.js';
+export * from './VendorVectorEncoder.js';

package/lib/mjs/encoder/field/index.js

@@ -0,0 +1,9 @@
+export * from './BooleanEncoder.js';
+export * from './DateEncoder.js';
+export * from './FieldEncoderMap.js';
+export * from './FixedVectorEncoder.js';
+export * from './IntEncoder.js';
+export * from './LangEncoder.js';
+export * from './PurposeRestrictionVectorEncoder.js';
+export * from './VectorEncodingType.js';
+export * from './VendorVectorEncoder.js';

package/lib/mjs/encoder/index.d.ts

@@ -0,0 +1,7 @@
+export * from './Base64Url.js';
+export * from './BitLength.js';
+export * from './EncodingOptions.js';
+export * from './SegmentEncoder.js';
+export * from './SemanticPreEncoder.js';
+export * from './field/index.js';
+export * from './sequence/index.js';

package/lib/mjs/encoder/index.js

@@ -0,0 +1,7 @@
+export * from './Base64Url.js';
+export * from './BitLength.js';
+export * from './EncodingOptions.js';
+export * from './SegmentEncoder.js';
+export * from './SemanticPreEncoder.js';
+export * from './field/index.js';
+export * from './sequence/index.js';

package/lib/mjs/encoder/sequence/FieldSequence.d.ts

@@ -0,0 +1,5 @@
+import { SequenceVersionMap, SVMItem } from './SequenceVersionMap.js';
+export declare class FieldSequence implements SequenceVersionMap {
+    readonly '1': SVMItem;
+    readonly '2': SVMItem;
+}

package/lib/mjs/encoder/sequence/FieldSequence.js

@@ -0,0 +1,53 @@
+import { Segment, Fields } from '../../model/index.js';
+export class FieldSequence {
+    '1' = {
+        [Segment.CORE]: [
+            Fields.version,
+            Fields.created,
+            Fields.lastUpdated,
+            Fields.cmpId,
+            Fields.cmpVersion,
+            Fields.consentScreen,
+            Fields.consentLanguage,
+            Fields.vendorListVersion,
+            Fields.purposeConsents,
+            Fields.vendorConsents,
+        ],
+    };
+    '2' = {
+        [Segment.CORE]: [
+            Fields.version,
+            Fields.created,
+            Fields.lastUpdated,
+            Fields.cmpId,
+            Fields.cmpVersion,
+            Fields.consentScreen,
+            Fields.consentLanguage,
+            Fields.vendorListVersion,
+            Fields.policyVersion,
+            Fields.isServiceSpecific,
+            Fields.useNonStandardStacks,
+            Fields.specialFeatureOptins,
+            Fields.purposeConsents,
+            Fields.purposeLegitimateInterests,
+            Fields.purposeOneTreatment,
+            Fields.publisherCountryCode,
+            Fields.vendorConsents,
+            Fields.vendorLegitimateInterests,
+            Fields.publisherRestrictions,
+        ],
+        [Segment.PUBLISHER_TC]: [
+            Fields.publisherConsents,
+            Fields.publisherLegitimateInterests,
+            Fields.numCustomPurposes,
+            Fields.publisherCustomConsents,
+            Fields.publisherCustomLegitimateInterests,
+        ],
+        [Segment.VENDORS_ALLOWED]: [
+            Fields.vendorsAllowed,
+        ],
+        [Segment.VENDORS_DISCLOSED]: [
+            Fields.vendorsDisclosed,
+        ],
+    };
+}

package/lib/mjs/encoder/sequence/SegmentSequence.d.ts

@@ -0,0 +1,9 @@
+import { SequenceVersionMap } from './SequenceVersionMap.js';
+import { TCModel } from '../../index.js';
+import { EncodingOptions } from '../EncodingOptions.js';
+import { Segment } from '../../model/index.js';
+export declare class SegmentSequence implements SequenceVersionMap {
+    '1': Segment[];
+    '2': Segment[];
+    constructor(tcModel: TCModel, options?: EncodingOptions);
+}

package/lib/mjs/encoder/sequence/SegmentSequence.js

@@ -0,0 +1,52 @@
+import { Segment, Fields, } from '../../model/index.js';
+export class SegmentSequence {
+    '1' = [
+        Segment.CORE,
+    ];
+    '2' = [
+        Segment.CORE,
+    ];
+    constructor(tcModel, options) {
+        if (tcModel.version === 2) {
+            if (tcModel.isServiceSpecific) {
+                /**
+                 * If it's service specific only, then the publisher TC String can be
+                 * stored in the cookie and would be transmitted if it's not for
+                 * storage.  So it's included regardless of whether or not it's for
+                 * saving or the cmp api to surface.
+                 */
+                this['2'].push(Segment.PUBLISHER_TC);
+            }
+            else {
+                const isForVendors = !!(options && options.isForVendors);
+                /**
+                 * including vendors disclosed only if it is for saving (to the global
+                 * scope and not for vendors through the CMP API) or supportOOB is
+                 * turned on (either or both).  The compliment of this being not for
+                 * saving (surfaced to CMP) and no support of OOB.
+                 */
+                if (!isForVendors || tcModel[Fields.supportOOB] === true) {
+                    this['2'].push(Segment.VENDORS_DISCLOSED);
+                }
+                if (isForVendors) {
+                    /**
+                     * If a publisher does support OOB and they have narrowed the allowed
+                     * vendors to utilize it, then we should include the vendors allowed
+                     * segment.  If it is empty then there are no restrictions, if that
+                     * is intended to mean no support for OOB, then the flag should be
+                     * set for that instead.
+                     *
+                     */
+                    if (tcModel[Fields.supportOOB] && tcModel[Fields.vendorsAllowed].size > 0) {
+                        this['2'].push(Segment.VENDORS_ALLOWED);
+                    }
+                    /**
+                     * Always include the publisher TC segment as long as this TC string
+                     * is not intended to be saved in the global scope.
+                     */
+                    this['2'].push(Segment.PUBLISHER_TC);
+                }
+            }
+        }
+    }
+}

package/lib/mjs/encoder/sequence/SequenceVersionMap.d.ts

@@ -0,0 +1,7 @@
+export interface SVMItem {
+    [label: string]: string[];
+}
+export interface SequenceVersionMap {
+    '1': string[] | SVMItem;
+    '2': string[] | SVMItem;
+}

package/lib/mjs/encoder/sequence/SequenceVersionMap.js

@@ -0,0 +1 @@
+export {};

package/lib/mjs/encoder/sequence/index.d.ts

@@ -0,0 +1,3 @@
+export * from './FieldSequence.js';
+export * from './SegmentSequence.js';
+export * from './SequenceVersionMap.js';

package/lib/mjs/encoder/sequence/index.js

@@ -0,0 +1,4 @@
+// created from 'create-ts-index'
+export * from './FieldSequence.js';
+export * from './SegmentSequence.js';
+export * from './SequenceVersionMap.js';

package/lib/mjs/errors/DecodingError.d.ts

@@ -0,0 +1,15 @@
+/**
+ * class for decoding errors
+ *
+ * @extends {Error}
+ */
+declare class DecodingError extends Error {
+    /**
+     * constructor - constructs an DecodingError
+     *
+     * @param {string} msg - Decoding Error Message
+     * @return {undefined}
+     */
+    constructor(msg: string);
+}
+export { DecodingError };

package/lib/mjs/errors/DecodingError.js

@@ -0,0 +1,18 @@
+/**
+ * class for decoding errors
+ *
+ * @extends {Error}
+ */
+class DecodingError extends Error {
+    /**
+     * constructor - constructs an DecodingError
+     *
+     * @param {string} msg - Decoding Error Message
+     * @return {undefined}
+     */
+    constructor(msg) {
+        super(msg);
+        this.name = 'DecodingError';
+    }
+}
+export { DecodingError };

package/lib/mjs/errors/EncodingError.d.ts

@@ -0,0 +1,15 @@
+/**
+ * class for encoding errors
+ *
+ * @extends {Error}
+ */
+declare class EncodingError extends Error {
+    /**
+     * constructor - constructs an EncodingError
+     *
+     * @param {string} msg - Encoding Error Message
+     * @return {undefined}
+     */
+    constructor(msg: string);
+}
+export { EncodingError };

package/lib/mjs/errors/EncodingError.js

@@ -0,0 +1,18 @@
+/**
+ * class for encoding errors
+ *
+ * @extends {Error}
+ */
+class EncodingError extends Error {
+    /**
+     * constructor - constructs an EncodingError
+     *
+     * @param {string} msg - Encoding Error Message
+     * @return {undefined}
+     */
+    constructor(msg) {
+        super(msg);
+        this.name = 'EncodingError';
+    }
+}
+export { EncodingError };

package/lib/mjs/errors/GVLError.d.ts

@@ -0,0 +1,15 @@
+/**
+ * class for General GVL Errors
+ *
+ * @extends {Error}
+ */
+declare class GVLError extends Error {
+    /**
+     * constructor - constructs a GVLError
+     *
+     * @param {string} msg - Error message to display
+     * @return {undefined}
+     */
+    constructor(msg: string);
+}
+export { GVLError };

package/lib/mjs/errors/GVLError.js

@@ -0,0 +1,18 @@
+/**
+ * class for General GVL Errors
+ *
+ * @extends {Error}
+ */
+class GVLError extends Error {
+    /**
+     * constructor - constructs a GVLError
+     *
+     * @param {string} msg - Error message to display
+     * @return {undefined}
+     */
+    constructor(msg) {
+        super(msg);
+        this.name = 'GVLError';
+    }
+}
+export { GVLError };

package/lib/mjs/errors/TCModelError.d.ts

@@ -0,0 +1,16 @@
+/**
+ * class for decoding errors
+ *
+ * @extends {Error}
+ */
+declare class TCModelError extends Error {
+    /**
+     * constructor - constructs an TCModelError
+     *
+     * @param {string} fieldName - the errored field
+     * @param {string} passedValue - what was passed
+     * @return {undefined}
+     */
+    constructor(fieldName: string, passedValue: any, msg?: string);
+}
+export { TCModelError };

package/lib/mjs/errors/TCModelError.js

@@ -0,0 +1,19 @@
+/**
+ * class for decoding errors
+ *
+ * @extends {Error}
+ */
+class TCModelError extends Error {
+    /**
+     * constructor - constructs an TCModelError
+     *
+     * @param {string} fieldName - the errored field
+     * @param {string} passedValue - what was passed
+     * @return {undefined}
+     */
+    constructor(fieldName, passedValue, msg = '') {
+        super(`invalid value ${passedValue} passed for ${fieldName} ${msg}`);
+        this.name = 'TCModelError';
+    }
+}
+export { TCModelError };

package/lib/mjs/errors/index.d.ts

@@ -0,0 +1,4 @@
+export * from './DecodingError.js';
+export * from './EncodingError.js';
+export * from './GVLError.js';
+export * from './TCModelError.js';

package/lib/mjs/errors/index.js

@@ -0,0 +1,4 @@
+export * from './DecodingError.js';
+export * from './EncodingError.js';
+export * from './GVLError.js';
+export * from './TCModelError.js';

package/lib/mjs/index.d.ts

@@ -0,0 +1,8 @@
+export * from './encoder/index.js';
+export * from './errors/index.js';
+export * from './model/index.js';
+export * from './Cloneable.js';
+export * from './GVL.js';
+export * from './Json.js';
+export * from './TCModel.js';
+export * from './TCString.js';

package/lib/mjs/index.js

@@ -0,0 +1,9 @@
+// created from 'create-ts-index'
+export * from './encoder/index.js';
+export * from './errors/index.js';
+export * from './model/index.js';
+export * from './Cloneable.js';
+export * from './GVL.js';
+export * from './Json.js';
+export * from './TCModel.js';
+export * from './TCString.js';