@pubtech-ai/core 1.6.0

package/lib/mjs/model/BinarySearchTree.d.ts

@@ -0,0 +1,30 @@
+import { Cloneable } from '../Cloneable.js';
+interface TreeNode {
+    value: number;
+    right: TreeNode | null;
+    left: TreeNode | null;
+}
+declare type TreeNodeMaybe = TreeNode | null;
+export declare class BinarySearchTree extends Cloneable<BinarySearchTree> {
+    private root;
+    getRoot(): TreeNodeMaybe;
+    isEmpty(): boolean;
+    add(value: number): void;
+    /**
+     * performs Morris in-order traversal
+     * @return {number[]} sorted array
+     */
+    get(): number[];
+    contains(value: number): boolean;
+    min(current?: TreeNodeMaybe): number;
+    max(current?: TreeNodeMaybe): number;
+    remove(value: number, current?: TreeNodeMaybe): void;
+    /**
+     * Build Binary Search Tree from the ordered number array.
+     *  The depth of the tree will be the `log2` of the array length.
+     * @param {number[]} values number array in ascending order
+     * @return {BinarySearchTree} Binary Search Tree
+     */
+    static build(values?: number[]): BinarySearchTree | null;
+}
+export {};

package/lib/mjs/model/BinarySearchTree.js

