@pendo/agent 2.275.1 → 2.277.0

package/README.md

@@ -45,7 +45,7 @@ The object returned by calling `initialize` is the same as a snippet install of
 | key | required? | type | description |
 | --- | --------- | ---- | ----------  |
 | apiKey | required | string | Your specific application `apiKey` can be found by going to the application details page in the Pendo App for your application. It will be a 32-digit code that identifies that application and connects it to Pendo. |
-| env | required | string | The environment that your Pendo subscription resides in. `io` is the default US environment and environments other than that can be found in the url that you use to access Pendo (e.g. app.`eu`.pendo.io). One of: ['io', 'eu', 'jpn', 'us1', 'au']. |
+| env | required | string | The environment that your Pendo subscription resides in. `io` is the default US environment and environments other than that can be found in the url that you use to access Pendo (e.g. app.`eu`.pendo.io). One of: ['io', 'eu', 'jpn', 'us1', 'au', 'gov']. |
 | visitor | optional | object | The visitor information for the current user of your application. This includes the `id` and any other metadata you want attached to the visitor. If not provided the visitor will be treated as an anonymous visitor. |
 | account | optional | object | The account information for the current user of your application if applicable. If not provided the visitor will not be assigned to an account. |
 | globalKey | optional | string | The key where you would like the global `pendo` object to be stored after initialization. By default this will be stored on `window.pendo` but this allows it to change to a different name if desired. |

package/dist/dom.esm.js

@@ -7094,7 +7094,11 @@ var sniffer = {
 
 // other node types can be read about here:
 // https://developer.mozilla.org/en-US/docs/Web/API/Node/nodeType
+var TEXT = 3;
 var ELEMENT = 1;
+var DOCUMENT = 9;
+var DOCUMENT_FRAGMENT = 11;
+var CDATA_SECTION = 4;
 function isElementNode(node) {
     return node && node.nodeType === ELEMENT;
 }
@@ -7224,7 +7228,7 @@ function getScreenPosition(element) {
     };
 }
 
-var VERSION = '2.275.1_';
+var VERSION = '2.277.0_';
 function isExtensionAgent() {
     var installType = getPendoConfigValue('installType') || getPendoConfigFromEnclosingScope().installType;
     return installType === EXTENSION_INSTALL_TYPE;
@@ -8635,14 +8639,15 @@ function roundOffsetPosition(position) {
     });
     return position;
 }
-function getOffsetPosition(element) {
+function getOffsetPosition(element, _win) {
+    if (_win === void 0) { _win = window; }
     if (isPositionFixed(element)) {
         var fixedPosition = getScreenPosition(element);
         fixedPosition.fixed = true;
         return roundOffsetPosition(fixedPosition);
     }
     else {
-        var absolutePosition = getAbsolutePosition(element, getBody());
+        var absolutePosition = getAbsolutePosition(element, getBody(_win.document), _win);
         return roundOffsetPosition(absolutePosition);
     }
 }
@@ -9594,6 +9599,233 @@ DomQuery.$ = {
     }
 };
 
