nimiq-supply-calculator 0.0.1-security → 1.0.0

package/dist/hooks/useSavedTrackingPreference.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useSavedTrackingPreference = exports.useSavedTrackingPreferenceFromMobileApp = void 0;
+const react_1 = require("react");
+const constants_1 = require("../constants");
+const CookieContext_1 = require("../CookieContext");
+const TrackingManagerContext_1 = require("../TrackingManagerContext");
+const types_1 = require("../types");
+const persistMobileAppPreferences_1 = require("../utils/persistMobileAppPreferences");
+const useSavedTrackingPreferenceFromMobileApp = () => {
+    const { region } = (0, TrackingManagerContext_1.useTrackingManager)();
+    const [isMobileAppFromCookie] = (0, CookieContext_1.useCookie)(constants_1.IS_MOBILE_APP);
+    const isMobileAppFromQueryParams = (0, react_1.useMemo)(() => (0, persistMobileAppPreferences_1.getIsMobileAppFromQueryParams)(), []);
+    const isMobileApp = isMobileAppFromCookie || isMobileAppFromQueryParams;
+    const mobileAppPreference = (0, react_1.useMemo)(() => {
+        if (isMobileApp)
+            return {
+                region,
+                consent: [types_1.TrackingCategory.NECESSARY],
+            };
+    }, [isMobileApp, region]);
+    return mobileAppPreference;
+};
+exports.useSavedTrackingPreferenceFromMobileApp = useSavedTrackingPreferenceFromMobileApp;
+const useSavedTrackingPreference = () => {
+    const { region, onError } = (0, TrackingManagerContext_1.useTrackingManager)();
+    const [euCookie] = (0, CookieContext_1.useCookie)(constants_1.EU_CONSENT_PREFERENCES_COOKIE);
+    const [defaultCookie] = (0, CookieContext_1.useCookie)(constants_1.DEFAULT_CONSENT_PREFERENCES_COOKIE);
+    const preference = region === types_1.Region.EU ? euCookie : defaultCookie;
+    if (!preference)
+        return;
+    if (!preference.region || !preference.consent) {
+        onError(new Error('Malformed preferences'));
+        return;
+    }
+    return preference;
+};
+exports.useSavedTrackingPreference = useSavedTrackingPreference;

package/dist/hooks/useSetTrackingPreference.d.ts

@@ -0,0 +1,3 @@
+import { TrackingPreference } from '../types';
+declare const useSetTrackingPreference: () => (preference: TrackingPreference) => void;
+export default useSetTrackingPreference;

package/dist/hooks/useSetTrackingPreference.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = require("react");
+const CookieContext_1 = require("../CookieContext");
+const TrackingManagerContext_1 = require("../TrackingManagerContext");
+const setTrackingPreference_1 = __importDefault(require("../utils/setTrackingPreference"));
+const useRequiredCategories_1 = __importDefault(require("./useRequiredCategories"));
+const useSetTrackingPreference = () => {
+    const { region, onPreferenceChange, onError } = (0, TrackingManagerContext_1.useTrackingManager)();
+    const setCookie = (0, CookieContext_1.useSetCookie)();
+    const requiredCategories = (0, useRequiredCategories_1.default)();
+    const changePreference = (0, react_1.useCallback)((preference) => {
+        const preferencesToSet = preference;
+        requiredCategories.forEach((c) => {
+            if (!preference.consent.includes(c)) {
+                onError(new Error(`Trying to remove category ${c} that is required`));
+                preferencesToSet.consent = [...preference.consent, c];
+            }
+        });
+        (0, setTrackingPreference_1.default)(setCookie, preferencesToSet, region, onPreferenceChange);
+    }, [onError, onPreferenceChange, region, requiredCategories, setCookie]);
+    return changePreference;
+};
+exports.default = useSetTrackingPreference;

package/dist/hooks/useTrackingPreference.d.ts

@@ -0,0 +1,3 @@
+import { TrackingPreference } from '../types';
+declare const useTrackingPreference: () => TrackingPreference;
+export default useTrackingPreference;

