kv-test-lib 3.5.2-rc.2 → 3.5.2-rc.3

package/es5_dist/kochava.js

@@ -90,10 +90,6 @@ var __generator = this && this.__generator || function (thisArg, body) {
         if (op[0] & 5) throw op[1];return { value: op[0] ? op[1] : void 0, done: true };
     }
 };
-/*
-  Authored by Jacob Bechler on 06/09/25.
-  Copyright (c) Kochava, Inc. All rights reserved.
-*/
 import './polyfills/browser.js';
 import 'whatwg-fetch';
 import { Log } from "./utils/log";
@@ -111,20 +107,13 @@ import { getCookie } from "./browser/cookies";
 import adapter from './adapters/adapter.browser.js';
 import { Product } from "./product";
 configureStorage(adapter);
-var Kochava = /** @class */function () {
-    // User will use the below factories instead of directly calling
-    // the constructor
+var Kochava = function () {
     function Kochava() {
         this.product = Product.measurement;
-        // Readiness barrier for the persisted-identity restore.  Resolves
-        // immediately in synchronous-storage environments (browser) and when the
-        // async restore completes otherwise (React Native).  Assigned in
-        // _resetInstance().
         this._stateRestored = Promise.resolve();
         this._resetInstance();
         this._jobQueue = new JobQueue();
     }
-    // ============================= PUBLIC =============================== //
     Kochava.create = function () {
         return new Kochava();
     };
@@ -153,26 +142,12 @@ var Kochava = /** @class */function () {
         kochava.executeAdvancedInstruction("wrapper", JSON.stringify({ name: "Angular", version: "1.0.0" }));
         return kochava;
     };
-    /*
-    Set if the SDK should also store persisted values in cookie storage.
-    - Not all values can be persisted in cookies, such as event/idlink queues
-    due to size constraints.
-    - true = yes use cookies
-    - no = no don't use cookies
-    - defaults to false
-    */
     Kochava.prototype.useCookies = function (condition) {
         if (condition === void 0) {
             condition = false;
         }
         this._instance.useCookies = condition;
     };
-    /*
-      - Set whether the sdk shouldn't automatically send a page or should.
-      - true = no auto page
-      - false = yes auto page
-      - defaults to false
-    */
     Kochava.prototype.disableAutoPage = function (condition) {
         if (condition === void 0) {
             condition = false;
@@ -193,32 +168,7 @@ var Kochava = /** @class */function () {
         }
         return new KochavaMeasurementEvent(this, eventName);
     };
-    /*
-      The primary means for starting the sdk.
-      Responsibilites:
-      - Checks for migrations.
-      - Creates the sdk instance.
-      - Checks for persisted state.
-      - Determines and sends kvinit.
-      - Determines and sends install.
-      - Optionally enqueues an auto_page.
-      - Starts the job queue.
-    */
-    /**
-     * Start the SDK.
-     *
-     * Returns a promise that resolves once startup reaches the "started"
-     * milestone — install identity resolved, session/appGuid established, and
-     * kvinit/install kicked off.  It intentionally does NOT wait for
-     * kvinit/install to complete: those retry indefinitely on network failure,
-     * and awaiting them would hang the caller with no connectivity.  Existing
-     * void-context callers are unaffected by the added return value.
-     */
     Kochava.prototype.startWithAppGuid = function (appGuid) {
-        // shutdown() swaps in the fresh instance synchronously, so by the time this
-        // runs (even on the line right after a shutdown), this._instance is already
-        // the new instance — no serialization needed.  _startWithAppGuid captures it
-        // up front and operates only on that captured reference.
         return this._startWithAppGuid(appGuid);
     };
     Kochava.prototype._startWithAppGuid = function (appGuid) {
@@ -227,136 +177,95 @@ var Kochava = /** @class */function () {
             return __generator(this, function (_c) {
                 switch (_c.label) {
                     case 0:
-                        // VALIDATE ELSE RETURN
                         if (!appGuid) {
                             Log.error("Invalid appGuid ".concat(appGuid, ", start failed."));
-                            return [2 /*return*/];
+                            return [2];
                         }
                         instance = this._instance;
                         stateRestored = this._stateRestored;
                         if (instance.started) {
                             Log.warn("Kochava SDK already started.");
-                            return [2 /*return*/];
+                            return [2];
                         }
-                        // Kick the install-identity resolution before control returns to the
-                        // caller when restore has already completed (synchronous storage): the
-                        // resolution's synchronous prefix populates kochavaDeviceId in place, so
-                        // getDeviceId() on the caller's very next line is already correct once
-                        // started flips true below.
                         if (instance.stateRestoredBool) {
                             this._ensureIdentityResolved(instance).catch(function () {});
                         }
-                        // Gen4 gate: started flips true synchronously within this call — the
-                        // long-standing contract getDeviceId() is gated on — so the identity
-                        // resolved by the kick above is readable on the caller's very next line.
-                        // (On asynchronous-storage platforms the id resolves during the awaits
-                        // below, matching the current production behavior there.)
                         instance.started = true;
                         _c.label = 1;
                     case 1:
                         _c.trys.push([1, 3,, 4]);
-                        return [4 /*yield*/, stateRestored];
+                        return [4, stateRestored];
                     case 2:
                         _c.sent();
-                        return [3 /*break*/, 4];
+                        return [3, 4];
                     case 3:
                         _a = _c.sent();
-                        return [3 /*break*/, 4];
+                        return [3, 4];
                     case 4:
                         if (instance.invalidatedBool) {
-                            return [2 /*return*/];
+                            return [2];
                         }
                         _c.label = 5;
                     case 5:
                         _c.trys.push([5, 7,, 8]);
-                        return [4 /*yield*/, this._ensureIdentityResolved(instance)];
+                        return [4, this._ensureIdentityResolved(instance)];
                     case 6:
                         _c.sent();
-                        return [3 /*break*/, 8];
+                        return [3, 8];
                     case 7:
                         _b = _c.sent();
-                        return [3 /*break*/, 8];
+                        return [3, 8];
                     case 8:
                         if (instance.invalidatedBool) {
-                            return [2 /*return*/];
+                            return [2];
                         }
-                        // MAIN
                         Log.diagDebug("Host called API: Start With App Guid ".concat(appGuid));
-                        return [4 /*yield*/, this._checkFirstLaunchAndMigrate(instance)];
+                        return [4, this._checkFirstLaunchAndMigrate(instance)];
                     case 9:
                         _c.sent();
                         if (instance.invalidatedBool) {
-                            return [2 /*return*/];
+                            return [2];
                         }
                         this._initInstance(instance, appGuid);
                         if (!instance.disableAutoPage) this.sendPageEvent();
-                        return [4 /*yield*/, this._checkPersistedState(instance)];
+                        return [4, this._checkPersistedState(instance)];
                     case 10:
                         _c.sent();
                         if (instance.invalidatedBool) {
-                            return [2 /*return*/];
+                            return [2];
                         }
-                        return [4 /*yield*/, this._checkPersistedKvinit(instance)];
+                        return [4, this._checkPersistedKvinit(instance)];
                     case 11:
                         _c.sent();
                         if (instance.invalidatedBool) {
-                            return [2 /*return*/];
+                            return [2];
                         }
                         this._printStartupMsgs(instance, appGuid);
-                        // Kick off the network-dependent startup (kvinit, install, queue) WITHOUT
-                        // awaiting it.  Network completion must not gate this returned promise —
-                        // retries are indefinite, so awaiting would hang a caller with no
-                        // connectivity.
                         this._beginStart(instance).catch(function (e) {
                             return Log.error("Error during startup", e);
                         });
-                        return [2 /*return*/];
+                        return [2];
                 }
             });
         });
     };
-    /*
-      Primary means for stopping the sdk.
-      Will optionally delete all persisted data, and will shutdown the
-      sdk and job queue.
-    */
     Kochava.prototype.shutdown = function (deleteData) {
         Log.diagDebug("Host called API: Shutdown and ".concat(deleteData ? "delete data" : "keep data"));
-        // Capture the instance being torn down.  In-flight startup continuations
-        // hold this same reference and bail on its invalidatedBool, so swapping
-        // this._instance out from under them below can never strand them on the
-        // fresh instance.
         var invalidatedInstance = this._instance;
         if (!invalidatedInstance.started) {
             Log.warn("SDK already shutdown.");
         }
         Log.info("SDK shutting down.");
-        // 1. Invalidate synchronously — every in-flight continuation checks this at
-        //    its next await boundary and exits early (after fulfilling anything it
-        //    owns), so no further side effects occur on this instance.
         invalidatedInstance.invalidatedBool = true;
-        // 2. Resume/stop long-running work so it observes invalidation promptly
-        //    rather than sitting in a retry sleep.  cancelRetries()/stop() resolve
-        //    the pending wait (they no longer merely clear the timer), so the loop
-        //    wakes, sees invalidatedBool, and returns.
         Kvinit.cancelRetries();
         Install.cancelRetries();
         this._jobQueue.stop();
         this._jobQueue = new JobQueue();
-        // 3. Swap in a fresh instance synchronously so a start issued on the very
-        //    next line (even without awaiting this shutdown) runs on the new
-        //    instance.  When deleting data on asynchronous storage, gate the fresh
-        //    instance's restore on the clear so it never reads storage mid-wipe.
-        //    On synchronous storage no gate is needed: an adapter exposing the sync
-        //    fast-path is synchronous under the hood, so the wipe has already landed
-        //    by the time deleteAllPersisted() returns.
         if (deleteData) {
             Log.debug("Deleting persisted values");
         }
         var clearPromise = deleteData ? deleteAllPersisted() : Promise.resolve();
         this._resetInstance(deleteData && !hasSyncStorage() ? clearPromise : undefined);
-        // 4. Complete asynchronously: after the clear (if any) and a bounded drain
-        //    of the invalidated instance's in-flight work, resolve.
         return this._completeShutdown(clearPromise);
     };
     Kochava.prototype._completeShutdown = function (clearPromise) {
@@ -366,31 +275,23 @@ var Kochava = /** @class */function () {
                 switch (_a.label) {
                     case 0:
                         _a.trys.push([0, 2,, 3]);
-                        return [4 /*yield*/, clearPromise];
+                        return [4, clearPromise];
                     case 1:
                         _a.sent();
-                        return [3 /*break*/, 3];
+                        return [3, 3];
                     case 2:
                         e_1 = _a.sent();
                         Log.error("Error deleting persisted values during shutdown", e_1);
-                        return [3 /*break*/, 3];
+                        return [3, 3];
                     case 3:
-                        return [4 /*yield*/, this._drainInvalidated()];
+                        return [4, this._drainInvalidated()];
                     case 4:
                         _a.sent();
-                        return [2 /*return*/];
+                        return [2];
                 }
             });
         });
     };
