@pendo/agent 2.289.1 → 2.290.1

package/dist/dom.esm.js

@@ -5283,6 +5283,16 @@ function isElementShadowRoot(elem, _win) {
 function getParent(elem, _win) {
     return isElementShadowRoot(elem, _win) ? elem.host : elem.parentNode;
 }
+function contains(context, elem, _win) {
+    var parent = elem;
+    while (parent) {
+        if (parent === context) {
+            return true;
+        }
+        parent = getParent(parent, _win);
+    }
+    return false;
+}
 
 var shadowAPI = (function () {
     function isShadowSelector(selector) {
@@ -5315,10 +5325,19 @@ var shadowAPI = (function () {
         isElementShadowRoot: isElementShadowRoot,
         getParent: getParent,
         isShadowSelector: isShadowSelector,
-        wrapSizzle: function (Sizzle) {
+        wrapSizzle: function (Sizzle, shadowDomManager) {
             Sizzle.intercept(function (Sizzle, selection, context, results, seed) {
                 if (!isShadowSelector(selection)) {
-                    return Sizzle(selection, context, results, seed);
+                    var queryResults_1 = Sizzle(selection, context, results, seed);
+                    if (shadowDomManager.cache.size > 0) {
+                        // eslint-disable-next-line agent-eslint-rules/no-array-foreach
+                        shadowDomManager.cache.forEach(function (shadowRoot) {
+                            if (!context || context === document || contains(context, shadowRoot)) {
+                                queryResults_1.push.apply(queryResults_1, Sizzle(selection, shadowRoot, results, seed));
+                            }
+                        });
+                    }
+                    return queryResults_1;
                 }
                 if (!_.isFunction(document.documentElement.attachShadow)) {
                     return Sizzle(selection.replace(shadowAPI.PSEUDO_REGEX, ''), context, results, seed);
@@ -7292,7 +7311,7 @@ function getScreenPosition(element) {
     };
 }
 
-var VERSION = '2.289.1_';
+var VERSION = '2.290.1_';
 
 var decodeURIComponent = _.isFunction(window.decodeURIComponent) ? window.decodeURIComponent : _.identity;
 

package/dist/pendo.module.js

@@ -3903,8 +3903,8 @@ var SERVER = '';
 var ASSET_HOST = '';
 var ASSET_PATH = '';
 var DESIGNER_SERVER = '';
-var VERSION = '2.289.1_';
-var PACKAGE_VERSION = '2.289.1';
+var VERSION = '2.290.1_';
+var PACKAGE_VERSION = '2.290.1';
 var LOADER = 'xhr';
 /* eslint-enable agent-eslint-rules/no-gulp-env-references */
 /**
@@ -6131,6 +6131,16 @@ function isElementShadowRoot(elem, _win) {
 function getParent(elem, _win) {
     return isElementShadowRoot(elem, _win) ? elem.host : elem.parentNode;
 }
+function contains(context, elem, _win) {
+    let parent = elem;
+    while (parent) {
+        if (parent === context) {
+            return true;
+        }
+        parent = getParent(parent, _win);
+    }
+    return false;
+}
 
 var shadowAPI = (function () {
     function isShadowSelector(selector) {
@@ -6163,10 +6173,19 @@ var shadowAPI = (function () {
         isElementShadowRoot: isElementShadowRoot,
         getParent: getParent,
         isShadowSelector,
-        wrapSizzle(Sizzle) {
+        wrapSizzle(Sizzle, shadowDomManager) {
             Sizzle.intercept(function (Sizzle, selection, context, results, seed) {
                 if (!isShadowSelector(selection)) {
-                    return Sizzle(selection, context, results, seed);
+                    const queryResults = Sizzle(selection, context, results, seed);
+                    if (shadowDomManager.cache.size > 0) {
+                        // eslint-disable-next-line agent-eslint-rules/no-array-foreach
+                        shadowDomManager.cache.forEach(shadowRoot => {
+                            if (!context || context === document || contains(context, shadowRoot)) {
+                                queryResults.push(...Sizzle(selection, shadowRoot, results, seed));
+                            }
+                        });
+                    }
+                    return queryResults;
                 }
                 if (!_.isFunction(document.documentElement.attachShadow)) {
                     return Sizzle(selection.replace(shadowAPI.PSEUDO_REGEX, ''), context, results, seed);
@@ -11796,6 +11815,7 @@ var restrictP1Access = _.memoize(function () {
 
 var eventCache = [];
 var trackEventCache = [];
+var agenticEventCache = [];
 // Send compressed event logs at least every 2 minutes
 var SEND_INTERVAL = 2 * 60 * 1000;
 var MAX_NUM_EVENTS = 16;
@@ -11815,8 +11835,10 @@ var buffers = {
     flushBy: _.noop,
     flushEvents: flushNow,
     flushTrackEvents: flushNow,
+    flushAgenticEvents: flushNow,
     flushSilos: flushNow,
     flushTrackEventSilos: flushNow,
+    flushAgenticEventSilos: flushNow,
     flushBeacons: flushNow,
     flushNow,
     flushLater,
@@ -11825,6 +11847,7 @@ var buffers = {
     beacons: [],
     silos: [],
     trackEventSilos: [],
+    agenticEventSilos: [],
     lock: lockEvents,
     unlock: unlockAndClear
 };
@@ -12227,6 +12250,10 @@ function collectEvent(type, props, url, name, eventProperties, context) {
         trackEventQueue.push(event);
         return;
     }
+    if (name === 'agentic') {
+        agenticEventQueue.push(event);
+        return;
+    }
     eventQueue.push(attachMonitoringData(store, event));
 }
 function attachMonitoringData(store, event) {
@@ -12788,9 +12815,12 @@ var events;
 var trackEvents;
 var eventQueue;
 var trackEventQueue;
+var agenticEventQueue;
+var agenticEvents;
 function initializeEventBuffer(options) {
     events = buffers.events = eventCache;
     trackEvents = buffers.trackEvents = trackEventCache;
+    agenticEvents = buffers.agenticEvents = agenticEventCache;
     eventQueue = createEventQueue(_.extend({
         cache: events,
         silos: buffers.silos,
@@ -12808,13 +12838,23 @@ function initializeEventBuffer(options) {
             type: 'track'
         }
     }, options));
+    agenticEventQueue = createEventQueue(_.extend({
+        cache: agenticEvents,
+        silos: buffers.agenticEventSilos,
+        apiKey: getAllApiKeys,
+        beacon: 'agentic',
+        class: 'agentic',
+        allowPost: true
+    }, options));
     addEventQueue(eventQueue);
     addEventQueue(trackEventQueue);
+    addEventQueue(agenticEventQueue);
     return () => {
         buffersClearAll();
         removeEventQueue(eventQueue);
         removeEventQueue(trackEventQueue);
-        eventQueue = trackEventQueue = undefined;
+        removeEventQueue(agenticEventQueue);
+        eventQueue = trackEventQueue = agenticEventQueue = undefined;
     };
 }
 
@@ -25557,7 +25597,7 @@ function securityPolicyViolationFn(evt) {
  * @example
  * pendo.initGuides()
  */
-var initGuides = function () {
+var initGuides = function (observer) {
     const teardownFns = [];
     teardownFns.push(initGuideAnalytics({
         localStorageUnload: ConfigReader.get('analytics.localStorageUnload')
@@ -25621,8 +25661,8 @@ var initGuides = function () {
     teardownFns.push(attachEventInternal(window, 'gestureend', adjustGuidesOnGestureEnd, true));
     teardownFns.push(attachEventInternal(window, 'securitypolicyviolation', securityPolicyViolationFn));
     teardownFns.push(createVideoFullScreenListeners());
-    if (ConfigReader.get('preferMutationObserver') && sniffer.MutationObserver) {
-        var updateGuide = function (event) {
+    if (observer.observing) {
+        var updateGuide = function () {
             store.dispatch('guideUpdate/documentChanged');
         };
         const debouncedUpdate = _.debounce(updateGuide, 50);
@@ -25630,10 +25670,8 @@ var initGuides = function () {
         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');
-        if (ConfigReader.get('observeShadowRoots')) {
-            store.commit('guideUpdate/setObserveShadowRoots');
-        }
         teardownFns.push(() => store.dispatch('guideUpdate/stopObserver'));
     }
     /**
@@ -27014,6 +27052,159 @@ const isReady = (pendoObj) => {
     return pendoObj.doesExist(pendoObj.apiKey);
 };
 
+class ShadowDomManager extends EventTarget {
+    constructor() {
+        super();
+        this.cache = new Set();
+        this.foundShadowRoots = false;
+        this.stoppedSearchEarly = false;
+    }
+    updateCache() {
+        // eslint-disable-next-line agent-eslint-rules/no-array-foreach
+        this.cache.forEach(shadowRoot => {
+            if (!isInDocument(shadowRoot)) {
+                this.cache.delete(shadowRoot);
+                this.dispatchEvent({
+                    type: 'detachShadow',
+                    shadowRoot
+                });
+            }
+        });
+    }
+    patchAttachShadow(Element) {
+        const original = Element.prototype.attachShadow;
+        const self = this;
+        Element.prototype.attachShadow = function (options) {
+            const shadowRoot = original.call(this, options);
+            if (this.shadowRoot) {
+                self.triggerAttachShadow(this.shadowRoot);
+            }
+            return shadowRoot;
+        };
+        Element.prototype.attachShadow.toString = function () {
+            return original.toString();
+        };
+        return () => {
+            Element.prototype.attachShadow = original;
+        };
+    }
+    initialize() {
+        this.unpatchAttachShadow = this.patchAttachShadow(Element);
+        this.findShadowRoots(document);
+    }
+    triggerAttachShadow(shadowRoot) {
+        this.cache.add(shadowRoot);
+        this.dispatchEvent({
+            type: 'attachShadow',
+            shadowRoot
+        });
+    }
+    findShadowRoots(document, maxPerSearch = 5000) {
+        if (!_.isFunction(document.createNodeIterator))
+            return;
+        let nodesChecked = 0;
+        let queue = [getBody(document)];
+        let currentNode;
+        function eachShadowRoot(iterator) {
+            do {
+                if (!iterator) {
+                    iterator = document.createNodeIterator(queue.pop(), NodeFilter.SHOW_ELEMENT);
+                }
+                if (!iterator || !iterator.nextNode)
+                    break;
+                while ((currentNode = iterator.nextNode())) {
+                    nodesChecked++;
+                    if (currentNode && currentNode.shadowRoot) {
+                        this.triggerAttachShadow(currentNode.shadowRoot);
+                        queue.push(currentNode.shadowRoot);
+                        this.foundShadowRoots = true;
+                    }
+                    if (nodesChecked % maxPerSearch === 0)
+                        break;
+                }
+                if (currentNode)
+                    break;
+                iterator = null;
+            } while (queue.length);
+            if (currentNode && this.foundShadowRoots) {
+                this.findTimeout = setTimeout$1(() => {
+                    this.findTimeout = null;
+                    eachShadowRoot.call(this, iterator);
+                }, 50);
+            }
+            if (nodesChecked === maxPerSearch && !this.foundShadowRoots) {
+                this.stoppedSearchEarly = true;
+            }
+        }
+        eachShadowRoot.call(this);
+    }
+    teardown() {
+        this.cache.clear();
+        if (_.isFunction(this.unpatchAttachShadow)) {
+            this.unpatchAttachShadow();
+            this.unpatchAttachShadow = null;
+        }
+        if (this.findTimeout) {
+            clearTimeout(this.findTimeout);
+            this.findTimeout = null;
+        }
+    }
+}
+
+class UberMutationObserver extends EventTarget {
+    constructor(observerClass = getZoneSafeMethod('MutationObserver')) {
+        super();
+        this.ObserverClass = observerClass;
+        this.observing = false;
+        this.observers = new Map();
+        this.shadowDom = new ShadowDomManager();
+        this.shadowDom.addEventListener('attachShadow', _.bind(this.handleAttachShadow, this));
+        this.shadowDom.addEventListener('detachShadow', _.bind(this.handleDetachShadow, this));
+        this.addEventListener('mutation', () => {
+            this.shadowDom.updateCache();
+        });
+    }
+    initialize(pendo, PluginAPI) {
+        const configReader = PluginAPI.ConfigReader;
+        if (!configReader.get('preferMutationObserver') || !pendo.sniffer.MutationObserver) {
+            return;
+        }
+        this.observeShadowRoots = configReader.get('observeShadowRoots');
+        this.startObserver(document.documentElement);
+        this.observing = true;
+        if (this.observeShadowRoots) {
+            this.shadowDom.initialize();
+        }
+    }
+    startObserver(target) {
+        const observer = new this.ObserverClass(_.bind(this.triggerMutation, this));
+        this.observers.set(target, observer);
+        observer.observe(target, {
+            subtree: true,
+            attributes: true,
+            childList: true,
+            characterData: true
+        });
+    }
+    teardown() {
+        this.observers.clear();
+        this.shadowDom.teardown();
+    }
+    triggerMutation(mutation) {
+        this.dispatchEvent({
+            type: 'mutation',
+            mutation
+        });
+    }
+    handleAttachShadow({ shadowRoot }) {
+        this.startObserver(shadowRoot);
+    }
+    handleDetachShadow({ shadowRoot }) {
+        this.observers.delete(shadowRoot);
+    }
+}
+var observer = new UberMutationObserver();
+
 // ---------------------------------------------------------------------------
 function registerEventHandlers({ events = [] }) {
     _.each(events, (callback, eventName) => {
@@ -27124,6 +27315,9 @@ const initialize = makeSafe(function (options) {
     teardownFns.push(initializeEventBuffer({
         localStorageUnload: localStorageUnloadEnabled
     }));
+    // needs to happen before initGuides
+    observer.initialize(pendo$1, PluginAPI);
+    teardownFns.push(() => observer.teardown());
     if (pendoCore) {
         /**
         * Current visitor id for pendo installation, either anonymous or identified. Used to determine
@@ -27177,7 +27371,7 @@ const initialize = makeSafe(function (options) {
         // Register handlers passed through pendo_options
         teardownFns.push(forwardInternalEvents(Events));
         registerEventHandlers(options);
-        teardownFns.push(initGuides()); // this is safe.  loadGuides actually does the loading.
+        teardownFns.push(initGuides(observer)); // this is safe.  loadGuides actually does the loading.
         initIdentityEvents(); // setup identify and meta event listeners
         teardownFns.push(wirePage());
         teardownFns.push(initializePlugins());
@@ -28188,26 +28382,59 @@ logPublic.showLogHistory = showLogHistory;
 logPublic.getLoggedContexts = getLoggedContexts;
 
 /**
- * Method to manually track events. Requires a non-empty name string to collect event.
- *
- * @access public
- * @category Events
- * @param {string} name name of the collected event
- * @param {Object} [props] optional properties object to collect with to the event
- * @example
- * pendo.track('scroll')
+ * Shared helper for event collection
  */
-function track(name, props) {
+function collectEventHelper({ type, name, props }) {
     if (!name || !_.isString(name)) {
         log.error('Must provide valid name string for event tracking');
         return;
     }
+    if (!type || !_.isString(type)) {
+        log.error('Must provide valid type string for event tracking');
+        return;
+    }
     let correctedProps = props;
     if (!_.isObject(props)) {
         correctedProps = { __err__: props };
     }
     var url = pendoDotUrl.get();
-    collectEvent('track', correctedProps, url, name);
+    collectEvent(type, correctedProps, url, name);
+}
+/**
+ * Method to manually track events. Requires a non-empty name string to collect event.
+ *
+ * @access public
+ * @category Events
+ * @param {string} name name of the collected event
+ * @param {Object} [props] optional properties object to collect with to the event
+ * @example
+ * pendo.track('scroll')
+ */
+function track(name, props) {
+    collectEventHelper({ type: 'track', name, props });
+}
+
+/**
+ * Method to manually track agentic events. Uses agent functions for IDs and context.
+ *
+ * @access public
+ * @category Events
+ * @param {string} type type of the collected agentic event ['prompt', 'system_response', 'user_reaction']
+ * @param {Object} props event-specific properties object
+ * @example
+ * pendo.trackAgent('type_of_event', {
+ *   agentId: 'weather_assistant',
+ *   conversationId: 'conv_abc123',
+ *   messageId: 'msg_xyz789',
+ *   content: 'thumbs_up',
+ *   modelUsed: 'gpt-4',
+ *   suggestedPrompt: false,
+ *   toolsUsed: [],
+ *   fileUploaded: false
+ * })
+ */
+function trackAgent(type, props) {
+    collectEventHelper({ type, name: 'agentic', props });
 }
 
 /**
@@ -29193,6 +29420,7 @@ function exportPublicApi(pendo) {
     pendo.fromByteArray = b64.uint8ToBase64;
     pendo.events = exportPendoCoreOnly(PublicEvents);
     pendo.track = exportPendoCoreOnly(track);
+    pendo.trackAgent = exportPendoCoreOnly(trackAgent);
     pendo.validateInstall = validateInstall;
     pendo.validateNativeMethods = validateNativeMethods;
     pendo.validateBuiltInGlobals = validateBuiltInGlobals;
@@ -32089,75 +32317,6 @@ function updateMasterGuideList(state) {
     }
 }
 
-function addShadowObserver(shadowRoot, observerCallback) {
-    const MutationObserver = getZoneSafeMethod('MutationObserver');
-    const shadowObserver = new MutationObserver(observerCallback);
-    shadowObserver.observe(shadowRoot, {
-        subtree: true,
-        attributes: true,
-        childList: true,
-        characterData: true
-    });
-}
-function patchAttachShadow(observerCallback) {
-    const original = Element.prototype.attachShadow;
-    Element.prototype.attachShadow = function (options) {
-        const shadowRoot = original.call(this, options);
-        if (this.shadowRoot) {
-            addShadowObserver(this.shadowRoot, observerCallback);
-        }
-        return shadowRoot;
-    };
-    Element.prototype.attachShadow.toString = function () {
-        return original.toString();
-    };
-}
-function startObserver(observerCallback) {
-    patchAttachShadow(observerCallback);
-    if (!_.isFunction(document.createNodeIterator))
-        return;
-    const maxPerSearch = 5000;
-    let nodesChecked = 0;
-    let queue = [getBody()];
-    let currentNode;
-    function eachShadowRoot(iterator) {
-        do {
-            if (!iterator) {
-                iterator = document.createNodeIterator(queue.pop(), NodeFilter.SHOW_ELEMENT);
-            }
-            if (!iterator || !iterator.nextNode)
-                break;
-            while ((currentNode = iterator.nextNode())) {
-                nodesChecked++;
-                if (currentNode && currentNode.shadowRoot) {
-                    addShadowObserver(currentNode.shadowRoot, observerCallback);
-                    queue.push(currentNode.shadowRoot);
-                    shadowDomManager.foundShadowRoots = true;
-                }
-                if (nodesChecked % maxPerSearch === 0)
-                    break;
-            }
-            if (currentNode)
-                break;
-            iterator = null;
-        } while (queue.length);
-        if (currentNode && shadowDomManager.foundShadowRoots) {
-            setTimeout$1(() => {
-                eachShadowRoot(iterator);
-            }, 50);
-        }
-        if (nodesChecked === maxPerSearch && !shadowDomManager.foundShadowRoots) {
-            shadowDomManager.stoppedSearchEarly = true;
-        }
-    }
-    eachShadowRoot();
-}
-const shadowDomManager = {
-    startObserver,
-    foundShadowRoots: false,
-    stoppedSearchEarly: false
-};
-
 var GuideUpdateModule = (function () {
     var observer;
     function observerCallback() {
@@ -32168,7 +32327,6 @@ var GuideUpdateModule = (function () {
     }
     var state = {
         useObserver: false,
-        observeShadowRoots: false,
         observing: false,
         needsUpdate: false,
         scheduledUpdate: null,
@@ -32199,43 +32357,31 @@ var GuideUpdateModule = (function () {
                 context.commit('setScheduledUpdate', null);
             }
         },
-        startObserverIfNeeded(context, observerClass) {
+        startObserverIfNeeded(context) {
             if (context.state.useObserver) {
-                var observerInstance = context.getters.observer();
-                if (!observerInstance) {
-                    observerInstance = new (observerClass || getZoneSafeMethod('MutationObserver'))(observerCallback);
-                    observer = observerInstance;
-                }
                 if (!context.state.observing) {
-                    observerInstance.observe(document.documentElement, {
-                        subtree: true,
-                        attributes: true,
-                        childList: true,
-                        characterData: true
-                    });
-                    if (context.state.observeShadowRoots) {
-                        shadowDomManager.startObserver(observerCallback);
-                    }
+                    const observer = context.getters.observer();
+                    observer.addEventListener('mutation', observerCallback);
                     context.commit('setObserving', true);
                 }
             }
         },
         stopObserver(context) {
-            var observerInstance = context.getters.observer();
-            if (observerInstance && _.isFunction(observerInstance.disconnect)) {
-                observerInstance.disconnect();
+            const observer = context.getters.observer();
+            if (observer) {
+                observer.removeEventListener('mutation', observerCallback);
             }
             context.commit('setObserving', false);
             context.dispatch('stopScheduledUpdate');
         }
     };
     var mutations = {
+        setObserver(state, _observer) {
+            observer = _observer;
+        },
         setUseObserver(state) {
             state.useObserver = true;
         },
-        setObserveShadowRoots(state) {
-            state.observeShadowRoots = true;
-        },
         setObserving(state, observing) {
             state.observing = observing;
         },
@@ -36150,7 +36296,8 @@ function debuggerExports() {
         isStagingServer,
         AutoDisplay,
         isLeader,
-        Events
+        Events,
+        observer
     };
 }
 function startDebuggingModuleIfEnabled() {
@@ -38482,7 +38629,7 @@ function populatePendoObject(pendo) {
     exportPublicApi(pendo);
     exportDeprecated(pendo);
     // Delay execution of these methods until initialize is called:
-    _.each(['identify', 'updateOptions', 'pageLoad', 'track'], function (method) {
+    _.each(['identify', 'updateOptions', 'pageLoad', 'track', 'trackAgent'], function (method) {
         var originalMethod = pendo[method];
         pendo[method] = function () {
             try {
@@ -38500,7 +38647,7 @@ function populatePendoObject(pendo) {
     });
 }
 function stubSnippetMethods(pendo) {
-    _.each(['initialize', 'identify', 'updateOptions', 'pageLoad', 'track'], function (method) {
+    _.each(['initialize', 'identify', 'updateOptions', 'pageLoad', 'track', 'trackAgent'], function (method) {
         pendo[method] = function () {
             console.log('Pendo is currently disabled.');
         };
@@ -38529,7 +38676,7 @@ function initAgent(pendo, PendoConfig) {
     AsyncContent.reset();
     store.dispatch('frames/init');
     logPublic.init();
-    shadowAPI.wrapSizzle(SizzleProxy);
+    shadowAPI.wrapSizzle(SizzleProxy, observer.shadowDom);
     SizzleProxy.intercept(sizzleAttachPointInterceptor);
     populatePendoObject(pendo);
     log.addEventListener('log', _.partial(store.dispatch, 'errorLog/write'));
@@ -48210,7 +48357,7 @@ var WorkerFactory = /*#__PURE__*/createInlineWorkerFactory(/* rollup-plugin-web-
 
     const ONE_HUNDRED_MB_IN_BYTES = 100 * 1024 * 1024;
     function matchHostedResources(recordingEvent, stringifiedRecordingPayload) {
-        const fontURLRegex = /https:\/\/[^\s]+?\.(woff|woff2|ttf|otf|eot)\b/g;
+        const fontURLRegex = /https:\/\/[^\s]+?\.(woff2?|ttf|otf|eot)(\?[^\s]*)?\b/g;
         const hostedResources = stringifiedRecordingPayload.match(fontURLRegex);
         return {
             type: 'recording',