package/dist/hooks/useTrackingPreference.js

@@ -0,0 +1,16 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const TrackingManagerContext_1 = require("../TrackingManagerContext");
+const getDefaultTrackingPreference_1 = __importDefault(require("../utils/getDefaultTrackingPreference"));
+const useSavedTrackingPreference_1 = require("./useSavedTrackingPreference");
+const useTrackingPreference = () => {
+    const preference = (0, useSavedTrackingPreference_1.useSavedTrackingPreference)();
+    const { region, config } = (0, TrackingManagerContext_1.useTrackingManager)();
+    if (!preference)
+        return (0, getDefaultTrackingPreference_1.default)(region, config);
+    return preference;
+};
+exports.default = useTrackingPreference;

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+export { TRACKER_CATEGORIES } from './constants';
+export { useCookie } from './CookieContext';
+export { default as useHasConsent } from './hooks/useHasConsent';
+export { default as useRequiredCategories } from './hooks/useRequiredCategories';
+export { useSavedTrackingPreference, useSavedTrackingPreferenceFromMobileApp, } from './hooks/useSavedTrackingPreference';
+export { default as useSetTrackingPreference } from './hooks/useSetTrackingPreference';
+export { default as useTrackingPreference } from './hooks/useTrackingPreference';
+export { Provider } from './TrackingManagerContext';
+export { useTrackingManager } from './TrackingManagerContext';
+export { Framework, Region, TrackerType, TrackingCategory, TrackingPreference } from './types';
+export { default as areCookiesEnabled } from './utils/areCookiesEnabled';
+export { default as getDefaultTrackingPreference } from './utils/getDefaultTrackingPreference';
+export { default as isOptOut } from './utils/isOptOut';
+export { getIsMobileAppFromQueryParams, persistMobileAppPreferences, } from './utils/persistMobileAppPreferences';

package/dist/index.js