@@ -0,0 +1,267 @@
+import { Cloneable } from '../Cloneable.js';
+export class BinarySearchTree extends Cloneable {
+    root = null;
+    getRoot() {
+        return this.root;
+    }
+    isEmpty() {
+        // if root is undefined or null then by definition this is empty
+        return !(this.root);
+    }
+    add(value) {
+        // create new node object
+        const node = {
+            value: value,
+            left: null,
+            right: null,
+        };
+        let current;
+        // first item?
+        if (this.isEmpty()) {
+            this.root = node;
+        }
+        else {
+            // start at the root
+            current = this.root;
+            // infinite loop, figure out where to put it
+            while (true) {
+                // if the value is less than current value; go left
+                if (value < current.value) {
+                    // if it's empty, we can insert
+                    if (current.left === null) {
+                        // insert on the left
+                        current.left = node;
+                        // our work is done here
+                        break;
+                    }
+                    else {
+                        /**
+                         * if there's something there already, we'll reset the pointer and
+                         * wait for the next loop to do something ie. keep traversing
+                         */
+                        current = current.left;
+                    }
+                }
+                else if (value > current.value) {
+                    // if the value is greater than our current value; go right
+                    if (current.right === null) {
+                        // there's nothing to the right, so put it here
+                        current.right = node;
+                        break;
+                    }
+                    else {
+                        /**
+                         * if there's something there already, we'll reset the pointer and
+                         * wait for the next loop to do something ie. keep traversing
+                         */
+                        current = current.right;
+                    }
+                }
+                else {
+                    /**
+                     * If it's neither greater than the right or less than the right then
+                     * it is equal to the current nodes value.  In that case we won't do
+                     * anything with it because we will only insert unique values.
+                     */
+                    break;
+                }
+            }
+        }
+    }
+    /**
+     * performs Morris in-order traversal
+     * @return {number[]} sorted array
+     */
+    get() {
+        const retr = [];
+        let current = this.root;
+        while (current) {
+            if (!current.left) {
+                retr.push(current.value); // if there is no left child, visit current node
+                current = current.right; // then we go the right branch
+            }
+            else {
+                // find the right most leaf of root.left node.
+                let pre = current.left;
+                // when pre.right == null, it means we go to the right most leaf
+                // when pre.right == current, it means the right most leaf has been visited in the last round
+                while (pre.right && pre.right != current) {
+                    pre = pre.right;
+                }
+                // this means the pre.right has been set, it's time to go to current node
+                if (pre.right == current) {
+                    pre.right = null;
+                    // means the current node is pointed by left right most child
+                    // the left branch has been visited, it's time to push the current node
+                    retr.push(current.value);
+                    current = current.right;
+                }
+                else {
+                    // the fist time to visit the pre node, make its right child point to current node
+                    pre.right = current;
+                    current = current.left;
+                }
+            }
+        }
+        return retr;
+    }
+    contains(value) {
+        let retr = false;
+        let current = this.root;
+        while (current) {
+            if (current.value === value) {
+                retr = true;
+                break;
+            }
+            else if (value > current.value) {
+                current = current.right;
+            }
+            else if (value < current.value) {
+                current = current.left;
+            }
+        }
+        return retr;
+    }
+    min(current = this.root) {
+        let retr;
+        while (current) {
+            if (current.left) {
+                current = current.left;
+            }
+            else {
+                retr = current.value;
+                current = null;
+            }
+        }
+        return retr;
+    }
+    max(current = this.root) {
+        let retr;
+        while (current) {
+            if (current.right) {
+                current = current.right;
+            }
+            else {
+                retr = current.value;
+                current = null;
+            }
+        }
+        return retr;
+    }
+    remove(value, current = this.root) {
+        // we start at the root, so the parent is null
+        let parent = null;
+        let parentSide = 'left';
+        while (current) {
+            if (value < current.value) {
+                // set our parent to the current value
+                parent = current;
+                // value is less than current value, so go left
+                current = current.left;
+                parentSide = 'left';
+            }
+            else if (value > current.value) {
+                // set our parent to the current value
+                parent = current;
+                // value is greater than current value, so go right
+                current = current.right;
+                parentSide = 'right';
+            }
+            else {
+                /**
+                   * if it's neither greater than or less than, then it's equal so BINGO!
+                   * we've found it
+                   *
+                   * If we have children, we've got to figure out what to do with
+                   * them once we are no longer around...  Woah, code is like real
+                   * life...
+                   *
+                   * There are three cases we care about when it comes to this removal
+                   * process:
+                   *
+                   * 1. No children -- If not children we just delete an do nothing
+                   * else, no harm no foul.
+                   *
+                   * 2. One child -- Just link the parent's link to current to the
+                   * child.
+                   *
+                   * 3. Two children --  Find the minimum value from the right subtree
+                   * replace us with the minimum value and of course remove that
+                   * minimum value from the right stubtree
+                   */
+                if (!current.left && !current.right) {
+                    // case 1 there are no children easy peasy lemon squeezy
+                    if (parent) {
+                        parent[parentSide] = null;
+                    }
+                    else {
+                        this.root = null;
+                    }
+                }
+                else if (!current.left) {
+                    // no left side only right, so link right
+                    if (parent) {
+                        parent[parentSide] = current.right;
+                    }
+                    else {
+                        this.root = current.right;
+                    }
+                }
+                else if (!current.right) {
+                    // no right side only left, so link left
+                    if (parent) {
+                        parent[parentSide] = current.left;
+                    }
+                    else {
+                        this.root = current.left;
+                    }
+                }
+                else {
+                    /**
+                     * case 3 just like real life, if you delete a parent the more kids
+                     * that parent has the more complicated things get... in this case we
+                     * have two children.  We're gonna have to figure out who goes where.
+                     */
+                    const minVal = this.min(current.right);
+                    // little bit of recursion...
+                    this.remove(minVal, current.right);
+                    current.value = minVal;
+                }
+                current = null;
+            }
+        }
+    }
+    /**
+     * Build Binary Search Tree from the ordered number array.
+     *  The depth of the tree will be the `log2` of the array length.
+     * @param {number[]} values number array in ascending order
+     * @return {BinarySearchTree} Binary Search Tree
+     */
+    static build(values) {
+        if (!values || values.length === 0) {
+            return null;
+        }
+        else if (values.length === 1) {
+            const tree = new BinarySearchTree();
+            tree.add(values[0]);
+            return tree;
+        }
+        else {
+            const rootIndex = values.length >> 1;
+            const tree = new BinarySearchTree();
+            tree.add(values[rootIndex]);
+            const root = tree.getRoot();
+            if (root) {
+                if (rootIndex + 1 < values.length) {
+                    const rightTree = BinarySearchTree.build(values.slice(rootIndex + 1));
+                    root.right = rightTree ? rightTree.getRoot() : null;
+                }
+                if (rootIndex - 1 > 0) {
+                    const leftTree = BinarySearchTree.build(values.slice(0, rootIndex - 1));
+                    root.left = leftTree ? leftTree.getRoot() : null;
+                }
+            }
+            return tree;
+        }
+    }
+}