-    // Bounded event-loop drain.  After invalidation, yield a few macrotask turns
-    // so in-flight work on the just-invalidated instance resumes (its retry waits
-    // were resolved by cancelRetries()/stop()) and bails before we consider
-    // shutdown complete.  This is best-effort quiescence for callers who await
-    // shutdown, never a correctness dependency: a request already in flight
-    // (bounded by the 20s request timeout) can outlive this window, and the
-    // invalidation checks preceding each side effect are what keep any straggler
-    // harmless.  A fixed hop count means it can never hang.
     Kochava.prototype._drainInvalidated = function () {
         return __awaiter(this, void 0, void 0, function () {
             var DRAIN_HOPS, i;
@@ -401,8 +302,8 @@ var Kochava = /** @class */function () {
                         i = 0;
                         _a.label = 1;
                     case 1:
-                        if (!(i < DRAIN_HOPS)) return [3 /*break*/, 4];
-                        return [4 /*yield*/, new Promise(function (resolve) {
+                        if (!(i < DRAIN_HOPS)) return [3, 4];
+                        return [4, new Promise(function (resolve) {
                             return setTimeout(resolve, 0);
                         })];
                     case 2:
@@ -410,34 +311,17 @@ var Kochava = /** @class */function () {
                         _a.label = 3;
                     case 3:
                         i++;
-                        return [3 /*break*/, 1];
+                        return [3, 1];
                     case 4:
-                        return [2 /*return*/];
+                        return [2];
                 }
             });
         });
     };
-    /*
-      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
-    */
     Kochava.prototype.setLogLevel = function (logLevel) {
         Log.diagDebug("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 ...
-    */
     Kochava.prototype.executeAdvancedInstruction = function (key, valueStr, callback) {
         Log.diagDebug("Host called API: Execute Advanced Instruction ".concat(key));
         switch (key) {
@@ -493,10 +377,6 @@ var Kochava = /** @class */function () {
                 break;
         }
     };
-    /*
-      Builds and enqueues a kochava event. Must include an event_name string,
-      with optional event_data as either another string or object.
-    */
     Kochava.prototype.sendEvent = function (name, data) {
         this._sendEvent(name, data);
     };
@@ -508,32 +388,19 @@ var Kochava = /** @class */function () {
                         Log.diagDebug("Host called API: Send Event");
                         if (!name) {
                             Log.warn("Invalid event name, ignoring call.");
-                            return [2 /*return*/];
+                            return [2];
                         }
-                        return [4 /*yield*/, this._jobQueue.enqueueEvent(this._instance, [name, data])];
+                        return [4, this._jobQueue.enqueueEvent(this._instance, [name, data])];
                     case 1:
                         _a.sent();
-                        return [2 /*return*/];
+                        return [2];
                 }
             });
         });
     };