@@ -0,0 +1,39 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.persistMobileAppPreferences = exports.getIsMobileAppFromQueryParams = exports.isOptOut = exports.getDefaultTrackingPreference = exports.areCookiesEnabled = exports.TrackingCategory = exports.TrackerType = exports.Region = exports.Framework = exports.useTrackingManager = exports.Provider = exports.useTrackingPreference = exports.useSetTrackingPreference = exports.useSavedTrackingPreferenceFromMobileApp = exports.useSavedTrackingPreference = exports.useRequiredCategories = exports.useHasConsent = exports.useCookie = exports.TRACKER_CATEGORIES = void 0;
+var constants_1 = require("./constants");
+Object.defineProperty(exports, "TRACKER_CATEGORIES", { enumerable: true, get: function () { return constants_1.TRACKER_CATEGORIES; } });
+var CookieContext_1 = require("./CookieContext");
+Object.defineProperty(exports, "useCookie", { enumerable: true, get: function () { return CookieContext_1.useCookie; } });
+var useHasConsent_1 = require("./hooks/useHasConsent");
+Object.defineProperty(exports, "useHasConsent", { enumerable: true, get: function () { return __importDefault(useHasConsent_1).default; } });
+var useRequiredCategories_1 = require("./hooks/useRequiredCategories");
+Object.defineProperty(exports, "useRequiredCategories", { enumerable: true, get: function () { return __importDefault(useRequiredCategories_1).default; } });
+var useSavedTrackingPreference_1 = require("./hooks/useSavedTrackingPreference");
+Object.defineProperty(exports, "useSavedTrackingPreference", { enumerable: true, get: function () { return useSavedTrackingPreference_1.useSavedTrackingPreference; } });
+Object.defineProperty(exports, "useSavedTrackingPreferenceFromMobileApp", { enumerable: true, get: function () { return useSavedTrackingPreference_1.useSavedTrackingPreferenceFromMobileApp; } });
+var useSetTrackingPreference_1 = require("./hooks/useSetTrackingPreference");
+Object.defineProperty(exports, "useSetTrackingPreference", { enumerable: true, get: function () { return __importDefault(useSetTrackingPreference_1).default; } });
+var useTrackingPreference_1 = require("./hooks/useTrackingPreference");
+Object.defineProperty(exports, "useTrackingPreference", { enumerable: true, get: function () { return __importDefault(useTrackingPreference_1).default; } });
+var TrackingManagerContext_1 = require("./TrackingManagerContext");
+Object.defineProperty(exports, "Provider", { enumerable: true, get: function () { return TrackingManagerContext_1.Provider; } });
+var TrackingManagerContext_2 = require("./TrackingManagerContext");
+Object.defineProperty(exports, "useTrackingManager", { enumerable: true, get: function () { return TrackingManagerContext_2.useTrackingManager; } });
+var types_1 = require("./types");
+Object.defineProperty(exports, "Framework", { enumerable: true, get: function () { return types_1.Framework; } });
+Object.defineProperty(exports, "Region", { enumerable: true, get: function () { return types_1.Region; } });
+Object.defineProperty(exports, "TrackerType", { enumerable: true, get: function () { return types_1.TrackerType; } });
+Object.defineProperty(exports, "TrackingCategory", { enumerable: true, get: function () { return types_1.TrackingCategory; } });
+var areCookiesEnabled_1 = require("./utils/areCookiesEnabled");
+Object.defineProperty(exports, "areCookiesEnabled", { enumerable: true, get: function () { return __importDefault(areCookiesEnabled_1).default; } });
+var getDefaultTrackingPreference_1 = require("./utils/getDefaultTrackingPreference");
+Object.defineProperty(exports, "getDefaultTrackingPreference", { enumerable: true, get: function () { return __importDefault(getDefaultTrackingPreference_1).default; } });
+var isOptOut_1 = require("./utils/isOptOut");
+Object.defineProperty(exports, "isOptOut", { enumerable: true, get: function () { return __importDefault(isOptOut_1).default; } });
+var persistMobileAppPreferences_1 = require("./utils/persistMobileAppPreferences");
+Object.defineProperty(exports, "getIsMobileAppFromQueryParams", { enumerable: true, get: function () { return persistMobileAppPreferences_1.getIsMobileAppFromQueryParams; } });
+Object.defineProperty(exports, "persistMobileAppPreferences", { enumerable: true, get: function () { return persistMobileAppPreferences_1.persistMobileAppPreferences; } });

package/dist/types.d.ts

@@ -0,0 +1,62 @@
+import { CookieAttributes } from 'js-cookie';
+export type ErrorFunction = (error: Error, metadata?: {
+    [key: string]: any;
+}) => void;
+export type SetCookieFunction = (value: any, options?: CookieAttributes) => void;
+export type LogFunction = (str: string, options?: Record<string, any>) => void;
+export declare enum Region {
+    EU = "EU",
+    DEFAULT = "DEFAULT"
+}
+export declare enum TrackingCategory {
+    FUNCTIONAL = "functional",
+    NECESSARY = "necessary",
+    TARGETING = "targeting",
+    PERFORMANCE = "performance",
+    DELETE_IF_SEEN = "delete-if-seen"
+}
+export type TrackingPreference = {
+    region: Region;
+    consent: Array<TrackingCategory>;
+};
+export declare enum Framework {
+    OPT_OUT = "optOut",
+    OPT_IN = "optIn"
+}
+export type GeolocationRule = {
+    region: Region;
+    framework: Framework;
+};
+export declare enum TrackerType {
+    COOKIE = "cookie",
+    QUERY = "query",
+    PIXEL = "pixel",
+    BEACON = "beacon"
+}
+export type Tracker = {
+    id: string;
+    type: TrackerType;
+    regex?: string;
+};
+export type ConfigCategoryInfo = {
+    id: TrackingCategory;
+    trackers: Array<Tracker>;
+    required?: boolean;
+};
+export type Config = {
+    categories: Array<ConfigCategoryInfo>;
+};
+export type TrackingManagerDependencies = {
+    onError: ErrorFunction;
+    projectName: string;
+    locale: string;
+    region: Region;
+    onPreferenceChange?: (preference: TrackingPreference) => void;
+    config: Config;
+    shadowMode?: boolean;
+    log: LogFunction;
+};
+export type AdTrackingPreference = {
+    value: boolean;
+    updated_at?: number;
+};