package/lib/mjs/model/ConsentLanguages.d.ts

@@ -0,0 +1,6 @@
+export declare class ConsentLanguages {
+    private static readonly langSet;
+    has(key: string): boolean;
+    forEach(callback: (key: string) => void): void;
+    get size(): number;
+}

package/lib/mjs/model/ConsentLanguages.js

@@ -0,0 +1,42 @@
+export class ConsentLanguages {
+    static langSet = new Set([
+        'BG',
+        'CA',
+        'CS',
+        'DA',
+        'DE',
+        'EL',
+        'EN',
+        'ES',
+        'ET',
+        'FI',
+        'FR',
+        'HR',
+        'HU',
+        'IT',
+        'JA',
+        'LT',
+        'LV',
+        'MT',
+        'NL',
+        'NO',
+        'PL',
+        'PT',
+        'RO',
+        'RU',
+        'SK',
+        'SL',
+        'SV',
+        'TR',
+        'ZH',
+    ]);
+    has(key) {
+        return ConsentLanguages.langSet.has(key);
+    }
+    forEach(callback) {
+        ConsentLanguages.langSet.forEach(callback);
+    }
+    get size() {
+        return ConsentLanguages.langSet.size;
+    }
+}

package/lib/mjs/model/DeviceDisclosure.d.ts

@@ -0,0 +1,9 @@
+import { DeviceDisclosureStorageAccessType } from './DeviceDisclosureStorageAccessType.js';
+export interface DeviceDisclosure {
+    domain?: string;
+    cookieRefresh?: boolean;
+    identifier: string;
+    maxAgeSeconds: number | null;
+    purposes: number[];
+    type: DeviceDisclosureStorageAccessType;
+}

package/lib/mjs/model/DeviceDisclosure.js

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

package/lib/mjs/model/DeviceDisclosureStorageAccessType.d.ts

@@ -0,0 +1,5 @@
+export declare enum DeviceDisclosureStorageAccessType {
+    COOKIE = "cookie",
+    WEB = "web",
+    APP = "app"
+}

package/lib/mjs/model/DeviceDisclosureStorageAccessType.js

@@ -0,0 +1,6 @@
+export var DeviceDisclosureStorageAccessType;
+(function (DeviceDisclosureStorageAccessType) {
+    DeviceDisclosureStorageAccessType["COOKIE"] = "cookie";
+    DeviceDisclosureStorageAccessType["WEB"] = "web";
+    DeviceDisclosureStorageAccessType["APP"] = "app";
+})(DeviceDisclosureStorageAccessType || (DeviceDisclosureStorageAccessType = {}));

package/lib/mjs/model/Fields.d.ts