-    /*
-      Wraps the sendEvent call with predefined data specific to page events.
-    */
     Kochava.prototype.sendPageEvent = function (pageName, additionalData) {
         if (pageName) this.sendEvent("page", __assign({ page_name: pageName }, additionalData));else this.sendEvent("page", __assign({ page_name: getPageName() }, additionalData));
     };
-    /**
-     * Register an identity link with the SDK.  Identity links are sent with the install
-     * on first launch, or as standalone requests on subsequent launches.  Duplicate
-     * links (same name and identifier) are ignored.  A maximum of 10 links may be
-     * stored at any time.
-     *
-     * Note: passing an empty identifier currently ignores the call rather than clearing
-     * the stored link — unlike registerCustomValue and registerCustomDeviceIdentifier,
-     * which treat an empty value as a clear.  Task 1214093961771892 tracks the fix.
-     */
     Kochava.prototype.registerIdentityLink = function (name, identifier) {
         this._registerIdentityLink(name, identifier);
     };
@@ -546,35 +413,32 @@ var Kochava = /** @class */function () {
                         Log.diagDebug("Host called API: Register Identity Link ".concat(name));
                         if (!name || !identifier) {
                             Log.warn("Invalid identity link, ignoring call.");
-                            return [2 /*return*/];
+                            return [2];
                         }
-                        return [4 /*yield*/, checkDuplicateIdLink(name, identifier)];
+                        return [4, checkDuplicateIdLink(name, identifier)];
                     case 1:
                         if (_a.sent()) {
                             Log.debug("Duplicate Identity Link found, ignoring.");
-                            return [2 /*return*/];
+                            return [2];
                         }
                         idLink = {};
                         idLink[name] = identifier;
-                        return [4 /*yield*/, addPersistedIdLinks(name, identifier, this._instance.useCookies)];
+                        return [4, addPersistedIdLinks(name, identifier, this._instance.useCookies)];
                     case 2:
                         _a.sent();
-                        return [4 /*yield*/, getItem("com.kochava.tracker.InstallSentDate")];
+                        return [4, getItem("com.kochava.tracker.InstallSentDate")];
                     case 3:
-                        if (!_a.sent()) return [3 /*break*/, 5];
-                        // it will be sent standalone
-                        return [4 /*yield*/, this._jobQueue.enqueueIdLink(this._instance, idLink)];
+                        if (!_a.sent()) return [3, 5];
+                        return [4, this._jobQueue.enqueueIdLink(this._instance, idLink)];
                     case 4:
-                        // it will be sent standalone
                         _a.sent();
                         _a.label = 5;
                     case 5:
-                        return [2 /*return*/];
+                        return [2];
                 }
             });
         });
     };