package/dist/types.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TrackerType = exports.Framework = exports.TrackingCategory = exports.Region = void 0;
+var Region;
+(function (Region) {
+    Region["EU"] = "EU";
+    Region["DEFAULT"] = "DEFAULT";
+})(Region || (exports.Region = Region = {}));
+var TrackingCategory;
+(function (TrackingCategory) {
+    TrackingCategory["FUNCTIONAL"] = "functional";
+    TrackingCategory["NECESSARY"] = "necessary";
+    TrackingCategory["TARGETING"] = "targeting";
+    TrackingCategory["PERFORMANCE"] = "performance";
+    TrackingCategory["DELETE_IF_SEEN"] = "delete-if-seen";
+})(TrackingCategory || (exports.TrackingCategory = TrackingCategory = {}));
+var Framework;
+(function (Framework) {
+    Framework["OPT_OUT"] = "optOut";
+    Framework["OPT_IN"] = "optIn";
+})(Framework || (exports.Framework = Framework = {}));
+var TrackerType;
+(function (TrackerType) {
+    TrackerType["COOKIE"] = "cookie";
+    TrackerType["QUERY"] = "query";
+    TrackerType["PIXEL"] = "pixel";
+    TrackerType["BEACON"] = "beacon";
+})(TrackerType || (exports.TrackerType = TrackerType = {}));

package/dist/utils/areCookiesEnabled.d.ts

@@ -0,0 +1,2 @@
+declare const areCookiesEnabled: () => boolean;
+export default areCookiesEnabled;

package/dist/utils/areCookiesEnabled.js

@@ -0,0 +1,14 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const js_cookie_1 = __importDefault(require("js-cookie"));
+const TEST_COOKIE = 'test_cookie';
+const areCookiesEnabled = () => {
+    js_cookie_1.default.set(TEST_COOKIE, 'test');
+    const result = !!js_cookie_1.default.get(TEST_COOKIE);
+    js_cookie_1.default.remove(TEST_COOKIE);
+    return result;
+};
+exports.default = areCookiesEnabled;

package/dist/utils/getAllCookies.d.ts

@@ -0,0 +1,3 @@
+export declare const deserializeCookies: (cookies: Record<string, string>) => Record<string, any>;
+export default function getAllCookies(initialCookies?: Record<string, string>): Record<string, any>;
+export declare function areRecordsEqual(record1: Record<string, any>, record2: Record<string, any>): boolean;

package/dist/utils/getAllCookies.js

@@ -0,0 +1,64 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.areRecordsEqual = exports.deserializeCookies = void 0;
+const js_cookie_1 = __importDefault(require("js-cookie"));
+const deserializeCookies = (cookies) => {
+    const parsedCookies = {};
+    Object.keys(cookies).forEach((c) => {
+        try {
+            parsedCookies[c] = JSON.parse(cookies[c]);
+        }
+        catch (e) {
+            parsedCookies[c] = cookies[c];
+        }
+    });
+    return parsedCookies;
+};
+exports.deserializeCookies = deserializeCookies;
+function getAllCookies(initialCookies) {
+    if (typeof window === 'undefined' && initialCookies) {
+        return (0, exports.deserializeCookies)(initialCookies);
+    }
+    return (0, exports.deserializeCookies)(js_cookie_1.default.get() || {});
+}
+exports.default = getAllCookies;
+function areRecordsEqual(record1, record2) {
+    // Check if the number of keys is the same
+    const keys1 = Object.keys(record1);
+    const keys2 = Object.keys(record2);
+    if (keys1.length !== keys2.length) {
+        return false;
+    }
+    // Check if all keys and their values are equal
+    for (const key of keys1) {
+        if (!deepEqual(record1[key], record2[key])) {
+            return false;
+        }
+    }
+    return true;
+}
+exports.areRecordsEqual = areRecordsEqual;
+function deepEqual(value1, value2) {
+    if (typeof value1 !== typeof value2) {
+        return false;
+    }
+    if (typeof value1 === 'object' && value1 !== null) {
+        const keys1 = Object.keys(value1);
+        const keys2 = Object.keys(value2);
+        if (keys1.length !== keys2.length) {
+            return false;
+        }
+        for (const key of keys1) {
+            if (!deepEqual(value1[key], value2[key])) {
+                return false;
+            }
+        }
+    }
+    else if (value1 !== value2) {
+        return false;
+    }
+    return true;
+}