@@ -0,0 +1,29 @@
+export declare class Fields {
+    static readonly cmpId: 'cmpId';
+    static readonly cmpVersion: 'cmpVersion';
+    static readonly consentLanguage: 'consentLanguage';
+    static readonly consentScreen: 'consentScreen';
+    static readonly created: 'created';
+    static readonly supportOOB: 'supportOOB';
+    static readonly isServiceSpecific: 'isServiceSpecific';
+    static readonly lastUpdated: 'lastUpdated';
+    static readonly numCustomPurposes: 'numCustomPurposes';
+    static readonly policyVersion: 'policyVersion';
+    static readonly publisherCountryCode: 'publisherCountryCode';
+    static readonly publisherCustomConsents: 'publisherCustomConsents';
+    static readonly publisherCustomLegitimateInterests: 'publisherCustomLegitimateInterests';
+    static readonly publisherLegitimateInterests: 'publisherLegitimateInterests';
+    static readonly publisherConsents: 'publisherConsents';
+    static readonly publisherRestrictions: 'publisherRestrictions';
+    static readonly purposeConsents: 'purposeConsents';
+    static readonly purposeLegitimateInterests: 'purposeLegitimateInterests';
+    static readonly purposeOneTreatment: 'purposeOneTreatment';
+    static readonly specialFeatureOptins: 'specialFeatureOptins';
+    static readonly useNonStandardStacks: 'useNonStandardStacks';
+    static readonly vendorConsents: 'vendorConsents';
+    static readonly vendorLegitimateInterests: 'vendorLegitimateInterests';
+    static readonly vendorListVersion: 'vendorListVersion';
+    static readonly vendorsAllowed: 'vendorsAllowed';
+    static readonly vendorsDisclosed: 'vendorsDisclosed';
+    static readonly version: 'version';
+}

package/lib/mjs/model/Fields.js

@@ -0,0 +1,29 @@
+export class Fields {
+    static cmpId = 'cmpId';
+    static cmpVersion = 'cmpVersion';
+    static consentLanguage = 'consentLanguage';
+    static consentScreen = 'consentScreen';
+    static created = 'created';
+    static supportOOB = 'supportOOB';
+    static isServiceSpecific = 'isServiceSpecific';
+    static lastUpdated = 'lastUpdated';
+    static numCustomPurposes = 'numCustomPurposes';
+    static policyVersion = 'policyVersion';
+    static publisherCountryCode = 'publisherCountryCode';
+    static publisherCustomConsents = 'publisherCustomConsents';
+    static publisherCustomLegitimateInterests = 'publisherCustomLegitimateInterests';
+    static publisherLegitimateInterests = 'publisherLegitimateInterests';
+    static publisherConsents = 'publisherConsents';
+    static publisherRestrictions = 'publisherRestrictions';
+    static purposeConsents = 'purposeConsents';
+    static purposeLegitimateInterests = 'purposeLegitimateInterests';
+    static purposeOneTreatment = 'purposeOneTreatment';
+    static specialFeatureOptins = 'specialFeatureOptins';
+    static useNonStandardStacks = 'useNonStandardStacks';
+    static vendorConsents = 'vendorConsents';
+    static vendorLegitimateInterests = 'vendorLegitimateInterests';
+    static vendorListVersion = 'vendorListVersion';
+    static vendorsAllowed = 'vendorsAllowed';
+    static vendorsDisclosed = 'vendorsDisclosed';
+    static version = 'version';
+}

package/lib/mjs/model/IntMap.d.ts

@@ -0,0 +1,13 @@
+/**
+ * IntMap - A map of abstract type (defined by implementer) that is keyed by an
+ * integer string id. Example `IntMap<number>`:
+ * ```
+ * const myIntMapOfNumbers: IntMap<number> = {
+ *   "1":2,
+ *   "3":4,
+ * };
+ * ```
+ */
+export interface IntMap<T> {
+    [id: string]: T;
+}

package/lib/mjs/model/IntMap.js

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

package/lib/mjs/model/KeyMap.d.ts

@@ -0,0 +1,12 @@
+/**
+ * KeyMap - A map of abstract type (defined by implementer) that is keyed by an
+ * integer string id. Example `KeyMap<number>`:
+ * ```
+ * const myKeyMapOfNumbers: KeyMap<number> = {
+ *   "1":2,
+ *   "3":4,
+ * };
+ * ```
+ */
+import { IntMap } from './IntMap.js';
+export declare type KeyMap<T> = IntMap<T>;

package/lib/mjs/model/KeyMap.js

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

package/lib/mjs/model/PurposeRestriction.d.ts