-    // Allows the client to attach arbitrary data to certain payloads. 
     Kochava.prototype.registerCustomValue = function (name, value) {
         Log.diagDebug("Host called API: Register Custom Value ".concat(value ? 'setting' : 'clearing', " ").concat(name));
         if (!name) {
@@ -591,7 +455,6 @@ var Kochava = /** @class */function () {
         dataToAdorn[name] = value;
         this._instance.customValues.push({ data: dataToAdorn, isDeviceId: false });
     };
-    // Allows the client to attach arbitrary identifiers to go out in the install.
     Kochava.prototype.registerCustomDeviceIdentifier = function (name, value) {
         this._registerCustomDeviceIdentifier(name, value);
     };
@@ -605,7 +468,7 @@ var Kochava = /** @class */function () {
                         Log.diagDebug("Host called API: Register Custom Device Identifier ".concat(value ? 'setting' : 'clearing', " ").concat(name));
                         if (!name) {
                             Log.warn("Invalid custom device identifier, ignoring call.");
-                            return [2 /*return*/];
+                            return [2];
                         }
                         if (!value) {
                             this._instance.customValues = this._instance.customValues.filter(function (cv) {
@@ -616,47 +479,33 @@ var Kochava = /** @class */function () {
                             dataToAdorn[name] = value;
                             this._instance.customValues.push({ data: dataToAdorn, isDeviceId: true });
                         }
-                        return [4 /*yield*/, getItem(PersistKey.InstallSentDate)];
+                        return [4, getItem(PersistKey.InstallSentDate)];
                     case 1:
-                        if (!_b.sent()) return [3 /*break*/, 4];
-                        return [4 /*yield*/, checkAndRecordDeviceIdChange(name, value)];
+                        if (!_b.sent()) return [3, 4];
+                        return [4, checkAndRecordDeviceIdChange(name, value)];
                     case 2:
                         changed = _b.sent();
                         if (!changed) {
                             Log.debug("Custom device identifier ".concat(name, " unchanged, no update needed."));
-                            return [2 /*return*/];
+                            return [2];
                         }
-                        return [4 /*yield*/, this._jobQueue.enqueueUpdate(this._instance, (_a = {}, _a[name] = value, _a))];
+                        return [4, this._jobQueue.enqueueUpdate(this._instance, (_a = {}, _a[name] = value, _a))];
                     case 3:
                         _b.sent();
                         _b.label = 4;
                     case 4:
-                        return [2 /*return*/];
+                        return [2];
                 }
             });
         });
     };
-    /*
-      Returns whether or not the sdk is in a "started" state.
-      This basically amounts to if start has been called,
-      not if kvinit is done or the queue is started.
-      Likewise, shutdown will set "started" to false;
-    */
     Kochava.prototype.getStarted = function () {
         return this._instance.started;
     };
-    /*
-    Returns the current kochavaDeviceId, or "" if called too early.
-    */
     Kochava.prototype.getDeviceId = function () {
         Log.diagDebug("Host called API: Get Kochava Device Id");
         if (this._instance.started) return this._instance.kochavaDeviceId;else return "";
     };
-    /*
-      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.
-    */
     Kochava.prototype.setSleep = function (sleep) {
         return this._setSleep(sleep);
     };
@@ -666,32 +515,23 @@ var Kochava = /** @class */function () {
                 switch (_a.label) {
                     case 0:
                         Log.diagDebug("Host called API: Sleep ".concat(sleep ? "Stop" : "Start"));
-                        if (!(sleep && !this._instance.sleep)) return [3 /*break*/, 1];
-                        // only pause if it was running
+                        if (!(sleep && !this._instance.sleep)) return [3, 1];
                         this._instance.sleep = sleep;
                         this._jobQueue.pause();
-                        return [3 /*break*/, 3];
+                        return [3, 3];
                     case 1:
-                        if (!(!sleep && this._instance.sleep)) return [3 /*break*/, 3];
-                        // only resume queueing if it was paused
+                        if (!(!sleep && this._instance.sleep)) return [3, 3];
                         this._instance.sleep = sleep;
-                        return [4 /*yield*/, this._beginStart(this._instance)];
+                        return [4, this._beginStart(this._instance)];
                     case 2:
                         _a.sent();
                         _a.label = 3;
                     case 3:
-                        return [2 /*return*/];
+                        return [2];
                 }
             });
         });
     };
-    // ============================= =============================== //
-    // Unintialized/invalid state.
-    // start must be called before these values will be correct.
-    //
-    // gate: when provided (shutdown with deleteData on asynchronous storage), the
-    // fresh instance's restore is deferred until the gate resolves — so restore
-    // never reads storage mid-wipe.
     Kochava.prototype._resetInstance = function (gate) {
         var _this = this;
         this._instance = {
@@ -728,118 +568,62 @@ var Kochava = /** @class */function () {
             kochavaInstallDate: -1,
             kochavaConfig: undefined
         };
-        // Restore the persisted identity so the resolution waterfall can run on
-        // demand.  Synchronously when the storage adapter supports it (browser) —
-        // a returning device's id is in memory before control returns; async
-        // otherwise (React Native), with start waiting on _stateRestored.  Restore
-        // only reads: a device with no stored identity keeps "" until the identity
-        // is resolved at start (_resolveInstallIdentity).  Under the Gen4 started
-        // gate nothing can observe pre-start state, so the remaining persisted
-        // state loads at start (_checkPersistedState / _checkPersistedKvinit)
-        // exactly as before.  When gated (shutdown+delete on async storage),
-        // restore runs only after the wipe settles — including a failed wipe, in
-        // which case restoring whatever survived is the honest state; a rejected
-        // gate must never leave the instance permanently unrestored.
         var instance = this._instance;
         this._stateRestored = gate ? gate.catch(function () {}).then(function () {
             return _this._restoreState(instance);
         }) : this._restoreState(instance);
     };
-    // Generate a fresh Kochava device id (kvid).
     Kochava.prototype._generateDeviceId = function () {
         var kvId = "KB".concat(utils.getCurrTimeSec(), "T").concat(utils.uuidv4());
         return kvId.replace(/-/g, "");
     };
-    // Choose the restore path based on the configured storage adapter's
-    // capability.  Sync when available (resolve immediately); async otherwise.
     Kochava.prototype._restoreState = function (instance) {
         if (hasSyncStorage()) {
             try {
                 this._restoreSync(instance);
                 return Promise.resolve();
-            } catch (_a) {
-                // Synchronous storage access threw (e.g. localStorage disabled) —
-                // fall back to the async path rather than leaving state unrestored.
-            }
+            } catch (_a) {}
         }
         return this._restoreAsync(instance);
     };