package/dist/utils/getDefaultTrackingPreference.d.ts

@@ -0,0 +1,3 @@
+import { Config, Region, TrackingPreference } from '../types';
+declare const getDefaultTrackingPreference: (region: Region, config: Config) => TrackingPreference;
+export default getDefaultTrackingPreference;

package/dist/utils/getDefaultTrackingPreference.js

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("../types");
+const isOptOut_1 = __importDefault(require("./isOptOut"));
+const getDefaultTrackingPreference = (region, config) => {
+    // In opt in regions, we only allow required trackers
+    if (!(0, isOptOut_1.default)(region)) {
+        const categories = config.categories
+            .map((c) => {
+            if (c.required) {
+                return c.id;
+            }
+        })
+            .filter((c) => !!c);
+        return { region, consent: categories };
+    }
+    const categories = config.categories
+        .map((c) => c.id)
+        .filter((id) => id !== types_1.TrackingCategory.DELETE_IF_SEEN);
+    return {
+        region,
+        consent: categories,
+    };
+};
+exports.default = getDefaultTrackingPreference;

package/dist/utils/getDomain.d.ts

@@ -0,0 +1,2 @@
+export declare function getHostname(): string | undefined;
+export declare function getDomainWithoutSubdomain(): string | undefined;

package/dist/utils/getDomain.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDomainWithoutSubdomain = exports.getHostname = void 0;
+function getHostname() {
+    if (typeof window !== 'undefined') {
+        return window.location.hostname;
+    }
+}
+exports.getHostname = getHostname;
+function getDomainWithoutSubdomain() {
+    const hostname = getHostname();
+    if (!hostname) {
+        return;
+    }
+    if (hostname === 'localhost') {
+        return hostname;
+    }
+    const [, ...domain] = hostname.split('.');
+    return `.${domain.join('.')}`;
+}
+exports.getDomainWithoutSubdomain = getDomainWithoutSubdomain;

package/dist/utils/getTrackerCategory.d.ts

@@ -0,0 +1,3 @@
+import { Config, ConfigCategoryInfo } from '../types';
+declare const getTrackerCategory: (trackerId: string, config: Config) => ConfigCategoryInfo | undefined;
+export default getTrackerCategory;

package/dist/utils/getTrackerCategory.js

@@ -0,0 +1,11 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const trackerMatches_1 = __importDefault(require("./trackerMatches"));
+const getTrackerCategory = (trackerId, config) => {
+    const category = config.categories.find((category) => category.trackers.find((tracker) => (0, trackerMatches_1.default)(tracker, trackerId)));
+    return category;
+};
+exports.default = getTrackerCategory;

package/dist/utils/getTrackerInfo.d.ts

@@ -0,0 +1,3 @@
+import { Config } from '../types';
+declare const getTrackerInfo: (trackerId: string, config: Config) => import("../types").Tracker | undefined;
+export default getTrackerInfo;

package/dist/utils/getTrackerInfo.js

@@ -0,0 +1,12 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const getTrackerCategory_1 = __importDefault(require("./getTrackerCategory"));
+const trackerMatches_1 = __importDefault(require("./trackerMatches"));
+const getTrackerInfo = (trackerId, config) => {
+    const trackingCategory = (0, getTrackerCategory_1.default)(trackerId, config);
+    return trackingCategory === null || trackingCategory === void 0 ? void 0 : trackingCategory.trackers.find((tracker) => (0, trackerMatches_1.default)(tracker, trackerId));
+};
+exports.default = getTrackerInfo;

