@pendo/agent 2.332.2 → 2.333.1

package/dist/pendo.module.js

@@ -4028,8 +4028,8 @@ let SERVER = '';
 let ASSET_HOST = '';
 let ASSET_PATH = '';
 let DESIGNER_SERVER = '';
-let VERSION = '2.332.2_';
-let PACKAGE_VERSION = '2.332.2';
+let VERSION = '2.333.1_';
+let PACKAGE_VERSION = '2.333.1';
 let LOADER = 'xhr';
 /* eslint-enable web-sdk-eslint-rules/no-gulp-env-references */
 /**
@@ -15080,6 +15080,16 @@ function findGuideContainerJSON(buildingBlocks) {
         });
     }
 }
+function correctGuideContainerId(containerJSON, stepId, guideId) {
+    if (!containerJSON || !containerJSON.props || !containerJSON.props.id)
+        return;
+    var currentId = containerJSON.props.id;
+    var isCorrect = (stepId && currentId === `pendo-g-${stepId}`) ||
+        (guideId && currentId === `pendo-g-${guideId}`);
+    if (!isCorrect && stepId) {
+        containerJSON.props.id = `pendo-g-${stepId}`;
+    }
+}
 function findDomBlockInDomJson(domJson, truthTestFn) {
     if (truthTestFn(domJson))
         return domJson;
@@ -29609,6 +29619,7 @@ var BuildingBlockGuides = (function () {
             detectColorMode(step);
         }
         var containerJSON = findGuideContainerJSON(json);
+        correctGuideContainerId(containerJSON, step.id, guide.id);
         var isResourceCenter = _.get(guide, 'attributes.resourceCenter');
         if (isResourceCenter) {
             BuildingBlockResourceCenter.revertRtlChanges(guide, json.props);
@@ -34792,6 +34803,201 @@ var PreviewModule = (function () {
     };
 })();
 
+const CONTAINER_ID = 'pendo-debugger-highlight-overlay';
+const BORDER_COLOR = '#FF4876';
+const BORDER_GLOW = 'rgba(255, 72, 118, 0.35)';
+const HIGHLIGHT_Z_INDEX = '2147483644';
+const ANIMATION_DURATION_MS = 500;
+const AUTO_CLEAR_MS = 10000;
+const BORDER_STYLES = {
+    'box-sizing': 'border-box',
+    'border': `2px solid ${BORDER_COLOR}`,
+    'border-radius': '2px',
+    'box-shadow': `0 0 0 2px ${BORDER_GLOW}`,
+    'pointer-events': 'none',
+    'z-index': HIGHLIGHT_Z_INDEX
+};
+let doc = document;
+let win = window;
+let container = null;
+let targets = [];
+let overlays = [];
+let resizeObserver = null;
+let autoClearTimer = null;
+function getContainer(dom) {
+    if (container && container.isConnected)
+        return container;
+    container = dom('<div>').css({
+        'position': 'absolute',
+        'top': 0,
+        'left': 0,
+        'width': 0,
+        'height': 0,
+        'margin': 0,
+        'padding': 0,
+        'border': 0,
+        'pointer-events': 'none'
+    }).appendTo(doc.documentElement || doc.body)[0];
+    container.id = CONTAINER_ID;
+    return container;
+}
+function positionOverlays() {
+    const scrollX = win.scrollX || win.pageXOffset || 0;
+    const scrollY = win.scrollY || win.pageYOffset || 0;
+    for (let i = 0; i < overlays.length; i++) {
+        const { el, box } = overlays[i];
+        if (!el || typeof el.getBoundingClientRect !== 'function')
+            continue;
+        const rect = el.getBoundingClientRect();
+        box.style.top = `${rect.top + scrollY}px`;
+        box.style.left = `${rect.left + scrollX}px`;
+        box.style.width = `${rect.width}px`;
+        box.style.height = `${rect.height}px`;
+    }
+}
+function buildOverlays(dom) {
+    const node = getContainer(dom);
+    node.textContent = '';
+    overlays = [];
+    for (let i = 0; i < targets.length; i++) {
+        const el = targets[i];
+        if (!el || typeof el.getBoundingClientRect !== 'function')
+            continue;
+        const rect = el.getBoundingClientRect();
+        if (rect.width === 0 && rect.height === 0)
+            continue;
+        const box = dom('<div>')
+            .css(Object.assign({ position: 'absolute' }, BORDER_STYLES))
+            .appendTo(node)[0];
+        overlays.push({ el, box });
+    }
+    positionOverlays();
+}
+function observeLayout() {
+    if (typeof win.ResizeObserver !== 'function')
+        return;
+    resizeObserver = new win.ResizeObserver(() => positionOverlays());
+    resizeObserver.observe(doc.documentElement);
+    for (let i = 0; i < overlays.length; i++) {
+        resizeObserver.observe(overlays[i].el);
+    }
+}
+function armAutoClear() {
+    if (autoClearTimer)
+        clearTimeout(autoClearTimer);
+    autoClearTimer = win.setTimeout(clearHighlights, AUTO_CLEAR_MS);
+}
+function isInViewport(rect) {
+    const vh = win.innerHeight || doc.documentElement.clientHeight;
+    const vw = win.innerWidth || doc.documentElement.clientWidth;
+    return rect.bottom > 0 && rect.right > 0 && rect.top < vh && rect.left < vw;
+}
+function scrollIntoViewIfNeeded(elements) {
+    const anyVisible = elements.some(el => isInViewport(el.getBoundingClientRect()));
+    if (anyVisible)
+        return;
+    const first = elements[0];
+    if (first && typeof first.scrollIntoView === 'function') {
+        first.scrollIntoView({ block: 'center', inline: 'center' });
+    }
+}
+function animateFocusRing(dom, el) {
+    if (!el || typeof el.animate !== 'function')
+        return;
+    const rect = el.getBoundingClientRect();
+    if (rect.width === 0 && rect.height === 0)
+        return;
+    const ring = dom('<div>')
+        .css(Object.assign({ position: 'fixed' }, BORDER_STYLES))
+        .appendTo(doc.documentElement || doc.body)[0];
+    const animation = ring.animate([
+        { top: '0px', left: '0px', width: '100vw', height: '100vh', borderRadius: '0px', opacity: 0 },
+        { opacity: 1, offset: 0.2 },
+        {
+            top: `${rect.top}px`,
+            left: `${rect.left}px`,
+            width: `${rect.width}px`,
+            height: `${rect.height}px`,
+            borderRadius: '2px',
+            opacity: 1
+        }
+    ], { duration: ANIMATION_DURATION_MS, easing: 'ease-in-out' });
+    animation.onfinish = () => {
+        if (ring.parentNode)
+            ring.parentNode.removeChild(ring);
+    };
+}
+function highlight(dom, elements) {
+    clearHighlights();
+    targets = [];
+    for (let i = 0; i < elements.length; i++) {
+        const el = elements[i];
+        if (el && el.nodeType === 1)
+            targets.push(el);
+    }
+    if (!targets.length)
+        return 0;
+    doc = targets[0].ownerDocument || document;
+    win = doc.defaultView || window;
+    scrollIntoViewIfNeeded(targets);
+    buildOverlays(dom);
+    observeLayout();
+    animateFocusRing(dom, targets[0]);
+    armAutoClear();
+    return targets.length;
+}
+function highlightElements(dom, selector) {
+    try {
+        const query = dom(selector);
+        const total = query ? query.length : 0;
+        const elements = [];
+        for (let i = 0; i < total; i++) {
+            elements.push(query[i]);
+        }
+        return highlight(dom, elements);
+    }
+    catch (e) {
+        clearHighlights();
+        return 0;
+    }
+}
+function highlightFrameElement(dom) {
+    let frameEl = null;
+    try {
+        frameEl = window.frameElement;
+    }
+    catch (e) {
+        frameEl = null;
+    }
+    if (frameEl) {
+        try {
+            return highlight(dom, [frameEl]);
+        }
+        catch (e) {
+            clearHighlights();
+            return 0;
+        }
+    }
+    return highlightElements(dom, 'body');
+}
+function clearHighlights() {
+    if (autoClearTimer) {
+        clearTimeout(autoClearTimer);
+        autoClearTimer = null;
+    }
+    if (resizeObserver) {
+        resizeObserver.disconnect();
+        resizeObserver = null;
+    }
+    targets = [];
+    overlays = [];
+    if (container) {
+        if (container.parentNode)
+            container.parentNode.removeChild(container);
+        container = null;
+    }
+}
+
 const DebuggerModule = (() => {
     const state = {
         isLeader: undefined,
@@ -34973,6 +35179,49 @@ const DebuggerModule = (() => {
                 }).then(result => JSON.parse(result));
             });
             q.all(framePromises).then(results => response(results));
+        },
+        highlightElement(context, payload) {
+            const { selector, targetFrame, outlineFrame, response } = payload;
+            const frames = targetFrame
+                ? _.filter(store.state.frames.frames, frame => frame.id === targetFrame)
+                : _.values(store.state.frames.frames);
+            const framePromises = _.map(frames, frame => {
+                return crossFrameChannel.postMessageOrTimeout({
+                    action: 'debugger/highlightInFrame',
+                    targetFrame: frame.id,
+                    selector,
+                    outlineFrame
+                }).then(result => JSON.parse(result)).catch(() => ({ count: 0 }));
+            });
+            q.all(framePromises).then(results => {
+                const count = _.reduce(results, (sum, result) => sum + (result.count || 0), 0);
+                if (response)
+                    response({ count });
+            });
+        },
+        clearHighlight() {
+            crossFrameChannel.postMessage({
+                action: 'debugger/clearHighlightInFrame'
+            });
+        },
+        highlightInFrame(context, payload) {
+            const { selector, outlineFrame, sourceFrame, promiseId } = payload;
+            const count = outlineFrame
+                ? highlightFrameElement(pendo$1.dom)
+                : highlightElements(pendo$1.dom, selector);
+            if (promiseId && sourceFrame) {
+                crossFrameChannel.postMessage({
+                    action: 'debuggerHighlightResponse',
+                    targetFrame: sourceFrame,
+                    resolveId: promiseId,
+                    frameId: context.state.frameId,
+                    count
+                });
+            }
+            return { count };
+        },
+        clearHighlightInFrame() {
+            clearHighlights();
         }
     };
     const getters = {};
@@ -37848,6 +38097,94 @@ const IFrameMonitor = (function () {
     }
 })();
 
+const MAX_TRACKED_PAIRS = 10;
+const ObjectMetadata = (function () {
+    let globalPendo;
+    let pluginApi;
+    // {objectId, type} pair -> crc32(metadata), persisted so we don't resend unchanged object
+    // metadata across page loads. This is purely a send-dedup cache and is not tied to visitor
+    // identity. Map insertion order gives us LRU eviction: re-storing a pair moves it to newest.
+    let sentHashes;
+    /**
+     * Persisted crc32 hashes of the last object metadata sent for each {objectId, type} pair. Used to avoid
+     * resending unchanged object metadata across page loads.
+     *
+     * @name _pendo_objectMetadata
+     * @category Cookies/localStorage
+     * @access public
+     * @label OBJECT_METADATA
+     */
+    var OBJECT_METADATA = 'objectMetadata';
+    /**
+     * Sends metadata for an arbitrary object, identified by an id and type. Unlike `updateOptions`, which
+     * targets the current visitor/account, this associates metadata with a caller-defined object. The metadata
+     * is only sent when it differs from the last payload sent for the same object id + type, so calling this
+     * repeatedly with unchanged metadata is a no-op.
+     *
+     * @access public
+     * @function
+     * @category Identity
+     * @param {string} objectId the object's id
+     * @param {string} type the object's type
+     * @param {object} metadata the metadata payload to associate with the object
+     * @example
+     * pendo.objectMetadata('order-1234', 'order', { total: 42.5, status: 'shipped' });
+     */
+    function objectMetadata(objectId, type, metadata) {
+        if (!isValidValue(objectId) || !isValidValue(type)) {
+            pluginApi.log.warn('objectMetadata requires a non-empty objectId and type.');
+            return;
+        }
+        var key = JSON.stringify([objectId, type]);
+        var hash = crc32(metadata);
+        if (sentHashes.get(key) === hash) {
+            // Unchanged since the last send; refresh recency and skip.
+            sentHashes.delete(key);
+            sentHashes.set(key, hash);
+            return;
+        }
+        sentHashes.delete(key);
+        sentHashes.set(key, hash);
+        if (sentHashes.size > MAX_TRACKED_PAIRS) {
+            sentHashes.delete(sentHashes.keys().next().value);
+        }
+        persistHashes();
+        pluginApi.analytics.collectEvent('objectMetadata', { objectId, type, metadata });
+        globalPendo.buffers.flushLater();
+    }
+    return {
+        name: 'ObjectMetadata',
+        initialize,
+        teardown,
+        objectMetadata
+    };
+    function initialize(pendo, PluginAPI) {
+        globalPendo = pendo;
+        pluginApi = PluginAPI;
+        pluginApi.agentStorage.registry.addLocal(OBJECT_METADATA, {
+            isSecure: true,
+            localStorageOnly: true,
+            serializer: JSON.stringify,
+            deserializer: SafeJsonDeserializer
+        });
+        sentHashes = loadHashes();
+        globalPendo.objectMetadata = objectMetadata;
+    }
+    function teardown() {
+        delete globalPendo.objectMetadata;
+    }
+    function loadHashes() {
+        var stored = pluginApi.agentStorage.read(OBJECT_METADATA);
+        return Array.isArray(stored) ? new Map(stored) : new Map();
+    }
+    function persistHashes() {
+        pluginApi.agentStorage.write(OBJECT_METADATA, Array.from(sentHashes));
+    }
+    function isValidValue(value) {
+        return typeof value === 'string' && value.length > 0;
+    }
+})();
+
 /**
  * OEM Account ID Plugin
  *
@@ -41072,6 +41409,7 @@ function registerBuiltInPlugins() {
     registerPlugin(FrustrationEvent);
     registerPlugin(GuideCachePlugin);
     registerPlugin(IFrameMonitor);
+    registerPlugin(ObjectMetadata);
     registerPlugin(OemAccountId);
     registerPlugin(P1GuidePlugin);
     registerPlugin(PromoteMetadata);
@@ -51282,12 +51620,12 @@ var WorkerFactory = /*#__PURE__*/createInlineWorkerFactory(/* rollup-plugin-web-
         }
     }
 
-    var ONE_HUNDRED_MB_IN_BYTES = 100 * 1024 * 1024;
+    const ONE_HUNDRED_MB_IN_BYTES = 100 * 1024 * 1024;
     function matchHostedResources(recordingEvent, stringifiedRecordingPayload) {
-        var fontURLRegex = /https:\/\/[^"\\\s]+?\.(woff2?|ttf|otf|eot)(\?[^"\\\s]*)?\b/g;
-        var matches = stringifiedRecordingPayload.match(fontURLRegex);
+        const fontURLRegex = /https:\/\/[^"\\\s]+?\.(woff2?|ttf|otf|eot)(\?[^"\\\s]*)?\b/g;
+        const matches = stringifiedRecordingPayload.match(fontURLRegex);
         // de-duplicate matches
-        var hostedResources = matches ? Array.from(new Set(matches)) : [];
+        const hostedResources = matches ? Array.from(new Set(matches)) : [];
         return {
             type: 'recording',
             visitorId: recordingEvent.visitorId,
@@ -51302,7 +51640,7 @@ var WorkerFactory = /*#__PURE__*/createInlineWorkerFactory(/* rollup-plugin-web-
             recordingPayloadMetadata: [],
             sequence: 0,
             recordingPayloadCount: 0,
-            hostedResources: hostedResources
+            hostedResources
         };
     }
     // keep in mind changes here may need addressing in the extension worker proxy as well
@@ -51310,69 +51648,69 @@ var WorkerFactory = /*#__PURE__*/createInlineWorkerFactory(/* rollup-plugin-web-
         try {
             if (e.data.type === 'init' && e.data.lockID) {
                 if (navigator.locks) {
-                    navigator.locks.request(e.data.lockID, function () {
+                    navigator.locks.request(e.data.lockID, () => {
                         postMessage({ ready: true });
                         // This unresolved promise keeps the lock held with the worker until the worker is
                         // terminated at which point the lock is released.
-                        return new Promise$2(function () { });
+                        return new Promise$2(() => { });
                     });
                 }
                 return;
             }
             if (e.data.url && e.data.payload) {
-                var _a = e.data, url = _a.url, payload = _a.payload, shouldCacheResources = _a.shouldCacheResources;
+                let { url, payload, shouldCacheResources } = e.data;
                 if (Object.keys(payload).length === 0) {
                     postMessage({
                         type: 'emptyPayload'
                     });
                 }
-                var sequence_1 = payload.sequence;
-                var stringifiedRecordingPayload = JSON.stringify(payload.recordingPayload);
+                const { sequence } = payload;
+                const stringifiedRecordingPayload = JSON.stringify(payload.recordingPayload);
                 // calculate and post back the recording payload size before the payload is compressed
-                var recordingPayloadSize = new TextEncoder().encode(stringifiedRecordingPayload).length;
-                var exceedsPayloadSizeLimit = recordingPayloadSize >= ONE_HUNDRED_MB_IN_BYTES;
+                const recordingPayloadSize = new TextEncoder().encode(stringifiedRecordingPayload).length;
+                const exceedsPayloadSizeLimit = recordingPayloadSize >= ONE_HUNDRED_MB_IN_BYTES;
                 postMessage({
                     type: 'recordingPayloadSize',
-                    recordingPayloadSize: recordingPayloadSize,
-                    exceedsPayloadSizeLimit: exceedsPayloadSizeLimit
+                    recordingPayloadSize,
+                    exceedsPayloadSizeLimit
                 });
                 // don't attempt to send the payload if it exceeds the allowed limit
                 if (exceedsPayloadSizeLimit)
                     return;
                 if (shouldCacheResources) {
-                    var hostedResourcesEvent = matchHostedResources(payload, stringifiedRecordingPayload);
+                    const hostedResourcesEvent = matchHostedResources(payload, stringifiedRecordingPayload);
                     if (hostedResourcesEvent.hostedResources.length) {
                         postMessage({
                             type: 'hostedResources',
-                            hostedResourcesEvent: hostedResourcesEvent
+                            hostedResourcesEvent
                         });
                     }
                 }
                 payload.recordingSize = recordingPayloadSize;
-                var body = compress(payload, 'binary');
+                const body = compress(payload, 'binary');
                 // we want to calculate ct (current time) as close as we can to the actual POST request
                 // so that it's as accurate as possible
-                url = "".concat(url, "&ct=").concat(new Date().getTime());
+                url = `${url}&ct=${new Date().getTime()}`;
                 fetch(url, {
                     method: 'POST',
-                    body: body
+                    body
                 }).then(function (response) {
                     if (response.status < 200 || response.status >= 300) {
                         postMessage({
-                            error: new Error("received status code ".concat(response.status, ": ").concat(response.statusText)),
+                            error: new Error(`received status code ${response.status}: ${response.statusText}`),
                             status: response.status,
-                            sequence: sequence_1
+                            sequence
                         });
                     }
                     else {
                         postMessage({
-                            sequence: sequence_1
+                            sequence
                         });
                     }
-                })["catch"](function (e) {
+                }).catch(function (e) {
                     postMessage({
                         error: e,
-                        sequence: sequence_1
+                        sequence
                     });
                 });
             }
@@ -55253,10 +55591,18 @@ const REQUIRED_SELECTORS = [
     TURN_CONTAINER,
     USER_MESSAGE
 ];
-const SUPPORTED_PRESETS = ['chatgpt-full', 'gemini-full', 'claude-full', 'copilot-full'];
+const SUPPORTED_PRESETS = [
+    'chatgpt-full',
+    'gemini-full',
+    'claude-full',
+    'copilot-full',
+    'copilot-m365-full'
+];
 const STREAMING_END_SETTLE_MS = 500;
 const SUBMISSION_START_RETRY_MS = 1000;
 const SUBMISSION_START_MAX_ATTEMPTS = 4;
+const NEW_CONVERSATION_TTL_MS = 5 * 60 * 1000;
+const NEW_CONVERSATION_KEY = 'pendo_pca_new_conv';
 class DOMConversation {
     // Returns the list of required selector types that are missing or empty
     // in the given cssSelectors config. An empty array means the config is
@@ -55368,6 +55714,21 @@ class DOMConversation {
             content
         });
     }
+    // On a new M365 conversation the browser does a full page reload to the
+    // conversation URL. the old page sets FRESH_CONVERSATION_KEY when streaming starts
+    // without a conversation id; the new page picks it up here and triggers onSubmissionEnd
+    // to scan the already-rendered messages.
+    tryFlushNewConversation() {
+        const ts = +this.api.sessionStorage.getItem(NEW_CONVERSATION_KEY);
+        if (!ts)
+            return;
+        this.api.sessionStorage.removeItem(NEW_CONVERSATION_KEY);
+        if (Date.now() - ts > NEW_CONVERSATION_TTL_MS)
+            return;
+        if (!this.getConversationId())
+            return;
+        this.startStreamingEndTimer();
+    }
     // observe the streaming indicator
     setupStreamingObserver() {
         this.wasStreaming = this.select(STREAMING_ACTIVE).length > 0;
@@ -55397,6 +55758,11 @@ class DOMConversation {
             return;
         if (isStreaming) { // started streaming
             if (!this.streamingEndTimer) {
+                if (!this.getConversationId()) {
+                    // Full-page reload expected on fresh chat: persist a flag so the
+                    // new page can emit the prompt + response after the reload.
+                    this.api.sessionStorage.setItem(NEW_CONVERSATION_KEY, String(Date.now()));
+                }
                 this.onSubmissionStart();
             }
             else {
@@ -55425,6 +55791,9 @@ class DOMConversation {
     }
     onSubmissionEnd() {
         this.stopSubmissionStartRetryTimer();
+        if (this.getConversationId()) {
+            this.api.sessionStorage.removeItem(NEW_CONVERSATION_KEY);
+        }
         let requestNode = this.requestNode;
         this.requestNode = null;
         if (!requestNode) {
@@ -55612,6 +55981,7 @@ class DOMConversation {
     }
     resume() {
         this.isActive = true;
+        this.tryFlushNewConversation();
     }
     teardown() {
         this._.each(this.observers, (o) => o && o.disconnect && o.disconnect());