-    // Synchronous identity restore through the adapter's sync fast-path.
-    // Pure reads — a device with no stored identity keeps "" until the identity
-    // is resolved on demand (_resolveInstallIdentity).
     Kochava.prototype._restoreSync = function (instance) {
         var _a, _b;
         this._applyRestoredIdentity(instance, (_a = getItemSync(PersistKey.DeviceId)) !== null && _a !== void 0 ? _a : "", (_b = getItemSync(PersistKey.OverrideDeviceId)) !== null && _b !== void 0 ? _b : "");
     };
-    // Asynchronous identity restore through the abstracted StorageAdapter, which
-    // routes to AsyncStorage on React Native.  Pure reads, as above.
     Kochava.prototype._restoreAsync = function (instance) {
         return __awaiter(this, void 0, void 0, function () {
             var _a, deviceId, overrideDeviceId;
             return __generator(this, function (_b) {
                 switch (_b.label) {
                     case 0:
-                        if (instance.invalidatedBool) return [2 /*return*/];
-                        return [4 /*yield*/, Promise.all([getItem(PersistKey.DeviceId), getItem(PersistKey.OverrideDeviceId)])];
+                        if (instance.invalidatedBool) return [2];
+                        return [4, Promise.all([getItem(PersistKey.DeviceId), getItem(PersistKey.OverrideDeviceId)])];
                     case 1:
                         _a = _b.sent(), deviceId = _a[0], overrideDeviceId = _a[1];
-                        if (instance.invalidatedBool) return [2 /*return*/];
+                        if (instance.invalidatedBool) return [2];
                         this._applyRestoredIdentity(instance, deviceId !== null && deviceId !== void 0 ? deviceId : "", overrideDeviceId !== null && overrideDeviceId !== void 0 ? overrideDeviceId : "");
-                        return [2 /*return*/];
+                        return [2];
                 }
             });
         });
     };
-    // Apply the restored identity to the instance.  Both loaders funnel through
-    // here so the two paths can never drift.
     Kochava.prototype._applyRestoredIdentity = function (instance, deviceId, overrideDeviceId) {
-        // kochavaDeviceId: server override wins over the stored id.
         instance.kochavaDeviceId = overrideDeviceId || deviceId;
-        // Restore complete — the identity may now be resolved on demand.
         instance.stateRestoredBool = true;
     };
-    // Return this instance's install-identity resolution, creating it on first
-    // demand.  Memoized on the instance so it can never pair with the wrong
-    // lifecycle generation across a shutdown swap.
     Kochava.prototype._ensureIdentityResolved = function (instance) {
         if (!instance.identityResolvedPromise) {
             instance.identityResolvedPromise = this._resolveInstallIdentity(instance);
         }
         return instance.identityResolvedPromise;
     };
-    // Resolve the install identity for this instance.  Precondition: the
-    // persisted-identity restore has completed (callers gate on stateRestoredBool
-    // or await _stateRestored first).
-    //
-    // The waterfall, in order — an id is generated only after every read source
-    // is exhausted, so nothing provisional is ever created, persisted, or shown:
-    //   1. Stored id (already in memory from restore).
-    //   2. Shared cookie (useCookies integrations share one identity across
-    //      subdomains; a fresh subdomain's local storage starts empty while the
-    //      shared cookie already holds the real id — adopting it here is what
-    //      keeps a new subdomain from entrenching a new id and clobbering the
-    //      shared identity).  An id read from local storage still wins over the
-    //      cookie, matching the long-standing storage-before-cookie precedence.
-    //   3. Legacy v2 kv_id (URL parameter or storage), only on a first-ever v3
-    //      launch — the identity half of the v2->v3 migration; the bookkeeping
-    //      half stays in _checkFirstLaunchAndMigrate.
-    //   4. Generate — the one and only generation point, logged as such.
-    //
-    // On synchronous-storage platforms every step through the in-memory
-    // assignment executes synchronously, so a resolution kicked from the
-    // synchronous start path makes getDeviceId() correct on the caller's very
-    // next line.  Cookie and legacy-URL sources are DOM-only and are gated on
-    // the sync fast-path accordingly.
     Kochava.prototype._resolveInstallIdentity = function (instance) {
         return __awaiter(this, void 0, void 0, function () {
             var cookieDeviceId, oldKvId, deviceId, cookieOverrideDeviceId;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
-                        // WATERFALL
-                        // 1. stored id
                         if (!instance.kochavaDeviceId) {
-                            // 2. shared cookie
                             if (instance.useCookies && hasSyncStorage()) {
                                 try {
                                     cookieDeviceId = getCookie(PersistKey.DeviceId);
@@ -847,11 +631,10 @@ var Kochava = /** @class */function () {
                                         instance.kochavaDeviceId = cookieDeviceId;
                                         setItemSync(PersistKey.DeviceId, cookieDeviceId);
                                     }
-                                } catch ( /* sync storage unavailable — fall through */_b) {/* sync storage unavailable — fall through */}
+                                } catch (_b) {}
                             }
                         }
                         if (!instance.kochavaDeviceId) {
-                            // 3. legacy v2 kv_id (first-ever v3 launch only; web-legacy sources)
                             if (hasSyncStorage()) {
                                 try {
                                     if (!getItemSync(PersistKey.FirstStartDate)) {
@@ -861,23 +644,19 @@ var Kochava = /** @class */function () {
                                             setItemSync(PersistKey.DeviceId, oldKvId);
                                         }
                                     }
-                                } catch ( /* sync storage unavailable — fall through */_c) {/* sync storage unavailable — fall through */}
+                                } catch (_c) {}
                             }
                         }
-                        if (!!instance.kochavaDeviceId) return [3 /*break*/, 2];
+                        if (!!instance.kochavaDeviceId) return [3, 2];
                         deviceId = this._generateDeviceId();
                         Log.diagDebug("Generated new kochava device id ".concat(deviceId));
                         instance.kochavaDeviceId = deviceId;
-                        return [4 /*yield*/, setItem(PersistKey.DeviceId, deviceId)];
+                        return [4, setItem(PersistKey.DeviceId, deviceId)];
                     case 1:
                         _a.sent();
-                        if (instance.invalidatedBool) return [2 /*return*/];
+                        if (instance.invalidatedBool) return [2];
                         _a.label = 2;
                     case 2:
-                        // overrideDeviceId
-                        // ⓘ Adopt the shared cookie override when none is stored locally, so a
-                        //   subdomain that has not yet received the override from kvinit reports
-                        //   consistently with the subdomain that has.
                         if (instance.useCookies && hasSyncStorage()) {
                             try {
                                 if (!getItemSync(PersistKey.OverrideDeviceId)) {
@@ -887,15 +666,14 @@ var Kochava = /** @class */function () {
                                         setItemSync(PersistKey.OverrideDeviceId, cookieOverrideDeviceId);
                                     }
                                 }
-                            } catch ( /* sync storage unavailable */_d) {/* sync storage unavailable */}
+                            } catch (_d) {}
                         }