package/dist/utils/hasConsent.d.ts

@@ -0,0 +1,11 @@
+import { Config, TrackingPreference } from '../types';
+/**
+ * Used for determining if a specific tracker has user consent.
+ * It follows the following logic in order:
+ * 1) If we don't have a tracker category in the config then dont allow
+ * 2) If cookie is in a required category then allow
+ * 3) If cookie is required for cookie manager to function then allow
+ * 4) Determine consent from user consent preferences
+ */
+declare const hasConsent: (tracker: string, config: Config, trackingPreference: TrackingPreference) => boolean;
+export default hasConsent;

package/dist/utils/hasConsent.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const constants_1 = require("../constants");
+const getTrackerCategory_1 = __importDefault(require("./getTrackerCategory"));
+/**
+ * Used for determining if a specific tracker has user consent.
+ * It follows the following logic in order:
+ * 1) If we don't have a tracker category in the config then dont allow
+ * 2) If cookie is in a required category then allow
+ * 3) If cookie is required for cookie manager to function then allow
+ * 4) Determine consent from user consent preferences
+ */
+const hasConsent = (tracker, config, trackingPreference) => {
+    const trackingCategory = (0, getTrackerCategory_1.default)(tracker, config);
+    if (constants_1.REQUIRED_COOKIE_MANAGER_COOKIES.includes(tracker)) {
+        return true;
+    }
+    if (!trackingCategory) {
+        return false;
+    }
+    if (trackingCategory.required) {
+        return true;
+    }
+    return trackingPreference.consent.includes(trackingCategory.id);
+};
+exports.default = hasConsent;

package/dist/utils/isMaxKBSize.d.ts

@@ -0,0 +1,2 @@
+declare const isMaxKBSize: (str: string, max: number) => boolean;
+export default isMaxKBSize;

package/dist/utils/isMaxKBSize.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const constants_1 = require("../constants");
+const isMaxKBSize = (str, max) => {
+    return Buffer.from(str).length / constants_1.KB > max;
+};
+exports.default = isMaxKBSize;

package/dist/utils/isOptOut.d.ts

@@ -0,0 +1,16 @@
+import { Region } from '../types';
+/**
+ * Used for determining the if current region is using the optOut framework
+ * It follows the following logic in order:
+ * 1) If there's no geolocation rule for the specified region
+ *  then use the rule for DEFAULT region
+ *  - Otherwise use the DEFAULT_FRAMEWORK
+ * 2) Use geolocation rule
+ */
+/**
+ * optIn: Users must opt in to tracking (EU)
+ * optOut: Users must opt out of tracking (non-EU)
+ * We use the most restrictive framework (optIn) if we don't know the framework
+ */
+declare const isOptOut: (region: Region) => boolean;
+export default isOptOut;

package/dist/utils/isOptOut.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const constants_1 = require("../constants");
+const types_1 = require("../types");
+/**
+ * Used for determining the if current region is using the optOut framework
+ * It follows the following logic in order:
+ * 1) If there's no geolocation rule for the specified region
+ *  then use the rule for DEFAULT region
+ *  - Otherwise use the DEFAULT_FRAMEWORK
+ * 2) Use geolocation rule
+ */
+/**
+ * optIn: Users must opt in to tracking (EU)
+ * optOut: Users must opt out of tracking (non-EU)
+ * We use the most restrictive framework (optIn) if we don't know the framework
+ */
+const isOptOut = (region) => {
+    const rule = constants_1.GEOLOCATION_RULES.find((r) => r.region === region);
+    if (!rule) {
+        return true;
+    }
+    return rule.framework === types_1.Framework.OPT_OUT;
+};
+exports.default = isOptOut;

package/dist/utils/persistMobileAppPreferences.d.ts

@@ -0,0 +1,2 @@
+export declare function persistMobileAppPreferences(): void;
+export declare function getIsMobileAppFromQueryParams(): boolean;

package/dist/utils/persistMobileAppPreferences.js

