@pendo/agent 2.299.0 → 2.300.1

package/dist/pendo.module.js

@@ -3905,8 +3905,8 @@ let SERVER = '';
 let ASSET_HOST = '';
 let ASSET_PATH = '';
 let DESIGNER_SERVER = '';
-let VERSION = '2.299.0_';
-let PACKAGE_VERSION = '2.299.0';
+let VERSION = '2.300.1_';
+let PACKAGE_VERSION = '2.300.1';
 let LOADER = 'xhr';
 /* eslint-enable agent-eslint-rules/no-gulp-env-references */
 /**
@@ -11560,7 +11560,7 @@ var loadResource = function (options, callback, sendErrorToCallback = false) {
             script.src = getPolicy(pendo$1).createScriptURL(options.url);
             addIntegrityAttribute(script, options.url);
             document.body.appendChild(script);
-            return {};
+            return script;
         }
         else { // Assume JS file.
             script = document.createElement('script');
@@ -11574,7 +11574,7 @@ var loadResource = function (options, callback, sendErrorToCallback = false) {
                 if (err) {
                     if (sendErrorToCallback)
                         originalCallback(err);
-                    return;
+                    return {};
                 }
                 originalCallback.apply(this, _.toArray(arguments).slice(1));
             });
@@ -11628,7 +11628,7 @@ var loadWatcher = function (target, url, callback) {
         setTimeout$1(function () {
             if (!isLoaded) {
                 // Log a warning if we fail to load the resource within 10 seconds
-                writeMessage('Failed to load ' + url + ' within 10 seconds');
+                log.critical('Failed to load ' + url + ' within 10 seconds');
             }
         }, 10000);
     }
@@ -12239,8 +12239,14 @@ const BEACON_GIF_FAILURES = {
     poll: 'pendo-poll-gif-failure',
     agentic: 'pendo-agentic-gif-failure'
 };
-const GUIDE_LOOP_TIMER = 'pendo-guide-loop';
-const EVENT_CAPTURED_TIMER = 'pendo-event-captured';
+const GUIDE_LOOP_TIMER = {
+    name: 'pendo-guide-loop',
+    debuggingOnly: true
+};
+const EVENT_CAPTURED_TIMER = {
+    name: 'pendo-event-captured',
+    debuggingOnly: true
+};
 const INITIALIZE = 'pendo-initialize';
 const TEARDOWN = 'pendo-teardown';
 const METRICS = {};
@@ -12256,12 +12262,8 @@ _.each(BEACON_GIF_FAILURES, (name) => {
         instrument: counter
     };
 });
-METRICS[GUIDE_LOOP_TIMER] = {
-    name: GUIDE_LOOP_TIMER
-};
-METRICS[EVENT_CAPTURED_TIMER] = {
-    name: EVENT_CAPTURED_TIMER
-};
+METRICS[GUIDE_LOOP_TIMER.name] = GUIDE_LOOP_TIMER;
+METRICS[EVENT_CAPTURED_TIMER.name] = EVENT_CAPTURED_TIMER;
 METRICS[INITIALIZE] = {
     name: INITIALIZE
 };
@@ -12269,17 +12271,52 @@ METRICS[TEARDOWN] = {
     name: TEARDOWN
 };
 
+var debugEnabled = 'debug-enabled';
+function getDebuggingStorage() {
+    try {
+        const debuggingStorage = agentStorage.read(debugEnabled) || JSON.parse(getCookie(debugEnabled));
+        if (typeof debuggingStorage === 'boolean') { // v1 debugger storage format
+            return { enabled: debuggingStorage };
+        }
+        return debuggingStorage || {};
+    }
+    catch (e) {
+        return {};
+    }
+}
+function isDebuggingEnabled(asBoolean = true) {
+    let isEnabled;
+    if (store && store.getters && store.getters['debugger/debuggingEnabled']) {
+        isEnabled = store.getters['debugger/debuggingEnabled']();
+    }
+    else {
+        isEnabled = getDebuggingStorage().enabled === true;
+    }
+    if (asBoolean) {
+        return isEnabled;
+    }
+    else {
+        return isEnabled ? 'Yes' : 'No';
+    }
+}
+
 const PERFORMANCE_SEND_INTERVAL = 1000 * 60 * 10; // 10 minutes
 class PerformanceMonitor {
     constructor() {
         this._isPerformanceApiAvailable = this._checkPerformanceApi();
         this._measuringPerformance = false;
+        this._debugging = false;
+        this._setDebuggingBound = _.bind(this._setDebugging, this);
         this.marks = new Set();
         this.measures = new Set();
     }
     initialize() {
+        if (!ConfigReader.get('performanceMetricsEnabled'))
+            return _.noop;
         this._measuringPerformance = true;
         this._markPerformance(INITIALIZE);
+        this._setDebugging();
+        Events.debuggerLaunched.on(this._setDebuggingBound);
         this.interval = setInterval(() => {
             this.send();
         }, PERFORMANCE_SEND_INTERVAL);
@@ -12291,13 +12328,19 @@ class PerformanceMonitor {
         this._markPerformance(TEARDOWN);
         this.send();
         this._measuringPerformance = false;
+        this._setDebugging();
+        Events.debuggerLaunched.off(this._setDebuggingBound);
         this._clearMarksAndMeasures();
         clearInterval(this.interval);
     }
-    startTimer(name, detail = null) {
+    startTimer({ name, debuggingOnly }, detail = null) {
+        if (debuggingOnly && !this._debugging)
+            return;
         this._markPerformance(`${name}-start`, { detail });
     }
-    stopTimer(name, detail = null) {
+    stopTimer({ name, debuggingOnly }, detail = null) {
+        if (debuggingOnly && !this._debugging)
+            return;
         this._markPerformance(`${name}-stop`, { detail });
         this._measurePerformance(name, { detail });
     }
@@ -12306,25 +12349,20 @@ class PerformanceMonitor {
         this._markPerformance(name, { detail });
     }
     send() {
-        const metrics = _.reduce(METRICS, (acc, metric) => {
+        const payload = _.reduce(METRICS, (acc, metric) => {
             const { name, type, instrument } = metric;
             if (!instrument)
                 return acc;
             const entries = performance.getEntriesByName(name);
             const value = instrument(entries);
-            if (type === 'counter' && value > 0) {
-                acc.push({
-                    name,
-                    type,
-                    value,
-                    timestamp: Date.now()
-                });
-            }
+            acc.push({
+                name,
+                type,
+                value,
+                timestamp: Date.now()
+            });
             return acc;
         }, []);
-        const payload = _.filter(metrics, (metric) => {
-            return metric.value > 0;
-        });
         this._clearMarksAndMeasures();
         if (!ConfigReader.get('sendPerformanceMetrics'))
             return;
@@ -12333,8 +12371,7 @@ class PerformanceMonitor {
         }
     }
     _checkPerformanceApi() {
-        return ConfigReader.get('performanceMetricsEnabled') &&
-            detectNativeBrowserAPI('performance.mark') &&
+        return detectNativeBrowserAPI('performance.mark') &&
             detectNativeBrowserAPI('performance.measure') &&
             detectNativeBrowserAPI('performance.getEntries') &&
             detectNativeBrowserAPI('performance.getEntriesByName') &&
@@ -12344,6 +12381,9 @@ class PerformanceMonitor {
     _shouldMeasurePerformance() {
         return this._isPerformanceApiAvailable && this._measuringPerformance;
     }
+    _setDebugging() {
+        this._debugging = isDebuggingEnabled();
+    }
     _markPerformance(name, metadata) {
         if (!this._shouldMeasurePerformance())
             return;
@@ -12361,13 +12401,15 @@ class PerformanceMonitor {
         }
     }
     _clearMarksAndMeasures() {
-        for (const name of this.marks) {
+        // eslint-disable-next-line agent-eslint-rules/no-array-foreach
+        this.marks.forEach(name => {
             performance.clearMarks(name);
-        }
+        });
         this.marks.clear();
-        for (const name of this.measures) {
+        // eslint-disable-next-line agent-eslint-rules/no-array-foreach
+        this.measures.forEach(name => {
             performance.clearMeasures(name);
-        }
+        });
         this.measures.clear();
     }
 }
@@ -20988,22 +21030,13 @@ function continueOrCompleteUpdate() {
  * Otherwise, it is the same as calling startGuides.
  */
 var manuallyStartGuides = function () {
-    var originalOptions = ConfigReader.getLocalConfig();
-    if (ConfigReader.get('delayGuides')) {
-        delete originalOptions.delayGuides;
-        ConfigReader.setLocalConfig(originalOptions);
-    }
-    if (ConfigReader.get('guides.delay')) {
-        delete originalOptions.guides.delay;
-        ConfigReader.setLocalConfig(originalOptions);
-    }
+    setGuidesDelayed(false);
     startGuides();
 };
 var manuallyStopGuides = function () {
     if (!areGuidesDisabled()) {
         setGuidesDelayed(true);
     }
-    stopGuides();
     resetPendoUI();
 };
 // a phase that only has one unit of work per update