-                        return [2 /*return*/];
+                        return [2];
                 }
             });
         });
     };
     Kochava.prototype._initInstance = function (instance, appGuid) {
-        // init instance with defaults
         instance.appGuid = appGuid;
         instance.disableAutoPage = instance.disableAutoPage || false;
         instance.useCookies = instance.useCookies || false;
@@ -912,32 +690,27 @@ var Kochava = /** @class */function () {
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
-                        return [4 /*yield*/, readAndUpdatePersistedValue(PersistKey.FirstStartDate, instance.useCookies)];
+                        return [4, readAndUpdatePersistedValue(PersistKey.FirstStartDate, instance.useCookies)];
                     case 1:
                         firstLaunchDate = _a.sent();
-                        if (instance.invalidatedBool) return [2 /*return*/];
-                        if (!!firstLaunchDate) return [3 /*break*/, 5];
-                        return [4 /*yield*/, updatePersistedValue(PersistKey.FirstStartDate, String(utils.getCurrTimeSec()), instance.useCookies)];
+                        if (instance.invalidatedBool) return [2];
+                        if (!!firstLaunchDate) return [3, 5];
+                        return [4, updatePersistedValue(PersistKey.FirstStartDate, String(utils.getCurrTimeSec()), instance.useCookies)];
                     case 2:
                         _a.sent();
-                        if (instance.invalidatedBool) return [2 /*return*/];
-                        return [4 /*yield*/, readAndUpdatePersistedValue(PersistKey.OldKvid, instance.useCookies)];
+                        if (instance.invalidatedBool) return [2];
+                        return [4, readAndUpdatePersistedValue(PersistKey.OldKvid, instance.useCookies)];
                     case 3:
                         oldKvId = _a.sent();
-                        if (instance.invalidatedBool) return [2 /*return*/];
-                        if (!oldKvId) return [3 /*break*/, 5];
-                        // Identity adoption of the legacy id lives in the resolution waterfall
-                        // (_resolveInstallIdentity), which already ran and wins precedence
-                        // battles (an established cookie identity beats the legacy id).  Here
-                        // migration only records that this device has v2 history, so the
-                        // install is not re-sent.
+                        if (instance.invalidatedBool) return [2];
+                        if (!oldKvId) return [3, 5];
                         instance.installDone = true;
-                        return [4 /*yield*/, updatePersistedValue(PersistKey.InstallSentDate, JSON.stringify(utils.getCurrTimeSec()), instance.useCookies)];
+                        return [4, updatePersistedValue(PersistKey.InstallSentDate, JSON.stringify(utils.getCurrTimeSec()), instance.useCookies)];
                     case 4:
                         _a.sent();
                         _a.label = 5;
                     case 5:
-                        return [2 /*return*/];
+                        return [2];
                 }
             });
         });
@@ -949,23 +722,22 @@ var Kochava = /** @class */function () {
                 switch (_a.label) {
                     case 0:
                         persistedKvinit = {};
-                        return [4 /*yield*/, readAndUpdatePersistedValue(PersistKey.LastKvinit, instance.useCookies)];
+                        return [4, readAndUpdatePersistedValue(PersistKey.LastKvinit, instance.useCookies)];
                     case 1:
                         persistedKvinitStr = _a.sent();
-                        if (instance.invalidatedBool) return [2 /*return*/];
-                        if (!persistedKvinitStr) return [3 /*break*/, 3];
+                        if (instance.invalidatedBool) return [2];
+                        if (!persistedKvinitStr) return [3, 3];
                         persistedKvinit = JSON.parse(persistedKvinitStr);
-                        if (!persistedKvinit) return [3 /*break*/, 3];
-                        // if persisted kvinit, apply it
+                        if (!persistedKvinit) return [3, 3];
                         Log.trace("Found persisted kvinit.", persistedKvinit);
-                        return [4 /*yield*/, Kvinit.applyKvinitResp(instance, persistedKvinit)];
+                        return [4, Kvinit.applyKvinitResp(instance, persistedKvinit)];
                     case 2:
                         _a.sent();
-                        if (instance.invalidatedBool) return [2 /*return*/];
+                        if (instance.invalidatedBool) return [2];
                         Log.trace("KochavaConfig after persistedKvinit:", JSON.parse(JSON.stringify(instance.kochavaConfig)));
                         _a.label = 3;
                     case 3:
-                        return [4 /*yield*/, readAndUpdatePersistedValue(PersistKey.KvinitSentDate, instance.useCookies)];
+                        return [4, readAndUpdatePersistedValue(PersistKey.KvinitSentDate, instance.useCookies)];
                     case 4:
                         persistedKvinitDateStr = _a.sent();
                         if (persistedKvinitDateStr) {
@@ -975,7 +747,7 @@ var Kochava = /** @class */function () {
                                 if (utils.getCurrTimeSec() - lastKvinitDate < refreshMin) instance.kvinitDone = true;
                             }
                         }
-                        return [2 /*return*/];
+                        return [2];
                 }
             });
         });