@@ -0,0 +1,33 @@
+import { Cloneable } from '../Cloneable.js';
+import { RestrictionType } from './RestrictionType.js';
+export declare class PurposeRestriction extends Cloneable<PurposeRestriction> {
+    static hashSeparator: string;
+    private purposeId_;
+    restrictionType: RestrictionType;
+    /**
+     * constructor
+     *
+     * @param {number} purposeId? - may optionally pass the purposeId into the
+     * constructor
+     * @param {RestrictionType} restrictionType? - may
+     * optionally pass the restrictionType into the constructor
+     * @return {undefined}
+     */
+    constructor(purposeId?: number, restrictionType?: RestrictionType);
+    static unHash(hash: string): PurposeRestriction;
+    get hash(): string;
+    /**
+     * @return {number} The purpose Id associated with a publisher
+     * purpose-by-vendor restriction that resulted in a different consent or LI
+     * status than the consent or LI purposes allowed lists.
+     */
+    get purposeId(): number;
+    /**
+     * @param {number} idNum - The purpose Id associated with a publisher
+     * purpose-by-vendor restriction that resulted in a different consent or LI
+     * status than the consent or LI purposes allowed lists.
+     */
+    set purposeId(idNum: number);
+    isValid(): boolean;
+    isSameAs(otherPR: PurposeRestriction): boolean;
+}

package/lib/mjs/model/PurposeRestriction.js

@@ -0,0 +1,69 @@
+import { Cloneable } from '../Cloneable.js';
+import { TCModelError } from '../errors/index.js';
+import { RestrictionType } from './RestrictionType.js';
+export class PurposeRestriction extends Cloneable {
+    static hashSeparator = '-';
+    purposeId_;
+    restrictionType;
+    /**
+     * constructor
+     *
+     * @param {number} purposeId? - may optionally pass the purposeId into the
+     * constructor
+     * @param {RestrictionType} restrictionType? - may
+     * optionally pass the restrictionType into the constructor
+     * @return {undefined}
+     */
+    constructor(purposeId, restrictionType) {
+        super();
+        if (purposeId !== undefined) {
+            this.purposeId = purposeId;
+        }
+        if (restrictionType !== undefined) {
+            this.restrictionType = restrictionType;
+        }
+    }
+    static unHash(hash) {
+        const splitUp = hash.split(this.hashSeparator);
+        const purpRestriction = new PurposeRestriction();
+        if (splitUp.length !== 2) {
+            throw new TCModelError('hash', hash);
+        }
+        purpRestriction.purposeId = parseInt(splitUp[0], 10);
+        purpRestriction.restrictionType = parseInt(splitUp[1], 10);
+        return purpRestriction;
+    }
+    get hash() {
+        if (!this.isValid()) {
+            throw new Error('cannot hash invalid PurposeRestriction');
+        }
+        return `${this.purposeId}${PurposeRestriction.hashSeparator}${this.restrictionType}`;
+    }
+    /**
+     * @return {number} The purpose Id associated with a publisher
+     * purpose-by-vendor restriction that resulted in a different consent or LI
+     * status than the consent or LI purposes allowed lists.
+     */
+    get purposeId() {
+        return this.purposeId_;
+    }
+    /**
+     * @param {number} idNum - The purpose Id associated with a publisher
+     * purpose-by-vendor restriction that resulted in a different consent or LI
+     * status than the consent or LI purposes allowed lists.
+     */
+    set purposeId(idNum) {
+        this.purposeId_ = idNum;
+    }
+    isValid() {
+        return (Number.isInteger(this.purposeId) &&
+            this.purposeId > 0 &&
+            (this.restrictionType === RestrictionType.NOT_ALLOWED ||
+                this.restrictionType === RestrictionType.REQUIRE_CONSENT ||
+                this.restrictionType === RestrictionType.REQUIRE_LI));
+    }
+    isSameAs(otherPR) {
+        return (this.purposeId === otherPR.purposeId &&
+            this.restrictionType === otherPR.restrictionType);
+    }
+}