+/**
+ * Abstraction on top of Mutation Observer that has a naive polyfill to use setTimeout and look
+ * every half second for changes.
+ *
+ * This observer only attempts to verify changes to `isInDocument` status for all "observed" elements.
+ * The side effect of changing status is left to the element and any code owning said element to handle.
+ */
+var DomObserver = /** @class */ (function () {
+    function DomObserver(container, config) {
+        if (container === void 0) { container = getBody(); }
+        if (config === void 0) { config = { 'attributes': true, 'childList': true, 'subtree': true }; }
+        var _this = this;
+        this.listeners = [];
+        this._teardown = function () { };
+        if (sniffer.MutationObserver) {
+            var MutationObserver_1 = getZoneSafeMethod('MutationObserver');
+            var observer_1 = new MutationObserver_1(function (mutationList, observer) {
+                _this.signal();
+            });
+            observer_1.observe(container, config);
+            this._teardown = function () { return observer_1.disconnect; };
+        }
+        else {
+            var handle_1 = setTimeout$1(function () {
+                _this.signal();
+            }, 500);
+            this._teardown = function () {
+                clearTimeout(handle_1);
+            };
+        }
+    }
+    DomObserver.prototype.signal = function () {
+        _.each(this.listeners, function (el) {
+            el.get();
+        });
+    };
+    DomObserver.prototype.addObservers = function () {
+        var elements = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            elements[_i] = arguments[_i];
+        }
+        this.listeners = [].concat(this.listeners, elements);
+    };
+    DomObserver.prototype.teardown = function () {
+        this._teardown();
+    };
+    return DomObserver;
+}());
+
+function WeakRefFactory() {
+    function WeakRef(obj) {
+        this._object = obj;
+    }
+
+    WeakRef.prototype.deref = function() {
+        return this._object;
+    };
+
+    return WeakRef;
+}
+
+var WeakRef = (function(global, factory) {
+    var nativeWeakRef = global.WeakRef;
+    if (typeof nativeWeakRef !== 'function' || !/native/.test(nativeWeakRef)) {
+        return factory();
+    }
+
+    return nativeWeakRef;
+})(window, WeakRefFactory);
+
+var trimString = function (str, limit) {
+    var len = str.length;
+    if (len <= limit)
+        return str;
+    return trimSurrogate(str.substring(0, limit));
+};
+function getTextValue(elem, limit) {
+    if (elem.tagName && ['textarea', 'input'].indexOf(elem.tagName.toLowerCase()) > -1) {
+        return trimString(elem.value, limit);
+    }
+    return getText(elem, limit);
+}
+function getText(elem, limit) {
+    if (limit === void 0) { limit = 128; }
+    var ret = '';
+    var nodeType = elem.nodeType;
+    var sub;
+    if (nodeType === TEXT || nodeType === CDATA_SECTION) {
+        return elem.nodeValue;
+    }
+    else if (!isElemBlacklisted(elem) &&
+        (nodeType === ELEMENT ||
+            nodeType === DOCUMENT ||
+            nodeType === DOCUMENT_FRAGMENT)) {
+        // Traverse its children
+        if (!elem.childNodes)
+            return ret;
+        for (var i = 0; i < elem.childNodes.length; ++i) {
+            var child = elem.childNodes[i];
+            sub = getText(child, limit - ret.length);
+            if ((ret + sub).length >= limit) {
+                return ret + trimSurrogate(sub.substring(0, limit - ret.length));
+            }
+            ret += sub;
+        }
+    }
+    return ret;
+}
+function isElemBlacklisted(elem) {
+    return !elem.tagName || elem.tagName.toLowerCase() == 'textarea';
+}
+/**
+ * Determine if the supplied {codepoint} falls within the "high surrogate" range
+ * of unicode characters.
+ *
+ * @access private
+ * @param {number} codepoint
+ * @returns {boolean}
+ * @see https://en.wikipedia.org/wiki/UTF-16#U.2BD800_to_U.2BDFFF
+ */
+function isHighSurrogate(codepoint) {
+    return (0xD800 <= codepoint && codepoint <= 0xDBFF);
+}
+/**
+ * Determine if the supplied {codepoint} falls within the "low surrogate" range
+ * of unicode characters.
+ *
+ * @access private
+ * @param {number} codepoint
+ * @returns {boolean}
+ * @see https://en.wikipedia.org/wiki/UTF-16#U.2BD800_to_U.2BDFFF
+ */
+function isLowSurrogate(codepoint) {
+    return (0xDC00 <= codepoint && codepoint <= 0xDFFF);
+}
+/**
+ * Remove "high surrogate" or unmatched "low surrogate" characters from the end
+ * of {s}, indicating a broken unicode glyph. This happens when we truncate the
+ * text of a node in {getText} that ends with a double-byte-encoded unicode glyph
+ * such as emoji.
+ *
+ * @access private
+ * @see https://github.com/pendo-io/pendo-client/pull/12
+ * @param {string} s
+ * @returns {string} s if no trailing surrogates, s-1 otherwise
+ */
+function trimSurrogate(s) {
+    // If the string is empty, it's definitely _not_ a "lonely surrogate"...
+    if (s.length < 1)
+        return s;
+    var last = s.slice(-1).charCodeAt(0);
+    // We're only interested in the `last` character...
+    if (!isHighSurrogate(last) && !isLowSurrogate(last))
+        return s;
+    // If the string is only 1 character, that surrogate is definitely "lonely"...
+    if (s.length === 1)
+        return s.slice(0, -1);
+    // All "lonely high surrogates" shall be eradicated...
+    if (isHighSurrogate(last))
+        return s.slice(0, -1);
+    // Not sure how "lonely low surrogate" could happen, but let's check!
+    if (isLowSurrogate(last)) {
+        // Per above, the `last` character isn't the _only_ character...
+        var prev = s.slice(-2).charCodeAt(0);
+        // And if the `prev` character isn't a "high surrogate", that "low surrogate" is lonely.
+        if (!isHighSurrogate(prev))
+            return s.slice(0, -1);
+    }
+    return s; // otherwise leave it alone
+}
+
+var ElementGetter = /** @class */ (function () {
+    function ElementGetter(cssSelector) {
+        this.listeners = {}; // callbacks to be called when an event of type occurs
+        this.events = []; // event types this element listens for
+        this.cssSelector = cssSelector;
+    }
+    ElementGetter.prototype.get = function () {
+        var _this = this;
+        var el = this.elRef && this.elRef.deref();
+        var isInDoc = isInDocument(el); // is this safe to call if el is null?
+        if (el && isInDoc)
+            return el;
+        if (el && !isInDoc) {
+            return undefined;
+        }
+        el = dom(this.cssSelector)[0];
+        if (!el) {
+            return undefined;
+        }
+        _.each(this.events, function (evtType) {
+            el.addEventListener(evtType, function (e) { return _this.onEvent(e); });
+        });
+        this.elRef = new WeakRef(el);
+        return el;
+    };
+    ElementGetter.prototype.getText = function (limit) {
+        if (limit === void 0) { limit = 1024; }
+        // XXX not sure about size limit
+        return getTextValue(this.get(), limit);
+    };
+    ElementGetter.prototype.addEventListener = function (event, callback) {
+        var _this = this;
+        var el = this.get();
+        if (this.events.indexOf(event) < 0) {
+            this.events.push(event);
+            if (el) {
+                el.addEventListener(event, function (e) { return _this.onEvent(e); });
+            }
+        }
+        this.listeners[event] = this.listeners[event]
+            ? this.listeners[event].push(callback) : [].concat(callback);
+    };
+    ElementGetter.prototype.onEvent = function (evt) {
+        var type = evt.type;
+        _.each(this.listeners[type], function (cb) { return cb(evt); });
+    };
+    ElementGetter.prototype.teardown = function () {
+        var _this = this;
+        var el = this.get();
+        if (el) {
+            _.each(this.events, function (evtType) { return el.removeEventListener(evtType, _this.onEvent); });
+        }
+    };
+    return ElementGetter;
+}());
+
 _.extend(dom, {
     'data': DomData$1,
     'event': DomEvent,
@@ -9608,6 +9840,8 @@ _.extend(dom, {
     'intersectRect': intersectRect,
     'getScrollParent': getScrollParent,
     'isElementVisible': isElementVisible,
+    'Observer': DomObserver,
+    'Element': ElementGetter,
     'scrollIntoView': scrollIntoView,
     'getRootNode': getRootNode
 });