@pendo/agent 2.299.0 → 2.300.0

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.0_';
+let PACKAGE_VERSION = '2.300.0';
 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);
     }
@@ -12278,6 +12278,8 @@ class PerformanceMonitor {
         this.measures = new Set();
     }
     initialize() {
+        if (!ConfigReader.get('performanceMetricsEnabled'))
+            return _.noop;
         this._measuringPerformance = true;
         this._markPerformance(INITIALIZE);
         this.interval = setInterval(() => {
@@ -12306,25 +12308,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 +12330,7 @@ class PerformanceMonitor {
         }
     }
     _checkPerformanceApi() {
-        return ConfigReader.get('performanceMetricsEnabled') &&
-            detectNativeBrowserAPI('performance.mark') &&
+        return detectNativeBrowserAPI('performance.mark') &&
             detectNativeBrowserAPI('performance.measure') &&
             detectNativeBrowserAPI('performance.getEntries') &&
             detectNativeBrowserAPI('performance.getEntriesByName') &&
@@ -20988,22 +20984,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
@@ -24268,30 +24255,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 +24296,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 +24338,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 +25922,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 +25941,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 +25997,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 +26078,7 @@ function loadGuideCss() {
     else {
         dom('#' + CUSTOM_CSS_ID).remove();
     }
-    return q.all(promises);
+    return promises;
 }
 var processGuideEventCache = function (options) {
     if (!guideEventQueue)
@@ -26220,14 +26230,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 +26320,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 +33477,7 @@ var GuideUpdateModule = (function () {
     function observerCallback() {
         store.dispatch('guideUpdate/documentChanged');
     }
+    const debouncedCallback = _.debounce(observerCallback, 50);
     function handleScheduledUpdate() {
         store.dispatch('guideUpdate/handleScheduledUpdate');
     }
@@ -33511,6 +33518,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 +33529,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 +39825,7 @@ class PromptPlugin {
                 promptType: method,
                 url,
                 privacyFilterApplied: filteredPrompt !== originalBody
-            });
+            }, undefined, 'agentic');
         });
     }
     handleError({ error, context }) {
@@ -39853,7 +39867,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 +45078,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 +45648,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 +46503,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 +46541,9 @@ class IframeManager {
   addLoadListener(cb) {
     this.loadListener = cb;
   }
+  addPageHideListener(cb) {
+    this.pageHideListener = cb;
+  }
   attachIframe(iframeEl, childSn) {
     var _a2, _b, _c;
     this.mutationCb({
@@ -46535,6 +46565,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 +47781,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 +47907,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 +47953,7 @@ function record(options = {}) {
     }
     return () => {
       handlers.forEach((h) => h());
+      iframeHandlersMap.forEach((h) => h());
       processedNodeManager.destroy();
       recording = false;
       unregisterErrorHandler();