package/lib/mjs/model/PurposeRestrictionVector.d.ts

@@ -0,0 +1,100 @@
+import { PurposeRestriction } from './PurposeRestriction.js';
+import { RestrictionType } from './RestrictionType.js';
+import { GVL } from '../GVL.js';
+import { Cloneable } from '../Cloneable.js';
+export declare class PurposeRestrictionVector extends Cloneable<PurposeRestrictionVector> {
+    /**
+     * if this originatd from an encoded string we'll need a place to store the
+     * bit length; it can be set and got from here
+     */
+    bitLength: number;
+    /**
+     * a map indexed by a string which will be a 'hash' of the purpose and
+     * restriction type.
+     *
+     * Using a BST to keep vendors in a sorted order for encoding later
+     */
+    private map;
+    private gvl_;
+    private has;
+    private isOkToHave;
+    /**
+     * add - adds a given Vendor ID under a given Purpose Restriction
+     *
+     * @param {number} vendorId
+     * @param {PurposeRestriction} purposeRestriction
+     * @return {void}
+     */
+    add(vendorId: number, purposeRestriction: PurposeRestriction): void;
+    /**
+     * restrictPurposeToLegalBasis - adds all Vendors under a given Purpose Restriction
+     *
+     * @param {PurposeRestriction} purposeRestriction
+     * @return {void}
+     */
+    restrictPurposeToLegalBasis(purposeRestriction: PurposeRestriction): void;
+    /**
+     * getVendors - returns array of vendor ids optionally narrowed by a given
+     * Purpose Restriction.  If no purpose restriction is passed then all vendor
+     * ids will be returned.  One can expect this result to be a unique set of
+     * ids no duplicates.
+     *
+     * @param {PurposeRestriction} [purposeRestriction] - optionally passed to
+     * get only Vendor IDs restricted under the given Purpose Restriction
+     * @return {number[]} - Unique ID set of vendors
+     */
+    getVendors(purposeRestriction?: PurposeRestriction): number[];
+    getRestrictionType(vendorId: number, purposeId: number): RestrictionType | undefined;
+    /**
+     * vendorHasRestriction - determines whether a given Vendor ID is under a
+     * given Purpose Restriction
+     *
+     * @param {number} vendorId
+     * @param {PurposeRestriction} purposeRestriction
+     * @return {boolean} - true if the give Vendor ID is under the given Purpose
+     * Restriction
+     */
+    vendorHasRestriction(vendorId: number, purposeRestriction: PurposeRestriction): boolean;
+    /**
+     * getMaxVendorId - gets the Maximum Vendor ID regardless of Purpose
+     * Restriction
+     *
+     * @return {number} - maximum Vendor ID
+     */
+    getMaxVendorId(): number;
+    getRestrictions(vendorId?: number): PurposeRestriction[];
+    getPurposes(): number[];
+    /**
+     * remove - removes Vendor ID from a Purpose Restriction
+     *
+     * @param {number} vendorId
+     * @param {PurposeRestriction} purposeRestriction
+     * @return {void}
+     */
+    remove(vendorId: number, purposeRestriction: PurposeRestriction): void;
+    /**
+     * Essential for being able to determine whether we can actually set a
+     * purpose restriction since they have to have a flexible legal basis
+     *
+     * @param {GVL} value - the GVL instance
+     */
+    set gvl(value: GVL);
+    /**
+     * gvl returns local copy of the GVL these restrictions apply to
+     *
+     * @return {GVL}
+     */
+    get gvl(): GVL;
+    /**
+     * isEmpty - whether or not this vector has any restrictions in it
+     *
+     * @return {boolean}
+     */
+    isEmpty(): boolean;
+    /**
+     * numRestrictions - returns the number of Purpose Restrictions.
+     *
+     * @return {number}
+     */
+    get numRestrictions(): number;
+}