@@ -21550,35 +21583,6 @@ function Wrappable() {
     return this;
 }
 
-var debugEnabled = 'debug-enabled';
-function getDebuggingStorage() {
-    try {
-        const debuggingStorage = agentStorage.read(debugEnabled) || JSON.parse(getCookie(debugEnabled));
-        if (typeof debuggingStorage === 'boolean') { // v1 debugger storage format
-            return { enabled: debuggingStorage };
-        }
-        return debuggingStorage || {};
-    }
-    catch (e) {
-        return {};
-    }
-}
-function isDebuggingEnabled(asBoolean = true) {
-    let isEnabled;
-    if (store && store.getters && store.getters['debugger/debuggingEnabled']) {
-        isEnabled = store.getters['debugger/debuggingEnabled']();
-    }
-    else {
-        isEnabled = getDebuggingStorage().enabled === true;
-    }
-    if (asBoolean) {
-        return isEnabled;
-    }
-    else {
-        return isEnabled ? 'Yes' : 'No';
-    }
-}
-
 class GuideTypeIdentifier {
     constructor(identificationFn, typeName) {
         this.type = typeName;
@@ -24268,30 +24272,40 @@ class GuideCache {
         if (this.db)
             return q.resolve(this.db);
         const deferred = q.defer();
-        const request = indexedDB.open(`pendo-${apiKey}`, 1);
-        request.onerror = () => {
-            log.warn('Error opening guide database');
-            this.cacheGuidesPersistent = false;
-            deferred.resolve();
-        };
-        request.onsuccess = (event) => {
-            const db = event.target.result;
-            this.db = db;
-            db.onclose = () => {
-                this.db = null;
+        try {
+            const request = indexedDB.open(`pendo-${apiKey}`, 1);
+            request.onerror = () => {
+                this.dbError(new Error('open.request.onerror'));
+                deferred.resolve();
             };
-            deferred.resolve(db);
-        };
-        request.onupgradeneeded = (event) => {
-            const db = event.target.result;
-            const objectStore = db.createObjectStore('guides', { keyPath: 'guide.id' });
-            objectStore.transaction.oncomplete = () => {
+            request.onsuccess = (event) => {
+                const db = event.target.result;
                 this.db = db;
+                db.onclose = () => {
+                    this.db = null;
+                };
                 deferred.resolve(db);
             };
-        };
+            request.onupgradeneeded = (event) => {
+                const db = event.target.result;
+                const objectStore = db.createObjectStore('guides', { keyPath: 'guide.id' });
+                objectStore.transaction.oncomplete = () => {
+                    this.db = db;
+                    deferred.resolve(db);
+                };
+            };
+        }
+        catch (error) {
+            this.dbError(error);
+            deferred.resolve();
+        }
         return deferred.promise;
     }
+    dbError(error) {
+        log.critical('indexedDB cache error', { error });
+        this.cacheGuidesPersistent = false;
+        this.db = null;
+    }
     load(now = getNow()) {
         if (this.cache)
             return q.resolve(this.cache);
@@ -24299,26 +24313,30 @@ class GuideCache {
         if (!this.db)
             return q.resolve(this.cache);
         const deferred = q.defer();
-        const objectStore = this.db.transaction(['guides'], 'readwrite').objectStore('guides');
-        const request = objectStore.getAll();
-        request.onerror = () => {
-            log.warn('Error loading guide cache');
-            this.cacheGuidesPersistent = false;
-            this.db = null;
-            deferred.resolve(this.cache);
-        };
-        request.onsuccess = (event) => {
-            const cachedGuides = event.target.result;
-            _.each(cachedGuides, (cachedGuide) => {
-                if (cachedGuide.expires > now) {
-                    this.cache[cachedGuide.guide.id] = cachedGuide;
-                }
-                else {
-                    objectStore.delete(cachedGuide.guide.id);
-                }
-            });
+        try {
+            const objectStore = this.db.transaction(['guides'], 'readwrite').objectStore('guides');
+            const request = objectStore.getAll();
+            request.onerror = () => {
+                this.dbError(new Error('load.request.onerror'));
+                deferred.resolve(this.cache);
+            };
+            request.onsuccess = (event) => {
+                const cachedGuides = event.target.result;
+                _.each(cachedGuides, (cachedGuide) => {
+                    if (cachedGuide.expires > now) {
+                        this.cache[cachedGuide.guide.id] = cachedGuide;
+                    }
+                    else {
+                        objectStore.delete(cachedGuide.guide.id);
+                    }
+                });
+                deferred.resolve(this.cache);
+            };
+        }
+        catch (error) {
+            this.dbError(error);
             deferred.resolve(this.cache);
-        };
+        }
         return deferred.promise;
     }
     add(guide, visitorId, now = getNow()) {
@@ -24337,16 +24355,22 @@ class GuideCache {
     save(cachedGuide) {
         if (!this.db)
             return;
-        const objectStore = this.db.transaction(['guides'], 'readwrite').objectStore('guides');
         const deferred = q.defer();
-        const update = objectStore.put(cachedGuide);
-        update.onerror = () => {
-            log.warn(`Error saving guide to cache ${cachedGuide.guide.id}`);
-            deferred.resolve();
-        };
-        update.onsuccess = () => {
+        try {
+            const objectStore = this.db.transaction(['guides'], 'readwrite').objectStore('guides');
+            const update = objectStore.put(cachedGuide);
+            update.onerror = () => {
+                this.dbError(new Error('save.request.onerror'));
+                deferred.resolve();
+            };
+            update.onsuccess = () => {
+                deferred.resolve();
+            };
+        }
+        catch (error) {
+            this.dbError(error);
             deferred.resolve();
-        };
+        }
         return deferred.promise;
     }
     update(lastGuideStepSeen) {
@@ -25915,13 +25939,12 @@ var loadGuides = function (apiKey, visitorId, page, callback) {
             }
             if (displayableGuides.length) {
                 q.all([
-                    loadGuideCss(),
                     globalJsPromise,
                     initializeResourceCenter(activeGuides),
                     BuildingBlockWatermark.initializeWatermark(activeGuides),
                     waitForGlobalCssToLoad(5000)
                 ]
-                    .concat(getRegisteredLoadGuideJobs(activeGuides))).then(function () {
+                    .concat(getRegisteredLoadGuideJobs(activeGuides), loadGuideCss())).then(function () {
                     if (loadGuides.reqId === reqId) {
                         if (store.getters['frames/isLeader']()) {
                             restoreGuideShownState(getActiveGuides());
@@ -25935,7 +25958,8 @@ var loadGuides = function (apiKey, visitorId, page, callback) {
                     }
                     deferred.resolve();
                 }, function (err) {
-                    log.error('Post loadGuide request failed: ', err);
+                    log.critical(`Post loadGuide request failed: ${err}`);
+                    resetPendoUI();
                     Events.guidesFailed.trigger();
                     deferred.reject();
                 });
@@ -25990,6 +26014,9 @@ function loadExternalCss(id, cssUrl) {
         var style = pendo$1.loadResource(cssUrl, function () {
             deferred.resolve();
         });
+        if (_.isEmpty(style)) {
+            return q.reject(`Failed to load CSS resource: ${cssUrl}. Check that the URL is correct and from an allowed origin.`);
+        }
         style.id = id;
         return deferred.promise;
     }
@@ -26068,7 +26095,7 @@ function loadGuideCss() {
     else {
         dom('#' + CUSTOM_CSS_ID).remove();
     }
-    return q.all(promises);
+    return promises;
 }
 var processGuideEventCache = function (options) {
     if (!guideEventQueue)
@@ -26220,14 +26247,6 @@ var initGuides = function (observer) {
     teardownFns.push(attachEventInternal(window, 'securitypolicyviolation', securityPolicyViolationFn));
     teardownFns.push(createVideoFullScreenListeners());
     if (observer.observing) {
-        var updateGuide = function () {
-            store.dispatch('guideUpdate/documentChanged');
-        };
-        const debouncedUpdate = _.debounce(updateGuide, 50);
-        teardownFns.push(() => { debouncedUpdate.cancel(); });
-        teardownFns.push(attachEvent(window, 'animationend', debouncedUpdate));
-        teardownFns.push(attachEvent(window, 'transitionend', debouncedUpdate));
-        teardownFns.push(attachEvent(window, 'mouseover', debouncedUpdate));
         store.commit('guideUpdate/setObserver', observer);
         store.commit('guideUpdate/setUseObserver');
         teardownFns.push(() => store.dispatch('guideUpdate/stopObserver'));
@@ -26318,6 +26337,10 @@ var setGuidesDisabled = function (areDisabled) {
 };
 var setGuidesDelayed = function (areDelayed) {
     var originalOptions = ConfigReader.getLocalConfig();
+    delete originalOptions.delayGuides;
+    if (originalOptions.guides) {
+        delete originalOptions.guides.delay;
+    }
     originalOptions.delayGuides = areDelayed;
     ConfigReader.setLocalConfig(originalOptions);
 };
@@ -33471,6 +33494,7 @@ var GuideUpdateModule = (function () {
     function observerCallback() {
         store.dispatch('guideUpdate/documentChanged');
     }
+    const debouncedCallback = _.debounce(observerCallback, 50);
     function handleScheduledUpdate() {
         store.dispatch('guideUpdate/handleScheduledUpdate');
     }
@@ -33511,6 +33535,9 @@ var GuideUpdateModule = (function () {
                 if (!context.state.observing) {
                     const observer = context.getters.observer();
                     observer.addEventListener('mutation', observerCallback);
+                    attachEvent(window, 'animationend', debouncedCallback);
+                    attachEvent(window, 'transitionend', debouncedCallback);
+                    attachEvent(window, 'mouseover', debouncedCallback);
                     context.commit('setObserving', true);
                 }
             }
@@ -33519,6 +33546,10 @@ var GuideUpdateModule = (function () {
             const observer = context.getters.observer();
             if (observer) {
                 observer.removeEventListener('mutation', observerCallback);
+                debouncedCallback.cancel();
+                detachEvent(window, 'animationend', debouncedCallback);
+                detachEvent(window, 'transitionend', debouncedCallback);
+                detachEvent(window, 'mouseover', debouncedCallback);
             }
             context.commit('setObserving', false);
             context.dispatch('stopScheduledUpdate');
@@ -39811,7 +39842,7 @@ class PromptPlugin {
                 promptType: method,
                 url,
                 privacyFilterApplied: filteredPrompt !== originalBody
-            });
+            }, undefined, 'agentic');
         });
     }
     handleError({ error, context }) {
@@ -39853,7 +39884,7 @@ class PromptPlugin {
             promptType: 'request',
             agentType: 'prompt'
         }, promptEvent);
-        this.api.analytics.collectEvent('prompt', event);
+        this.api.analytics.collectEvent('prompt', event, undefined, 'agentic');
     }
     teardown() {
         this._.each(this.prompts, (prompt) => prompt.teardown());
@@ -45064,6 +45095,9 @@ class MutationBuffer {
       this.movedMap = {};
       this.mutationCb(payload);
     });
+    __publicField(this, "bufferBelongsToIframe", (iframeEl) => {
+      return this.doc === iframeEl.contentDocument;
+    });
     __publicField(this, "genTextAreaValueMutation", (textarea) => {
       let item = this.attributeMap.get(textarea);
       if (!item) {
@@ -45631,6 +45665,15 @@ function initViewportResizeObserver({ viewportResizeCb }, { win }) {
   );
   return on("resize", updateDimension, win);
 }
+function findAndRemoveIframeBuffer(iframeEl) {
+  for (let i2 = mutationBuffers.length - 1; i2 >= 0; i2--) {
+    const buf = mutationBuffers[i2];
+    if (buf.bufferBelongsToIframe(iframeEl)) {
+      buf.reset();
+      mutationBuffers.splice(i2, 1);
+    }
+  }
+}
 const INPUT_TAGS = ["INPUT", "TEXTAREA", "SELECT"];
 const lastInputValueMap = /* @__PURE__ */ new WeakMap();
 function initInputObserver({
@@ -46477,6 +46520,7 @@ class IframeManager {
     __publicField(this, "wrappedEmit");
     __publicField(this, "takeFullSnapshot");
     __publicField(this, "loadListener");
+    __publicField(this, "pageHideListener");
     __publicField(this, "stylesheetManager");
     __publicField(this, "recordCrossOriginIframes");
     this.mutationCb = options.mutationCb;
@@ -46514,6 +46558,9 @@ class IframeManager {
   addLoadListener(cb) {
     this.loadListener = cb;
   }
+  addPageHideListener(cb) {
+    this.pageHideListener = cb;
+  }
   attachIframe(iframeEl, childSn) {
     var _a2, _b, _c;
     this.mutationCb({
@@ -46535,6 +46582,9 @@ class IframeManager {
         this.handleMessage.bind(this)
       );
       (_b = iframeEl.contentWindow) == null ? void 0 : _b.addEventListener("pagehide", () => {
+        var _a3;
+        (_a3 = this.pageHideListener) == null ? void 0 : _a3.call(this, iframeEl);
+        this.mirror.removeNodeFromMap(iframeEl.contentDocument);
         this.crossOriginIframeMap.delete(iframeEl.contentWindow);
       });
     }
@@ -47748,6 +47798,7 @@ function record(options = {}) {
   iframeManager.setTakeFullSnapshot(takeFullSnapshot$1);
   try {
     const handlers = [];
+    const iframeHandlersMap = /* @__PURE__ */ new Map();
     const observe = (doc) => {
       var _a2;
       return callbackWrapper(initObservers)(
@@ -47873,11 +47924,19 @@ function record(options = {}) {
     };
     iframeManager.addLoadListener((iframeEl) => {
       try {
-        handlers.push(observe(iframeEl.contentDocument));
+        iframeHandlersMap.set(iframeEl, observe(iframeEl.contentDocument));
       } catch (error) {
         console.warn(error);
       }
     });
+    iframeManager.addPageHideListener((iframeEl) => {
+      const iframeHandler = iframeHandlersMap.get(iframeEl);
+      if (iframeHandler) {
+        iframeHandler();
+        iframeHandlersMap.delete(iframeEl);
+      }
+      findAndRemoveIframeBuffer(iframeEl);
+    });
     const init = () => {
       takeFullSnapshot$1();
       handlers.push(observe(document));
@@ -47911,6 +47970,7 @@ function record(options = {}) {
     }
     return () => {
       handlers.forEach((h) => h());
+      iframeHandlersMap.forEach((h) => h());
       processedNodeManager.destroy();
       recording = false;
       unregisterErrorHandler();