@@ -0,0 +1,36 @@
+"use strict";
+/*
+ * The purpose here is to allow the iOS/Android app to send a is_mobile_app=true
+ * parameter that should indicate to the web surfaces not to show the
+ * cookie banner
+ *
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getIsMobileAppFromQueryParams = exports.persistMobileAppPreferences = void 0;
+const constants_1 = require("../constants");
+const getDomain_1 = require("./getDomain");
+function persistMobileAppPreferences() {
+    try {
+        const isMobileApp = getIsMobileAppFromQueryParams();
+        if (isMobileApp) {
+            document.cookie = `${constants_1.IS_MOBILE_APP}=true; domain=${(0, getDomain_1.getDomainWithoutSubdomain)()}`;
+        }
+    }
+    catch (e) {
+        // Ignore, we are not in a browser.
+    }
+}
+exports.persistMobileAppPreferences = persistMobileAppPreferences;
+function getIsMobileAppFromQueryParams() {
+    try {
+        const params = new URLSearchParams(window.location.search);
+        const isWebView = params.get('webview') === 'true';
+        const isMobileApp = params.get(constants_1.IS_MOBILE_APP) === 'true';
+        return Boolean(isWebView || isMobileApp);
+    }
+    catch (e) {
+        // Ignore, we are not in a browser.
+    }
+    return false;
+}
+exports.getIsMobileAppFromQueryParams = getIsMobileAppFromQueryParams;

package/dist/utils/setGTMVariables.d.ts

@@ -0,0 +1,3 @@
+import { AdTrackingPreference, TrackingPreference } from '../types';
+declare const setGTMVariables: (preference: TrackingPreference, adTrackingPreference: AdTrackingPreference) => void;
+export default setGTMVariables;

package/dist/utils/setGTMVariables.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const setGTMVariables = (preference, adTrackingPreference) => {
+    if (typeof window !== 'undefined') {
+        if (!window.dataLayer)
+            window.dataLayer = [];
+        const gtmData = [
+            { consent: preference.consent },
+            { adConsent: adTrackingPreference.value.toString() },
+        ];
+        window.dataLayer.push(...gtmData);
+    }
+};
+exports.default = setGTMVariables;

package/dist/utils/setTrackingPreference.d.ts

@@ -0,0 +1,4 @@
+import { CookieAttributes } from 'js-cookie';
+import { Region, TrackingPreference } from '../types';
+declare const setTrackingPreference: (setCookie: (name: string, value: any, options?: CookieAttributes) => void, newConsentPreference: TrackingPreference, region: Region, onPreferenceChange?: ((preference: TrackingPreference) => void) | undefined) => void;
+export default setTrackingPreference;

package/dist/utils/setTrackingPreference.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const constants_1 = require("../constants");
+const getDomain_1 = require("./getDomain");
+const setTrackingPreference = (setCookie, newConsentPreference, region, onPreferenceChange) => {
+    const expiration = constants_1.PREFERENCE_EXPIRATION_YEAR * 365;
+    const cookieOptions = {
+        expires: expiration,
+        domain: (0, getDomain_1.getDomainWithoutSubdomain)(),
+        path: '/',
+    };
+    if (region === 'EU') {
+        setCookie(constants_1.EU_CONSENT_PREFERENCES_COOKIE, newConsentPreference, cookieOptions);
+    }
+    else {
+        setCookie(constants_1.DEFAULT_CONSENT_PREFERENCES_COOKIE, newConsentPreference, cookieOptions);
+    }
+    if (onPreferenceChange) {
+        onPreferenceChange(newConsentPreference);
+    }
+};
+exports.default = setTrackingPreference;

package/dist/utils/trackerMatches.d.ts

@@ -0,0 +1,3 @@
+import { Tracker } from '../types';
+declare const trackerMatches: (tracker: Tracker, id: string) => boolean;
+export default trackerMatches;

package/dist/utils/trackerMatches.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const trackerMatches = (tracker, id) => {
+    if (tracker.regex) {
+        const re = new RegExp(tracker.regex);
+        return re.test(id);
+    }
+    else {
+        return tracker.id === id;
+    }
+};
+exports.default = trackerMatches;