@@ -986,43 +758,43 @@ var Kochava = /** @class */function () {
             return __generator(this, function (_e) {
                 switch (_e.label) {
                     case 0:
-                        if (!instance.useCookies) return [3 /*break*/, 3];
-                        return [4 /*yield*/, getItem(PersistKey.DeviceId)];
+                        if (!instance.useCookies) return [3, 3];
+                        return [4, getItem(PersistKey.DeviceId)];
                     case 1:
                         rawDeviceId = _e.sent() || instance.kochavaDeviceId;
-                        if (instance.invalidatedBool) return [2 /*return*/];
-                        return [4 /*yield*/, updatePersistedValue(PersistKey.DeviceId, rawDeviceId, true)];
+                        if (instance.invalidatedBool) return [2];
+                        return [4, updatePersistedValue(PersistKey.DeviceId, rawDeviceId, true)];
                     case 2:
                         _e.sent();
-                        if (instance.invalidatedBool) return [2 /*return*/];
+                        if (instance.invalidatedBool) return [2];
                         _e.label = 3;
                     case 3:
                         _a = instance;
-                        return [4 /*yield*/, readAndUpdatePersistedValue(PersistKey.InstallSentDate, instance.useCookies)];
+                        return [4, readAndUpdatePersistedValue(PersistKey.InstallSentDate, instance.useCookies)];
                     case 4:
                         _a.installDone = _e.sent().length > 0;
-                        if (instance.invalidatedBool) return [2 /*return*/];
+                        if (instance.invalidatedBool) return [2];
                         _b = instance;
-                        return [4 /*yield*/, readAndUpdatePersistedValue(PersistKey.InstallId, instance.useCookies)];
+                        return [4, readAndUpdatePersistedValue(PersistKey.InstallId, instance.useCookies)];
                     case 5:
                         _b.kochavaInstallId = _e.sent();
-                        if (instance.invalidatedBool) return [2 /*return*/];
+                        if (instance.invalidatedBool) return [2];
                         _c = instance;
-                        return [4 /*yield*/, readAndUpdateSessionCount(instance.useCookies)];
+                        return [4, readAndUpdateSessionCount(instance.useCookies)];
                     case 6:
                         _c.kochavaSessionCount = _e.sent();
-                        if (instance.invalidatedBool) return [2 /*return*/];
+                        if (instance.invalidatedBool) return [2];
                         _d = instance;
-                        return [4 /*yield*/, readAndUpdateUTM(instance.appGuid, instance.useCookies)];
+                        return [4, readAndUpdateUTM(instance.appGuid, instance.useCookies)];
                     case 7:
                         _d.utm = _e.sent();
-                        if (instance.invalidatedBool) return [2 /*return*/];
-                        return [4 /*yield*/, readAndUpdatePersistedValue(PersistKey.InstallCount, instance.useCookies)];
+                        if (instance.invalidatedBool) return [2];
+                        return [4, readAndUpdatePersistedValue(PersistKey.InstallCount, instance.useCookies)];
                     case 8:
                         installCountStr = _e.sent();
                         parsedInstallCount = parseInt(installCountStr, 10);
                         instance.installCount = isNaN(parsedInstallCount) ? 0 : parsedInstallCount;
-                        return [2 /*return*/];
+                        return [2];
                 }
             });
         });
@@ -1041,40 +813,39 @@ var Kochava = /** @class */function () {
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
-                        if (instance.invalidatedBool) return [2 /*return*/];
+                        if (instance.invalidatedBool) return [2];
                         jobQueue = this._jobQueue;
-                        if (!!instance.kvinitDone) return [3 /*break*/, 2];
+                        if (!!instance.kvinitDone) return [3, 2];
                         Log.diagDebug("A new kvinit will be sent");
-                        return [4 /*yield*/, this.performNewKvinit(instance)];
+                        return [4, this.performNewKvinit(instance)];
                     case 1:
                         _a.sent();
-                        return [3 /*break*/, 3];
+                        return [3, 3];
                     case 2:
                         Log.diagDebug("A new kvinit will not be sent");
                         _a.label = 3;
                     case 3:
-                        if (instance.invalidatedBool) return [2 /*return*/];
-                        return [4 /*yield*/, this.checkResendId(instance)];
+                        if (instance.invalidatedBool) return [2];
+                        return [4, this.checkResendId(instance)];
                     case 4:
-                        // if the install_id changed and thus a new install must go out
                         if (_a.sent()) instance.installDone = false;
-                        if (instance.invalidatedBool) return [2 /*return*/];
+                        if (instance.invalidatedBool) return [2];
                         Log.diagDebug("The install ".concat(instance.installDone ? "has already" : "has not yet", " been sent"));
-                        if (instance.sleep) return [2 /*return*/];
-                        if (!!instance.installDone) return [3 /*break*/, 6];
-                        return [4 /*yield*/, this.performInstall(instance)];
+                        if (instance.sleep) return [2];
+                        if (!!instance.installDone) return [3, 6];
+                        return [4, this.performInstall(instance)];
                     case 5:
                         _a.sent();
                         _a.label = 6;
                     case 6:
-                        if (instance.invalidatedBool) return [2 /*return*/];
-                        if (!(instance.kvinitDone && instance.installDone)) return [3 /*break*/, 8];
-                        return [4 /*yield*/, jobQueue.start(instance)];
+                        if (instance.invalidatedBool) return [2];
+                        if (!(instance.kvinitDone && instance.installDone)) return [3, 8];
+                        return [4, jobQueue.start(instance)];
                     case 7:
                         _a.sent();
                         _a.label = 8;
                     case 8:
-                        return [2 /*return*/];
+                        return [2];
                 }
             });
         });
