web-adsmeasurement 1.8.12

package/es5_dist/kochava.js

@@ -0,0 +1,654 @@
+/*
+  Authored by Jacob Bechler on 6/13/23.
+  Copyright (c) Kochava, Inc. All rights reserved.
+*/
+var __assign = this && this.__assign || function () {
+    __assign = Object.assign || function (t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = this && this.__awaiter || function (thisArg, _arguments, P, generator) {
+    function adopt(value) {
+        return value instanceof P ? value : new P(function (resolve) {
+            resolve(value);
+        });
+    }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) {
+            try {
+                step(generator.next(value));
+            } catch (e) {
+                reject(e);
+            }
+        }
+        function rejected(value) {
+            try {
+                step(generator["throw"](value));
+            } catch (e) {
+                reject(e);
+            }
+        }
+        function step(result) {
+            result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+        }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = this && this.__generator || function (thisArg, body) {
+    var _ = { label: 0, sent: function () {
+            if (t[0] & 1) throw t[1];return t[1];
+        }, trys: [], ops: [] },
+        f,
+        y,
+        t,
+        g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function () {
+        return this;
+    }), g;
+    function verb(n) {
+        return function (v) {
+            return step([n, v]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0:case 1:
+                    t = op;break;
+                case 4:
+                    _.label++;return { value: op[1], done: false };
+                case 5:
+                    _.label++;y = op[1];op = [0];continue;
+                case 7:
+                    op = _.ops.pop();_.trys.pop();continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];t = op;break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];_.ops.push(op);break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [6, e];y = 0;
+        } finally {
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __rest = this && this.__rest || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+        if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
+    }
+    return t;
+};
+import { Log } from "./utils/log";
+import JobQueue from "./jobqueue";
+import * as Config from "./payloads/config";
+import { DEFAULTS } from "./interfaces";
+import { deleteAllPersisted, readAndUpdatePersistedValue, updatePersistedValue, PersistKey, readPersistedConfig, readAndUpdateInstallId, readPersistedCustomDeviceIdentifiers } from "./browser/persist";
+import * as utils from "./utils/utils";
+import { Product } from "./product";
+// Re-export Product so framework harnesses (React, Vue, Angular, ReactNative)
+// can import both PubSuite and Product from a single module reference, matching
+// K4A's pattern.  Parity with K4A's src/kochava.ts which re-exports Product.
+export { Product } from "./product";
+var PubSuite = /** @class */function () {
+    // User will use the below factories instead of directly calling
+    // the constructor
+    function PubSuite() {
+        this.product = Product.adsmeasurement;
+        this.resetInstance();
+        this.jobQueue = new JobQueue();
+    }
+    // ============================= PUBLIC =============================== //
+    PubSuite.create = function () {
+        return new PubSuite();
+    };
+    // Framework-specific factories.  Parity with K4A's PubSuite/Kochava factory
+    // pattern so the framework harnesses (and any framework integrations) can
+    // instantiate via a per-framework entry point.  For now each delegates to
+    // create(); per-framework configuration can park here later.
+    PubSuite.createForReact = function () {
+        return PubSuite.create();
+    };
+    PubSuite.createForVue = function () {
+        return PubSuite.create();
+    };
+    PubSuite.createForAngular = function () {
+        return PubSuite.create();
+    };
+    PubSuite.createForReactNative = function () {
+        return PubSuite.create();
+    };
+    PubSuite.prototype.startWithConfig = function (config) {
+        var _a, _b, _c, _d;
+        Log.diagInfo("Host called API: Start With Config");
+        var event_metadata = config.event_metadata,
+            rest = __rest(config, ["event_metadata"]);
+        this.instance.HostConfig = __assign({ conversion_metadata: event_metadata }, rest);
+        this.start((_b = (_a = this.instance.HostConfig.general) === null || _a === void 0 ? void 0 : _a.product_id) !== null && _b !== void 0 ? _b : "", (_d = (_c = this.instance.HostConfig.general) === null || _c === void 0 ? void 0 : _c.access_token) !== null && _d !== void 0 ? _d : "");
+    };
+    PubSuite.prototype.startWithProductId = function (product_id, access_token) {
+        Log.diagInfo("Host called API: Start With Product ID");
+        this.start(product_id, access_token);
+    };
+    /*
+      The primary means for starting the sdk.
+      Responsibilites:
+      - Creates the sdk instance.
+      - Checks for persisted state.
+      - Determines and applies config.
+      - Starts the job queue.
+    */
+    PubSuite.prototype.start = function (product_id, access_token) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!product_id) {
+                            Log.error("Invalid product_id: ".concat(product_id, ", start failed."));
+                            return [2 /*return*/];
+                        }
+                        if (!access_token) {
+                            Log.error("Invalid access_token: ".concat(access_token, ", start failed."));
+                            return [2 /*return*/];
+                        }
+                        if (!this.instance) this.resetInstance();
+                        if (this.instance.started) {
+                            Log.warn("SDK already started.");
+                            return [2 /*return*/];
+                        }
+                        this.instance.started = true;
+                        this.checkFirstLaunch();
+                        this.initInstance(product_id, access_token);
+                        if (!!this.instance.configDone) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.performNewConfig()];
+                    case 1:
+                        _a.sent();
+                        _a.label = 2;
+                    case 2:
+                        this.checkPersistedState();
+                        this.printStartupMsgs(product_id);
+                        this.enableElementTracking();
+                        this.beginStart();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /*
+      Builds and enqueues a conversion. Must include a conversion_name string,
+      with optional conversion_data as either another string or object.
+    */
+    PubSuite.prototype.sendConversion = function (name, data, override_access_token, override_product_id) {
+        Log.diagInfo("Host called API: Send Conversion");
+        if (!name) {
+            Log.warn("Invalid Conversion name, ignoring call.");
+            return;
+        }
+        if (this.instance.sessionConfig.enabled) {
+            this.updateSessionState();
+        }
+        this.jobQueue.enqueueConversion(this.instance, [name, data, override_access_token, override_product_id]);
+    };
+    /*
+      Returns whether or not the sdk is in a "started" state.
+      This basically amounts to if start has been called,
+      not if config is done or the queue is started.
+      Likewise, shutdown will set "started" to false;
+    */
+    PubSuite.prototype.getStarted = function () {
+        return this.instance.started;
+    };
+    PubSuite.prototype.registerCustomDeviceIdentifier = function (name, value) {
+        Log.diagInfo("Host called API: Register Custom Device Identifier ".concat(value ? 'setting' : 'clearing', " ").concat(name));
+        if (!name) {
+            Log.warn("Invalid custom device identifier, ignoring call.");
+            return;
+        }
+        var persistedCustomDeviceIds = readPersistedCustomDeviceIdentifiers(this.instance.useCookies);
+        if (persistedCustomDeviceIds) {
+            this.instance.customDeviceIds = JSON.parse(persistedCustomDeviceIds);
+        }
+        this.instance.customDeviceIds = this.instance.customDeviceIds.filter(function (id) {
+            return id.name !== name;
+        });
+        if (value) {
+            var newCustomDeviceId = {
+                name: name.substring(0, 256),
+                value: value.substring(0, 256)
+            };
+            this.instance.customDeviceIds.push(newCustomDeviceId);
+            if (this.instance.customDeviceIds.length > 100) {
+                this.instance.customDeviceIds = this.instance.customDeviceIds.slice(-100);
+            }
+        }
+        updatePersistedValue(PersistKey.CustomDeviceIdentifiers, JSON.stringify(this.instance.customDeviceIds), this.instance.useCookies);
+    };
+    /*
+      Puts the sdk in a "sleep" state. This will stop the sdk from dequeuing
+      new jobs and retrying failed jobs. Different than shutdown, because the
+      current state is not destroyed.
+    */
+    PubSuite.prototype.setSleep = function (sleep) {
+        Log.diagInfo("Host called API: Sleep ".concat(sleep ? "Stop" : "Start"));
+        if (sleep && !this.instance.sleep) {
+            // only pause if it was running
+            this.instance.sleep = sleep;
+            this.jobQueue.pause();
+        } else if (!sleep && this.instance.sleep) {
+            // only resume queueing if it was paused
+            this.instance.sleep = sleep;
+            this.beginStart();
+        }
+    };
+    /*
+      Primary means for stopping the sdk.
+      Will optionally delete all persisted data, and will shutdown the
+      sdk and job queue.
+    */
+    PubSuite.prototype.shutdown = function (deleteData) {
+        Log.diagInfo("Host called API: Shutdown and ".concat(deleteData ? "delete data" : "keep data"));
+        if (deleteData) {
+            Log.debug("Deleting persisted values");
+            deleteAllPersisted();
+        }
+        if (!this.instance.started) {
+            Log.warn("SDK already shutdown.");
+        }
+        Log.info("SDK shutting down.");
+        Config.cancelRetries();
+        this.jobQueue.stop();
+        // wipe whatever was previously in the queue
+        this.jobQueue = new JobQueue();
+        this.resetInstance();
+    };
+    /*
+      Changes the current logLevel.
+      Options include:
+      - Off   :: No logging whatsoever
+      - Error :: Only critical errors
+      - Warn  :: Only critical errors and non-critical warnings
+      - Info  :: High-level sdk behavior logs (default)
+      - Debug :: More in-depth sdk behavior logs and payload logs
+      - Trace :: Everything, granular detail
+    */
+    PubSuite.prototype.setLogLevel = function (logLevel) {
+        Log.diagInfo("Host called API: Set Log Level ".concat(logLevel));
+        Log.setLogLevel(logLevel);
+    };
+    /*
+      Used internally, for special SDK behavior not utilized by a client.
+      Examples include:
+      - urls    :: purposefully changing an endpoint for testing
+      - wrapper :: overwriting the version of a wrapper
+      several more ...
+    */
+    PubSuite.prototype.executeAdvancedInstruction = function (key, valueStr, callback) {
+        Log.diagInfo("Host called API: Execute Advanced Instruction ".concat(key));
+        switch (key) {
+            case "wrapper":
+                {
+                    var wrapperVersion = JSON.parse(valueStr);
+                    Product.adsmeasurement.wrapperProduct = new Product("Product.wrapper", wrapperVersion.name, wrapperVersion.name, wrapperVersion.version, "");
+                    this.instance.version = Product.adsmeasurement.standardVersionInfoString;
+                }
+                break;
+            case "urls":
+                {
+                    var overrideUrls = JSON.parse(valueStr);
+                    if (overrideUrls.config) this.instance.overrideUrls.serverConfig = overrideUrls.config;
+                    if (overrideUrls.conversion) this.instance.overrideUrls.conversion = overrideUrls.conversion;
+                }
+                break;
+            case "urlsRestore":
+                {
+                    var restoreUrls = JSON.parse(valueStr);
+                    for (var _i = 0, restoreUrls_1 = restoreUrls; _i < restoreUrls_1.length; _i++) {
+                        var url = restoreUrls_1[_i];
+                        if (url === "config") this.instance.overrideUrls.hostServerConfig = DEFAULTS.networking.urls.serverConfig;
+                        if (url === "conversion") this.instance.overrideUrls.conversion = DEFAULTS.networking.urls.conversion;
+                    }
+                }
+                break;
+            case "logFilter":
+                {
+                    var disabled = JSON.parse(valueStr);
+                    disabled.forEach(function (level) {
+                        return Log.disableLogType(level);
+                    });
+                }
+                break;
+            case "getInstance":
+                {
+                    var currInstance = JSON.stringify(this.instance);
+                    if (callback) callback(currInstance);
+                    Log.debug("capturing instance: ".concat(valueStr));
+                }
+                break;
+            case "logObjects":
+                Log.setLogObjects(JSON.parse(valueStr));
+                break;
+            case "pInstance":
+                return JSON.stringify(this.instance);
+                break;
+            default:
+                break;
+        }
+    };
+    PubSuite.prototype.enableElementTracking = function (condition) {
+        if (condition === void 0) {
+            condition = true;
+        }
+        if (this.boundClickHandler) {
+            document.removeEventListener('click', this.boundClickHandler);
+        }
+        if (condition) {
+            this.boundClickHandler = this.ClickHandler.bind(this);
+            if (this.boundClickHandler) {
+                document.addEventListener('click', this.boundClickHandler);
+            }
+        } else {
+            this.boundClickHandler = null;
+        }
+    };
+    // Unintialized/invalid state.
+    // start must be called before these values will be correct.
+    PubSuite.prototype.resetInstance = function () {
+        // Log.diagDebug("RESETTING INSTANCE.")
+        this.instance = {
+            product_id: "",
+            access_token: "",
+            started: false,
+            configDone: false,
+            HostConfig: {
+                general: {},
+                config: {
+                    refresh_minimum: 60
+                },
+                networking: {
+                    urls: {
+                        config: "",
+                        conversion: ""
+                    },
+                    retry_waterfall: [7, 30, 300, 1800]
+                },
+                sessions: {
+                    enabled: false,
+                    timeout: 1800
+                }
+            },
+            customDataAttribute: 'data-ps-conversion',
+            element_conversions: [],
+            button_conversions: [],
+            useCookies: false,
+            collectReferrer: false,
+            collectUrl: false,
+            sleep: false,
+            version: Product.adsmeasurement.standardVersionInfoString,
+            buildDate: Product.adsmeasurement.sdkBuildDate,
+            collect_ga: false,
+            overrideUrls: {
+                serverConfig: "",
+                hostServerConfig: "",
+                conversion: ""
+            },
+            customDeviceIds: [],
+            conversion_metadata: {},
+            pubSuiteSession: "",
+            retryWaterfall: [],
+            startTimeMS: 0,
+            sdk_disabled: false,
+            instance_id: '',
+            installIdEnabled: false,
+            pubSuiteSessionCount: -1,
+            pubSuiteConfig: undefined,
+            pubSuiteInstallId: '',
+            sessionConfig: {
+                enabled: false,
+                timeout: 1800
+            },
+            sessionState: {
+                last_activity_time: 0,
+                session_time: 0,
+                count: 0
+            }
+        };
+    };
+    PubSuite.prototype.initInstance = function (product_id, access_token) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;
+        // init instance with defaults
+        this.instance.product_id = product_id;
+        this.instance.access_token = access_token;
+        this.instance.version = Product.adsmeasurement.standardVersionInfoString;
+        this.instance.buildDate = Product.adsmeasurement.sdkBuildDate;
+        this.instance.pubSuiteSession = utils.uuidv4().substring(0, 5);
+        this.instance.startTimeMS = utils.getCurrTimeMS();
+        this.instance.retryWaterfall = [7, 30, 300, 1800];
+        this.instance.instance_id = utils.uuidv4().substring(0, 5);
+        this.instance.installIdEnabled = (_b = (_a = this.instance.HostConfig.general) === null || _a === void 0 ? void 0 : _a.install_id_enabled) !== null && _b !== void 0 ? _b : false;
+        this.instance.useCookies = (_e = ((_c = this.instance.HostConfig.general) === null || _c === void 0 ? void 0 : _c.cookies_enabled) || ((_d = this.instance.HostConfig.general) === null || _d === void 0 ? void 0 : _d.pers_tr)) !== null && _e !== void 0 ? _e : false;
+        this.instance.sessionConfig.enabled = (_g = (_f = this.instance.HostConfig.sessions) === null || _f === void 0 ? void 0 : _f.enabled) !== null && _g !== void 0 ? _g : false;
+        this.instance.sessionConfig.timeout = (_j = (_h = this.instance.HostConfig.sessions) === null || _h === void 0 ? void 0 : _h.timeout) !== null && _j !== void 0 ? _j : 1800;
+        this.instance.collectReferrer = (_l = (_k = this.instance.HostConfig.general) === null || _k === void 0 ? void 0 : _k.collect_page_info) !== null && _l !== void 0 ? _l : false;
+        this.instance.collectUrl = (_o = (_m = this.instance.HostConfig.general) === null || _m === void 0 ? void 0 : _m.collect_page_info) !== null && _o !== void 0 ? _o : false;
+        this.instance.pubSuiteConfig = JSON.parse(JSON.stringify(DEFAULTS));
+    };
+    PubSuite.prototype.checkFirstLaunch = function () {
+        // If this is our first launch ever, set it in persistence.
+        if (!readAndUpdatePersistedValue(PersistKey.FirstStartDate)) {
+            updatePersistedValue(PersistKey.FirstStartDate, String(utils.getCurrTimeSec()));
+        }
+    };
+    PubSuite.prototype.checkPersistedState = function () {
+        // this.instance.pubSuiteSessionCount = readAndUpdateSessionCount();
+        if (this.instance.installIdEnabled) this.instance.pubSuiteInstallId = readAndUpdateInstallId(this.instance.useCookies);
+        if (this.instance.sessionConfig.enabled) {
+            var persistedSessionTime = parseInt(readAndUpdatePersistedValue(PersistKey.SessionTime));
+            this.instance.sessionState.session_time = isNaN(persistedSessionTime) ? 0 : persistedSessionTime;
+            var persistedLastActivityTime = parseInt(readAndUpdatePersistedValue(PersistKey.LastActivityTime));
+            this.instance.sessionState.last_activity_time = isNaN(persistedLastActivityTime) ? 0 : persistedLastActivityTime;
+            var persistedSessionCount = parseInt(readAndUpdatePersistedValue(PersistKey.SessionCount));
+            this.instance.sessionState.count = isNaN(persistedSessionCount) ? 0 : persistedSessionCount;
+        }
+        var persistedCustomDeviceIds = readPersistedCustomDeviceIdentifiers(this.instance.useCookies);
+        if (persistedCustomDeviceIds) {
+            var restoredCustomDeviceIds = JSON.parse(persistedCustomDeviceIds);
+            this.instance.customDeviceIds = restoredCustomDeviceIds;
+        }
+    };
+    PubSuite.prototype.printStartupMsgs = function (product_id) {
+        var adsmeasurementProduct = Product.adsmeasurement;
+        Log.diagInfo("Started SDK ".concat(adsmeasurementProduct.standardVersionInfoString, "\n      published ").concat(adsmeasurementProduct.sdkBuildDate));
+        Log.diagInfo("The log level is set to ".concat(Log.getLogLevel()));
+        Log.diagDebug("The product ID provided was '".concat(product_id, "'"));
+    };
+    PubSuite.prototype.beginStart = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (this.instance.sleep) return [2 /*return*/];
+                        if (this.instance.sessionConfig.enabled) this.updateSessionState();
+                        return [4 /*yield*/, this.jobQueue.start(this.instance)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    PubSuite.prototype.performNewConfig = function () {
+        var _a, _b, _c, _d;
+        return __awaiter(this, void 0, void 0, function () {
+            var config, serverConfig, hostServerConfig;
+            return __generator(this, function (_e) {
+                switch (_e.label) {
+                    case 0:
+                        if (this.instance.HostConfig) config = Config.mergeConfig((_a = this.instance.pubSuiteConfig) !== null && _a !== void 0 ? _a : {}, this.instance.HostConfig);
+                        if (!Config.ConfigExpired(this.instance)) return [3 /*break*/, 2];
+                        return [4 /*yield*/, Config.getServerConfig(this.instance, this.instance.retryWaterfall)];
+                    case 1:
+                        _e.sent();
+                        _e.label = 2;
+                    case 2:
+                        serverConfig = readPersistedConfig(PersistKey.LastServerConfig);
+                        if (!!((_b = serverConfig === null || serverConfig === void 0 ? void 0 : serverConfig.general) === null || _b === void 0 ? void 0 : _b.sdk_disabled)) return [3 /*break*/, 4];
+                        if (!(((_d = (_c = config.networking) === null || _c === void 0 ? void 0 : _c.urls) === null || _d === void 0 ? void 0 : _d.config) && Config.ConfigExpired(this.instance))) return [3 /*break*/, 4];
+                        return [4 /*yield*/, Config.getHostServerConfig(this.instance, this.instance.retryWaterfall)];
+                    case 3:
+                        _e.sent();
+                        hostServerConfig = readPersistedConfig(PersistKey.LastHostServerConfig);
+                        _e.label = 4;
+                    case 4:
+                        if (hostServerConfig) config = Config.mergeConfig(config, hostServerConfig);
+                        config = Config.mergeConfig(config, serverConfig !== null && serverConfig !== void 0 ? serverConfig : {});
+                        Config.applyConfigResp(this.instance, config);
+                        updatePersistedValue(PersistKey.LastConfigDate, String(utils.getCurrTimeSec()));
+                        this.instance.configDone = true;
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    PubSuite.prototype.updateSessionState = function () {
+        var currTime = utils.getCurrTimeSec();
+        var activityDiff = currTime - this.instance.sessionState.last_activity_time;
+        this.instance.sessionState.last_activity_time = currTime;
+        updatePersistedValue(PersistKey.LastActivityTime, String(this.instance.sessionState.last_activity_time), this.instance.useCookies);
+        if (activityDiff > this.instance.sessionConfig.timeout) {
+            this.instance.sessionState.count++;
+            this.instance.sessionState.session_time = currTime;
+            this.sendConversion("session_start");
+        }
+        updatePersistedValue(PersistKey.SessionTime, this.instance.sessionState.session_time.toString(), this.instance.useCookies);
+        updatePersistedValue(PersistKey.SessionCount, String(this.instance.sessionState.count), this.instance.useCookies);
+    };
+    PubSuite.prototype.reportUserActivity = function () {
+        this.updateSessionState();
+    };
+    PubSuite.prototype.ClickHandler = function (event) {
+        var _a;
+        var targetElement = event.target;
+        var targetTag = targetElement.tagName;
+        var conversion_name = null;
+        if (this.instance.button_conversions && (targetTag === "INPUT" || targetTag === "BUTTON")) {
+            var buttonText = targetTag === "INPUT" ? targetElement.value : targetElement.textContent;
+            if (this.instance.button_conversions[buttonText]) {
+                conversion_name = this.instance.button_conversions[buttonText];
+            }
+        }
+        if (targetElement.hasAttribute(this.instance.customDataAttribute)) {
+            conversion_name = targetElement.getAttribute(this.instance.customDataAttribute);
+        }
+        if (this.instance.element_conversions[targetElement.id]) {
+            conversion_name = this.instance.element_conversions[targetElement.id];
+        }
+        if (conversion_name) {
+            this.sendConversion(conversion_name, (_a = this.instance.conversion_metadata) !== null && _a !== void 0 ? _a : {});
+            return;
+        }
+        if (Object.keys(this.instance.button_conversions).length && Object.keys(this.instance.element_conversions).length) {
+            Log.trace('Element conversions and button conversions are configured, but neither the ID of this element nor the button text match any in the element_conversions or button_text list provided in the config on startup.');
+        } else if (Object.keys(this.instance.element_conversions).length) {
+            Log.trace('Element conversions are configured, but the ID of this element does not match any in the element_conversions list provided in the config on startup');
+        } else if (Object.keys(this.instance.button_conversions).length) {
+            Log.trace('Button conversions are configured, but the text of this element does not match any in the button_conversions list provided in the config on startup');
+        }
+    };
+    PubSuite.prototype.Impressions = function () {
+        window.addEventListener("load", function () {
+            // Executes when visible for more than a second
+            function visibleForOneSecond(element) {
+                window.pubSuite.sendConversion(element.id);
+            }
+            // Observer Callback
+            function intersectionCallback(entries, observer) {
+                entries.forEach(function (entry) {
+                    if (entry.isIntersecting) {
+                        var target_1 = entry.target;
+                        var timerId = setTimeout(function () {
+                            var rect = entry.target.getBoundingClientRect();
+                            if (fourCornersVisible(target_1)) {
+                                visibleForOneSecond(target_1);
+                                observer.unobserve(target_1);
+                            }
+                        }, 1000);
+                        target_1._visibilityTimer = timerId;
+                    } else {
+                        clearTimeout(entry.target._visibilityTimer);
+                    }
+                });
+            }
+            // Create the intersection observer
+            var observer = new IntersectionObserver(intersectionCallback, {
+                threshold: 1.0 // Trigger when 100% of the element is visible
+            });
+            // Observe elements with the specified class name (e.g. '.watched-element')
+            var elementsToWatch = document.querySelectorAll('[data-pubSuiteTrack]');
+            elementsToWatch.forEach(function (element) {
+                return observer.observe(element);
+            });
+            function fourCornersVisible(target) {
+                var rect = target.getBoundingClientRect();
+                var topLeftVisible = pointIsVisible(target, rect.left, rect.top);
+                var topRightVisible = pointIsVisible(target, rect.right - 1, rect.top + 1);
+                var botLeftVisible = pointIsVisible(target, rect.left + 1, rect.bottom - 1);
+                var botRightVisible = pointIsVisible(target, rect.right - 1, rect.bottom - 1);
+                return topLeftVisible && topRightVisible && botLeftVisible && botRightVisible;
+            }
+            function pointIsVisible(target, x, y) {
+                var topElement = document.elementFromPoint(x, y);
+                return target === topElement || target.contains(topElement);
+            }
+        }, false);
+    };
+    return PubSuite;
+}();
+export { PubSuite };
+var sdk_instance = PubSuite.create();
+window.pubSuite = sdk_instance;
+function initSDK(currentScript, sdkInstance) {
+    if (!currentScript) return;
+    var sdkName = currentScript.getAttribute('data-sdk-name') || 'pubSuite';
+    var sdkTag = currentScript.getAttribute('data-sdk-tag');
+    var sdkNameRegex = /^[A-Za-z_][A-Za-z0-9_]*$/;
+    var sdkTagRegex = /^[A-Z]{2}$/;
+    if (!sdkNameRegex.test(sdkName)) {
+        Log.warn('Invalid SDK Name provided. SDK Name must start with a letter or underscore, and contain only letters, numbers, and underscores.');
+        return;
+    }
+    if (!sdkTag) {
+        Log.initLog(sdkName);
+    } else {
+        if (sdkTagRegex.test(sdkTag)) {
+            Log.initLog(sdkName, sdkTag);
+        } else {
+            Log.warn('Invalid SDK Tag provided. SDK Tag must be exactly two uppercase letters.');
+        }
+    }
+    window[sdkName] = sdkInstance;
+}
+initSDK(document.currentScript, sdk_instance);
+//# sourceMappingURL=kochava.js.map