@@ -1086,27 +857,27 @@ var Kochava = /** @class */function () {
                 switch (_b.label) {
                     case 0:
                         _a = instance;
-                        return [4 /*yield*/, Kvinit.send(instance, instance.retryWaterfall)];
+                        return [4, Kvinit.send(instance, instance.retryWaterfall)];
                     case 1:
                         _a.kvinitDone = _b.sent();
-                        if (instance.invalidatedBool) return [2 /*return*/];
-                        return [4 /*yield*/, updatePersistedValue(PersistKey.KvinitSentDate, String(utils.getCurrTimeSec()), instance.useCookies)];
+                        if (instance.invalidatedBool) return [2];
+                        return [4, updatePersistedValue(PersistKey.KvinitSentDate, String(utils.getCurrTimeSec()), instance.useCookies)];
                     case 2:
                         _b.sent();
-                        if (instance.invalidatedBool) return [2 /*return*/];
+                        if (instance.invalidatedBool) return [2];
                         newKvinit = {};
-                        return [4 /*yield*/, readAndUpdatePersistedValue(PersistKey.LastKvinit, instance.useCookies)];
+                        return [4, readAndUpdatePersistedValue(PersistKey.LastKvinit, instance.useCookies)];
                     case 3:
                         newKvinitStr = _b.sent();
-                        if (instance.invalidatedBool) return [2 /*return*/];
+                        if (instance.invalidatedBool) return [2];
                         if (newKvinitStr) {
                             newKvinit = JSON.parse(newKvinitStr);
                         }
-                        return [4 /*yield*/, Kvinit.applyKvinitResp(instance, newKvinit)];
+                        return [4, Kvinit.applyKvinitResp(instance, newKvinit)];
                     case 4:
                         _b.sent();
                         Log.trace("KochavaConfig after new Kvinit:", JSON.parse(JSON.stringify(instance.kochavaConfig)));
-                        return [2 /*return*/];
+                        return [2];
                 }
             });
         });
@@ -1121,13 +892,13 @@ var Kochava = /** @class */function () {
                         if (instance.kochavaConfig.install) {
                             resendId = instance.kochavaConfig.install.resend_id;
                         }
-                        return [4 /*yield*/, checkInstallIdChange(resendId, instance.useCookies)];
+                        return [4, checkInstallIdChange(resendId, instance.useCookies)];
                     case 1:
                         needsNewInstall = _a.sent();
                         if (needsNewInstall) {
                             Log.debug("resend_id ".concat(resendId, " found, forcing new install"));
                         }
-                        return [2 /*return*/, needsNewInstall];
+                        return [2, needsNewInstall];
                 }
             });
         });
@@ -1139,33 +910,31 @@ var Kochava = /** @class */function () {
                 switch (_b.label) {
                     case 0:
                         jobQueue = this._jobQueue;
-                        return [4 /*yield*/, Install.build(instance)];
+                        return [4, Install.build(instance)];
                     case 1:
                         request = _b.sent();
                         _a = instance;
-                        return [4 /*yield*/, Install.send(instance, request)];
+                        return [4, Install.send(instance, request)];
                     case 2:
                         _a.installDone = _b.sent();
-                        if (!instance.installDone) return [2 /*return*/];
-                        if (instance.invalidatedBool) return [2 /*return*/];
-                        // If the install succeeded, remove all idLink that were passed to it
-                        return [4 /*yield*/, Install.onSuccess(instance)];
+                        if (!instance.installDone) return [2];
+                        if (instance.invalidatedBool) return [2];
+                        return [4, Install.onSuccess(instance)];
                     case 3:
-                        // If the install succeeded, remove all idLink that were passed to it
                         _b.sent();
-                        if (instance.invalidatedBool) return [2 /*return*/];
-                        return [4 /*yield*/, jobQueue.persistIdLinkQueue()];
+                        if (instance.invalidatedBool) return [2];
+                        return [4, jobQueue.persistIdLinkQueue()];
                     case 4:
                         _b.sent();
-                        if (instance.invalidatedBool) return [2 /*return*/];
-                        return [4 /*yield*/, jobQueue.persistUpdateQueue()];
+                        if (instance.invalidatedBool) return [2];
+                        return [4, jobQueue.persistUpdateQueue()];
                     case 5:
                         _b.sent();
-                        if (instance.invalidatedBool) return [2 /*return*/];
-                        return [4 /*yield*/, this._persistSentCustomDeviceIds(instance)];
+                        if (instance.invalidatedBool) return [2];
+                        return [4, this._persistSentCustomDeviceIds(instance)];
                     case 6:
                         _b.sent();
-                        return [2 /*return*/];
+                        return [2];
                 }
             });
         });
@@ -1192,13 +961,13 @@ var Kochava = /** @class */function () {
                             }
                             if (keyAllowed) sentIds[key] = cv.data[key];
                         });
-                        if (!(Object.keys(sentIds).length > 0)) return [3 /*break*/, 2];
-                        return [4 /*yield*/, persistSentDeviceIds(sentIds)];
+                        if (!(Object.keys(sentIds).length > 0)) return [3, 2];
+                        return [4, persistSentDeviceIds(sentIds)];
                     case 1:
                         _c.sent();
                         _c.label = 2;
                     case 2:
-                        return [2 /*return*/];
+                        return [2];
                 }
             });
         });
@@ -1206,6 +975,5 @@ var Kochava = /** @class */function () {
     return Kochava;
 }();
 export { Kochava };
-// Only here for generic Web integration
 window.kochava = Kochava.create();
 //# sourceMappingURL=kochava.js.map