logrocket
Version:
JavaScript SDK for [LogRocket](https://logrocket.com/)
1,329 lines (1,238 loc) • 161 kB
JavaScript
(function webpackUniversalModuleDefinition(root, factory) {
if(typeof exports === 'object' && typeof module === 'object')
module.exports = factory();
else if(typeof define === 'function' && define.amd)
define([], factory);
else {
var a = factory();
for(var i in a) (typeof exports === 'object' ? exports : root)[i] = a[i];
}
})(this, function() {
return /******/ (function() { // webpackBootstrap
/******/ var __webpack_modules__ = ({
/***/ "./packages/@logrocket/console/src/index.ts":
/*!**************************************************!*\
!*** ./packages/@logrocket/console/src/index.ts ***!
\**************************************************/
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
"use strict";
var _interopRequireDefault = __webpack_require__(/*! @babel/runtime/helpers/interopRequireDefault */ "./node_modules/.pnpm/@babel+runtime@7.29.2/node_modules/@babel/runtime/helpers/interopRequireDefault.js");
Object.defineProperty(exports, "__esModule", ({
value: true
}));
exports["default"] = void 0;
var _registerConsole = _interopRequireDefault(__webpack_require__(/*! ./registerConsole */ "./packages/@logrocket/console/src/registerConsole.js"));
var _default = exports["default"] = _registerConsole.default;
/***/ }),
/***/ "./packages/@logrocket/console/src/registerConsole.js":
/*!************************************************************!*\
!*** ./packages/@logrocket/console/src/registerConsole.js ***!
\************************************************************/
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
"use strict";
var _interopRequireDefault = __webpack_require__(/*! @babel/runtime/helpers/interopRequireDefault */ "./node_modules/.pnpm/@babel+runtime@7.29.2/node_modules/@babel/runtime/helpers/interopRequireDefault.js");
Object.defineProperty(exports, "__esModule", ({
value: true
}));
exports["default"] = registerConsole;
var _enhanceFunc = _interopRequireDefault(__webpack_require__(/*! @logrocket/utils/src/enhanceFunc */ "./packages/@logrocket/utils/src/enhanceFunc.ts"));
var _exceptions = __webpack_require__(/*! @logrocket/exceptions */ "./packages/@logrocket/exceptions/src/index.ts");
function registerConsole(logger) {
const unsubFunctions = [];
const methods = ['log', 'warn', 'info', 'error', 'debug'];
methods.forEach(method => {
unsubFunctions.push((0, _enhanceFunc.default)(console, method, function () {
for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
args[_key] = arguments[_key];
}
logger.addEvent('lr.core.LogEvent', function () {
let consoleOptions = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
const isEnabled = consoleOptions.isEnabled;
if (typeof isEnabled === 'object' && isEnabled[method] === false || isEnabled === false) {
return null;
}
if (method === 'error' && consoleOptions.shouldAggregateConsoleErrors) {
// some customers have loggers that add the log level as the first arg
if (!!args && args.length >= 2 && args[0] === 'ERROR') {
let secondArg = '';
try {
secondArg = " ".concat(args[1]);
} catch (_unused) {} // eslint-disable-line no-empty
_exceptions.Capture.captureMessage(logger, "".concat(args[0]).concat(secondArg), args, {}, true);
} else {
_exceptions.Capture.captureMessage(logger, args[0], args, {}, true);
}
}
return {
logLevel: method.toUpperCase(),
args
};
});
}));
});
return () => {
unsubFunctions.forEach(unsubFunction => unsubFunction());
};
}
/***/ }),
/***/ "./packages/@logrocket/custom-element-states/src/index.ts":
/*!****************************************************************!*\
!*** ./packages/@logrocket/custom-element-states/src/index.ts ***!
\****************************************************************/
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
"use strict";
var _interopRequireDefault = __webpack_require__(/*! @babel/runtime/helpers/interopRequireDefault */ "./node_modules/.pnpm/@babel+runtime@7.29.2/node_modules/@babel/runtime/helpers/interopRequireDefault.js");
Object.defineProperty(exports, "__esModule", ({
value: true
}));
exports["default"] = void 0;
var _registerCustomStates = _interopRequireDefault(__webpack_require__(/*! ./registerCustomStates */ "./packages/@logrocket/custom-element-states/src/registerCustomStates.ts"));
var _default = exports["default"] = _registerCustomStates.default;
/***/ }),
/***/ "./packages/@logrocket/custom-element-states/src/registerCustomStates.ts":
/*!*******************************************************************************!*\
!*** ./packages/@logrocket/custom-element-states/src/registerCustomStates.ts ***!
\*******************************************************************************/
/***/ (function(__unused_webpack_module, exports) {
"use strict";
Object.defineProperty(exports, "__esModule", ({
value: true
}));
exports["default"] = registerCustomStates;
function wrapCustomStateSet(element, stateSet, stateChangeCallback) {
const saved = stateSet.__lr_originals;
const originalAdd = saved ? saved.add : stateSet.add.bind(stateSet);
const originalDelete = saved ? saved.delete : stateSet.delete.bind(stateSet);
const originalClear = saved ? saved.clear : stateSet.clear.bind(stateSet);
if (!saved) {
stateSet.__lr_originals = {
add: originalAdd,
delete: originalDelete,
clear: originalClear
};
}
stateSet.add = function (value) {
const result = originalAdd(value);
stateChangeCallback({
timestamp: Date.now(),
element,
states: new Set(stateSet)
});
return result;
};
stateSet.delete = function (value) {
const result = originalDelete(value);
stateChangeCallback({
timestamp: Date.now(),
element,
states: new Set(stateSet)
});
return result;
};
stateSet.clear = function () {
originalClear();
stateChangeCallback({
timestamp: Date.now(),
element,
states: new Set()
});
};
}
function unwrapCustomStateSet(stateSet) {
const saved = stateSet.__lr_originals;
if (saved) {
stateSet.add = saved.add;
stateSet.delete = saved.delete;
stateSet.clear = saved.clear;
}
}
function registerCustomStates() {
if (typeof HTMLElement === 'undefined' || typeof HTMLElement.prototype.attachInternals !== 'function') {
return {
customStatesManager: undefined,
unsub: () => {}
};
}
const trackedElements = new WeakMap();
const trackedElementRefs = [];
const originalAttachInternalsDescriptor = Object.getOwnPropertyDescriptor(HTMLElement.prototype, 'attachInternals');
let stateChangeCallback = undefined;
let stateChangeBuffer = [];
const MAX_STATE_BUFFER_SIZE = 200;
const runCallbacks = event => {
stateChangeBuffer.push(event);
if (stateChangeBuffer.length > MAX_STATE_BUFFER_SIZE) {
stateChangeBuffer = stateChangeBuffer.slice(-MAX_STATE_BUFFER_SIZE);
}
if (stateChangeCallback != undefined) {
stateChangeBuffer.forEach(changeEvent => stateChangeCallback(changeEvent));
stateChangeBuffer = [];
}
};
Object.defineProperty(HTMLElement.prototype, 'attachInternals', {
value: function () {
for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
args[_key] = arguments[_key];
}
const internals = originalAttachInternalsDescriptor.value.apply(this, args);
if (internals.states) {
const stateSet = internals.states;
wrapCustomStateSet(this, stateSet, runCallbacks);
trackedElements.set(this, stateSet);
trackedElementRefs.push(new WeakRef(this));
}
return internals;
},
enumerable: true,
writable: true,
configurable: true
});
const customStatesManager = {
onStateChange(callback) {
stateChangeCallback = callback;
},
clearStateChangeCallback() {
stateChangeCallback = undefined;
},
getStatesForElement(element) {
return trackedElements.has(element) ? new Set(trackedElements.get(element)) : new Set();
},
originalAttachInternalsDescriptor,
cleanup() {
Object.defineProperty(HTMLElement.prototype, 'attachInternals', originalAttachInternalsDescriptor);
for (const ref of trackedElementRefs) {
const el = ref.deref();
if (el) {
const stateSet = trackedElements.get(el);
if (stateSet) unwrapCustomStateSet(stateSet);
}
}
trackedElementRefs.length = 0;
}
};
return {
customStatesManager,
unsub: () => {
customStatesManager.cleanup();
}
};
}
/***/ }),
/***/ "./packages/@logrocket/exceptions/src/Capture.js":
/*!*******************************************************!*\
!*** ./packages/@logrocket/exceptions/src/Capture.js ***!
\*******************************************************/
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
"use strict";
var _interopRequireDefault = __webpack_require__(/*! @babel/runtime/helpers/interopRequireDefault */ "./node_modules/.pnpm/@babel+runtime@7.29.2/node_modules/@babel/runtime/helpers/interopRequireDefault.js");
Object.defineProperty(exports, "__esModule", ({
value: true
}));
exports.captureException = captureException;
exports.captureMessage = captureMessage;
var _scrubException = __webpack_require__(/*! @logrocket/utils/src/scrubException */ "./packages/@logrocket/utils/src/scrubException.ts");
var _TraceKit = _interopRequireDefault(__webpack_require__(/*! @logrocket/utils/src/TraceKit */ "./packages/@logrocket/utils/src/TraceKit.js"));
var _stackTraceFromError = _interopRequireDefault(__webpack_require__(/*! ./stackTraceFromError */ "./packages/@logrocket/exceptions/src/stackTraceFromError.js"));
function captureMessage(logger, message, messageArgs) {
let options = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
let isConsole = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;
const data = {
exceptionType: isConsole ? 'CONSOLE' : 'MESSAGE',
message,
messageArgs,
browserHref: window.location ? window.location.href : ''
};
(0, _scrubException.scrubException)(data, options);
logger.addEvent('lr.core.Exception', () => data);
}
function captureException(logger, exception) {
let options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
let preppedTrace = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;
let exceptionType = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 'WINDOW';
const trace = preppedTrace || _TraceKit.default.computeStackTrace(exception);
const data = {
exceptionType,
errorType: trace.name,
message: trace.message,
browserHref: window.location ? window.location.href : ''
};
(0, _scrubException.scrubException)(data, options);
const addEventOptions = {
_stackTrace: (0, _stackTraceFromError.default)(trace)
};
logger.addEvent('lr.core.Exception', () => data, addEventOptions);
}
/***/ }),
/***/ "./packages/@logrocket/exceptions/src/index.ts":
/*!*****************************************************!*\
!*** ./packages/@logrocket/exceptions/src/index.ts ***!
\*****************************************************/
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
"use strict";
var _interopRequireDefault = __webpack_require__(/*! @babel/runtime/helpers/interopRequireDefault */ "./node_modules/.pnpm/@babel+runtime@7.29.2/node_modules/@babel/runtime/helpers/interopRequireDefault.js");
Object.defineProperty(exports, "__esModule", ({
value: true
}));
exports.Capture = void 0;
Object.defineProperty(exports, "registerExceptions", ({
enumerable: true,
get: function () {
return _registerExceptions.default;
}
}));
var _registerExceptions = _interopRequireDefault(__webpack_require__(/*! ./registerExceptions */ "./packages/@logrocket/exceptions/src/registerExceptions.js"));
var Capture = _interopRequireWildcard(__webpack_require__(/*! ./Capture */ "./packages/@logrocket/exceptions/src/Capture.js"));
exports.Capture = Capture;
function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
/***/ }),
/***/ "./packages/@logrocket/exceptions/src/raven/FunctionPropertyMirror.js":
/*!****************************************************************************!*\
!*** ./packages/@logrocket/exceptions/src/raven/FunctionPropertyMirror.js ***!
\****************************************************************************/
/***/ (function(__unused_webpack_module, exports) {
"use strict";
Object.defineProperty(exports, "__esModule", ({
value: true
}));
exports["default"] = void 0;
const DEFAULT_RESERVED_PROPS = new Set(['prototype', 'length', 'name', 'arguments', 'caller', '__lr__', '__lr_wrapper__', '__inner__', '__refreshMirroredProps__']);
function isSymbol(prop) {
return typeof prop === 'symbol';
}
class FunctionPropertyMirror {
constructor(source, target) {
let {
hasKey,
reservedProps = DEFAULT_RESERVED_PROPS,
includeSymbols = true
} = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
this.source = source;
this.target = target;
this.hasKey = hasKey || (() => false);
this.reservedProps = reservedProps;
this.includeSymbols = includeSymbols;
this.mirroredProps = Object.create(null);
this.descriptorCache = Object.create(null);
}
isReserved(prop) {
if (prop === null || prop === undefined) {
return true;
}
if (isSymbol(prop)) {
return !this.includeSymbols;
}
return this.reservedProps.has(prop);
}
remember(prop) {
this.mirroredProps[prop] = true;
}
forget(prop) {
delete this.mirroredProps[prop];
if (Object.prototype.hasOwnProperty.call(this.descriptorCache, prop)) {
delete this.descriptorCache[prop];
}
}
hasMirrored(prop) {
return Object.prototype.hasOwnProperty.call(this.mirroredProps, prop);
}
getDescriptor(prop) {
if (Object.prototype.hasOwnProperty.call(this.descriptorCache, prop)) {
return this.descriptorCache[prop] || undefined;
}
let descriptor;
try {
descriptor = Object.getOwnPropertyDescriptor(this.source, prop);
} catch (err) {
descriptor = undefined;
}
this.descriptorCache[prop] = descriptor || null;
return descriptor;
}
defineMirroredDescriptor(prop, descriptor) {
const configurable = Object.prototype.hasOwnProperty.call(descriptor, 'configurable') ? descriptor.configurable : true;
const enumerable = Object.prototype.hasOwnProperty.call(descriptor, 'enumerable') ? descriptor.enumerable : true;
if (descriptor.get || descriptor.set) {
Object.defineProperty(this.target, prop, {
configurable,
enumerable,
get: descriptor.get ? () => descriptor.get.call(this.source) : undefined,
set: descriptor.set ? value => descriptor.set.call(this.source, value) : undefined
});
return;
}
const writable = Object.prototype.hasOwnProperty.call(descriptor, 'writable') ? descriptor.writable : true;
Object.defineProperty(this.target, prop, {
configurable,
enumerable,
get: () => this.source[prop],
set: writable === false ? undefined : value => {
this.source[prop] = value;
}
});
}
mirrorProperty(prop) {
if (this.isReserved(prop) || this.hasMirrored(prop)) {
return false;
}
if (!this.hasKey(this.source, prop)) {
return false;
}
const descriptor = this.getDescriptor(prop);
if (!descriptor) {
return false;
}
try {
this.defineMirroredDescriptor(prop, descriptor);
this.remember(prop);
return true;
} catch (err) {
try {
this.target[prop] = this.source[prop];
this.remember(prop);
return true;
} catch (e) {
return false;
}
}
}
mirrorProperties(props) {
if (!props) {
return;
}
const list = Array.isArray(props) ? props : [props];
for (let i = 0; i < list.length; i += 1) {
this.mirrorProperty(list[i]);
}
}
syncAll() {
try {
this.mirrorProperties(Object.getOwnPropertyNames(this.source));
if (this.includeSymbols && typeof Object.getOwnPropertySymbols === 'function') {
this.mirrorProperties(Object.getOwnPropertySymbols(this.source));
}
} catch (err) {
// Accessing some meta properties (e.g., 'caller') can throw in strict mode environments.
}
}
syncProperty(prop) {
if (this.isReserved(prop)) {
return;
}
this.forget(prop);
this.mirrorProperty(prop);
}
attachManualRefreshHook() {
if (this.isReserved('__refreshMirroredProps__')) {
Object.defineProperty(this.target, '__refreshMirroredProps__', {
configurable: true,
enumerable: false,
writable: false,
value: () => {
this.syncAll();
return this.target;
}
});
}
}
}
exports["default"] = FunctionPropertyMirror;
/***/ }),
/***/ "./packages/@logrocket/exceptions/src/raven/raven.js":
/*!***********************************************************!*\
!*** ./packages/@logrocket/exceptions/src/raven/raven.js ***!
\***********************************************************/
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
"use strict";
var _interopRequireDefault = __webpack_require__(/*! @babel/runtime/helpers/interopRequireDefault */ "./node_modules/.pnpm/@babel+runtime@7.29.2/node_modules/@babel/runtime/helpers/interopRequireDefault.js");
Object.defineProperty(exports, "__esModule", ({
value: true
}));
exports["default"] = void 0;
var _TraceKit = _interopRequireDefault(__webpack_require__(/*! @logrocket/utils/src/TraceKit */ "./packages/@logrocket/utils/src/TraceKit.js"));
var _FunctionPropertyMirror = _interopRequireDefault(__webpack_require__(/*! ./FunctionPropertyMirror */ "./packages/@logrocket/exceptions/src/raven/FunctionPropertyMirror.js"));
/* eslint-disable */
/*
Some contents of this file were originaly from raven-js, BSD-2 Clause
Copyright (c) 2018 Sentry (https://sentry.io) and individual contributors.
All rights reserved.
Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
var objectPrototype = Object.prototype;
function isUndefined(what) {
return what === void 0;
}
function isFunction(what) {
return typeof what === 'function';
}
function each(obj, callback) {
var i, j;
if (isUndefined(obj.length)) {
for (i in obj) {
if (hasKey(obj, i)) {
callback.call(null, i, obj[i]);
}
}
} else {
j = obj.length;
if (j) {
for (i = 0; i < j; i++) {
callback.call(null, i, obj[i]);
}
}
}
}
/**
* hasKey, a better form of hasOwnProperty
* Example: hasKey(MainHostObject, property) === true/false
*
* @param {Object} host object to check property
* @param {string} key to check
*/
function hasKey(object, key) {
return objectPrototype.hasOwnProperty.call(object, key);
}
/**
* Polyfill a method
* @param obj object e.g. `document`
* @param name method name present on object e.g. `addEventListener`
* @param replacement replacement function
* @param track {optional} record instrumentation to an array
*/
function fill(obj, name, replacement, track) {
var orig = obj[name];
obj[name] = replacement(orig);
if (track) {
track.push([obj, name, orig]);
}
}
var _window = typeof window !== 'undefined' ? window : typeof __webpack_require__.g !== 'undefined' ? __webpack_require__.g : typeof self !== 'undefined' ? self : {};
var _document = _window.document;
class Handler {
constructor(_ref) {
let {
captureException
} = _ref;
this._errorHandler = this._errorHandler.bind(this);
this._ignoreOnError = 0;
this._wrappedBuiltIns = [];
this.captureException = captureException;
_TraceKit.default.report.subscribe(this._errorHandler);
this._instrumentTryCatch();
}
uninstall() {
_TraceKit.default.report.unsubscribe(this._errorHandler);
// restore any wrapped builtins
var builtin;
while (this._wrappedBuiltIns.length) {
builtin = this._wrappedBuiltIns.shift();
var obj = builtin[0],
name = builtin[1],
orig = builtin[2];
obj[name] = orig;
}
}
_errorHandler(report) {
if (!this._ignoreOnError) {
this.captureException(report);
}
}
_ignoreNextOnError() {
this._ignoreOnError += 1;
setTimeout(() => {
// onerror should trigger before setTimeout
this._ignoreOnError -= 1;
});
}
/*
* Wrap code within a context so Handler can capture errors
* reliably across domains that is executed immediately.
*
* @param {object} options A specific set of options for this context [optional]
* @param {function} func The callback to be immediately executed within the context
* @param {array} args An array of arguments to be called with the callback [optional]
*/
context(options, func, args) {
if (isFunction(options)) {
args = func || [];
func = options;
options = undefined;
}
return this.wrap(options, func).apply(this, args);
}
/*
* Wrap code within a context and returns back a new function to be executed
*
* @param {object} options A specific set of options for this context [optional]
* @param {function} func The function to be wrapped in a new context
* @param {function} func A function to call before the try/catch wrapper [optional, private]
* @return {function} The newly wrapped functions with a context
*/
wrap(options, func, _before) {
var self = this;
// 1 argument has been passed, and it's not a function
// so just return it
if (isUndefined(func) && !isFunction(options)) {
return options;
}
// options is optional
if (isFunction(options)) {
func = options;
options = undefined;
}
// At this point, we've passed along 2 arguments, and the second one
// is not a function either, so we'll just return the second argument.
if (!isFunction(func)) {
return func;
}
// We don't wanna wrap it twice!
try {
if (func.__lr__) {
return func;
}
// If this has already been wrapped in the past, return that
if (func.__lr_wrapper__) {
return func.__lr_wrapper__;
}
// If func is not extensible, return the function as-is to prevent TypeErrors
// when trying to add new props & to assure immutable funcs aren't changed
if (!Object.isExtensible(func)) {
return func;
}
} catch (e) {
// Just accessing custom props in some Selenium environments
// can cause a "Permission denied" exception (see lr-js#495).
// Bail on wrapping and return the function as-is (defers to window.onerror).
return func;
}
function wrapped() {
var args = [],
i = arguments.length,
deep = !options || options && options.deep !== false;
if (_before && isFunction(_before)) {
_before.apply(this, arguments);
}
// Recursively wrap all of a function's arguments that are
// functions themselves.
while (i--) args[i] = deep ? self.wrap(options, arguments[i]) : arguments[i];
try {
// Attempt to invoke user-land function. This is part of the LogRocket SDK.
// If you're seeing this frame in a stack trace, it means that LogRocket caught
// an unhandled error thrown by your application code, reported it, then bubbled
// it up. This is expected behavior and is not a bug with LogRocket.
return func.apply(this, args);
} catch (e) {
self._ignoreNextOnError();
self.captureException(_TraceKit.default.computeStackTrace(e), options);
throw e;
}
}
var reflect = typeof Reflect === 'object' ? Reflect : undefined;
var propertyMirror = new _FunctionPropertyMirror.default(func, wrapped, {
hasKey: hasKey,
includeSymbols: true
});
propertyMirror.syncAll();
propertyMirror.attachManualRefreshHook();
wrapped.prototype = func.prototype;
try {
if (typeof Object.setPrototypeOf === 'function') {
Object.setPrototypeOf(wrapped, func);
} else if (!isUndefined(wrapped.__proto__)) {
wrapped.__proto__ = func;
}
} catch (prototypeError) {
// Ignore failures from prototype adjustments (e.g., non-extensible functions).
}
var returnWrapper = wrapped;
if (typeof Proxy === 'function') {
var proxy = new Proxy(wrapped, {
apply(target, thisArg, argArray) {
propertyMirror.syncAll();
return target.apply(thisArg, argArray);
},
construct(target, argArray, newTarget) {
propertyMirror.syncAll();
if (reflect && reflect.construct) {
return reflect.construct(target, argArray, newTarget);
}
var BoundTarget = Function.bind.apply(target, [null].concat(argArray || []));
return new BoundTarget();
},
get(target, prop, receiver) {
if (prop === '__inner__') {
return func;
}
propertyMirror.mirrorProperty(prop);
if (reflect && reflect.get) {
return reflect.get(target, prop, receiver);
}
return target[prop];
},
set(target, prop, value, receiver) {
if (prop === '__lr__' || prop === '__lr_wrapper__' || prop === '__inner__') {
if (reflect && reflect.set) {
return reflect.set(target, prop, value, receiver);
}
target[prop] = value;
return true;
}
propertyMirror.mirrorProperty(prop);
var result;
if (reflect && reflect.set) {
result = reflect.set(target, prop, value, receiver);
} else {
target[prop] = value;
result = true;
}
try {
func[prop] = value;
propertyMirror.syncProperty(prop);
} catch (err) {
// ignore failures syncing to the inner function
}
return result;
},
has(target, prop) {
propertyMirror.mirrorProperty(prop);
if (reflect && reflect.has) {
if (reflect.has(target, prop)) {
return true;
}
} else if (prop in target) {
return true;
}
return prop in func;
},
ownKeys(target) {
propertyMirror.syncAll();
if (reflect && reflect.ownKeys) {
return reflect.ownKeys(target);
}
return Object.getOwnPropertyNames(target);
},
getOwnPropertyDescriptor(target, prop) {
propertyMirror.mirrorProperty(prop);
if (reflect && reflect.getOwnPropertyDescriptor) {
return reflect.getOwnPropertyDescriptor(target, prop);
}
return Object.getOwnPropertyDescriptor(target, prop);
},
defineProperty(target, prop, descriptor) {
var defineResult;
if (reflect && reflect.defineProperty) {
defineResult = reflect.defineProperty(target, prop, descriptor);
} else {
Object.defineProperty(target, prop, descriptor);
defineResult = true;
}
if (prop === '__lr__' || prop === '__lr_wrapper__' || prop === '__inner__') {
return defineResult;
}
try {
Object.defineProperty(func, prop, descriptor);
} catch (err) {
// ignore sync failure on inner function
}
propertyMirror.syncProperty(prop);
return defineResult;
},
deleteProperty(target, prop) {
if (prop === '__lr__' || prop === '__lr_wrapper__' || prop === '__inner__') {
if (reflect && reflect.deleteProperty) {
return reflect.deleteProperty(target, prop);
}
return delete target[prop];
}
propertyMirror.forget(prop);
try {
delete func[prop];
} catch (err) {
// ignore failures removing from inner function
}
if (reflect && reflect.deleteProperty) {
return reflect.deleteProperty(target, prop);
}
return delete target[prop];
}
});
returnWrapper = proxy;
}
func.__lr_wrapper__ = returnWrapper;
// Signal that this function has been wrapped already
// for both debugging and to prevent it to being wrapped twice
wrapped.__lr__ = true;
wrapped.__inner__ = func;
if (returnWrapper !== wrapped) {
returnWrapper.__lr__ = true;
returnWrapper.__inner__ = func;
}
return returnWrapper;
}
/**
* Install any queued plugins
*/
_instrumentTryCatch() {
var self = this;
var wrappedBuiltIns = self._wrappedBuiltIns;
function wrapTimeFn(orig) {
return function (fn, t) {
// preserve arity
// Make a copy of the arguments to prevent deoptimization
// https://github.com/petkaantonov/bluebird/wiki/Optimization-killers#32-leaking-arguments
var args = new Array(arguments.length);
for (var i = 0; i < args.length; ++i) {
args[i] = arguments[i];
}
var originalCallback = args[0];
if (isFunction(originalCallback)) {
args[0] = self.wrap(originalCallback);
}
// IE < 9 doesn't support .call/.apply on setInterval/setTimeout, but it
// also supports only two arguments and doesn't care what this is, so we
// can just call the original function directly.
if (orig.apply) {
return orig.apply(this, args);
} else {
return orig(args[0], args[1]);
}
};
}
function wrapEventTarget(global) {
var proto = _window[global] && _window[global].prototype;
if (proto && proto.hasOwnProperty && proto.hasOwnProperty('addEventListener')) {
fill(proto, 'addEventListener', function (orig) {
return function (evtName, fn, capture, secure) {
// preserve arity
try {
if (fn && fn.handleEvent) {
fn.handleEvent = self.wrap(fn.handleEvent);
}
} catch (err) {
// can sometimes get 'Permission denied to access property "handle Event'
}
// More breadcrumb DOM capture ... done here and not in `_instrumentBreadcrumbs`
// so that we don't have more than one wrapper function
var before;
return orig.call(this, evtName, self.wrap(fn, undefined, before), capture, secure);
};
}, wrappedBuiltIns);
fill(proto, 'removeEventListener', function (orig) {
return function (evt, fn, capture, secure) {
/**
* There are 3 scenararios to consider when removing an event listener
*
* 1. 'addEventListener' was called when the LR SDK was uninitialized.
* In this case, the event handler has not been wrapped, so this behaves
* as a passthrough and just removes the original handler.
*
* 2. 'addEventListener' was called while the LR SDK was initialized, which means
* our wrapped 'addEventListener' was called. In this case, the tracked event handler
* is also wrapped, so we need to remove that wrapped version of the handler.
*
* 3. 'addEventListener' was called both before and after the LR SDK was initialized
* for the same event handler. In this case, we have to remove both of them.
* If we'd remove only the wrapped one, the initial handler would stick around forever.
*/
try {
const wrappedFn = fn === null || fn === void 0 ? void 0 : fn.__lr_wrapper__;
if (wrappedFn) {
orig.call(this, evt, wrappedFn, capture, secure);
}
} catch (e) {
// ignore, accessing __lr_wrapper__ will throw in some Selenium environments
}
return orig.call(this, evt, fn, capture, secure);
};
},
// undefined is provided here to skip tracking for uninstall.
// Once our removeEventListener is installed, it can't be uninstalled.
// We always need to support removing logrocket wrapped event handlers (event
// handlers added when logrocket was installed) even after SDK shutdown.
undefined);
}
}
fill(_window, 'setTimeout', wrapTimeFn, wrappedBuiltIns);
fill(_window, 'setInterval', wrapTimeFn, wrappedBuiltIns);
if (_window.requestAnimationFrame) {
fill(_window, 'requestAnimationFrame', function (orig) {
return function (cb) {
return orig(self.wrap(cb));
};
}, wrappedBuiltIns);
}
// event targets borrowed from bugsnag-js:
// https://github.com/bugsnag/bugsnag-js/blob/master/src/bugsnag.js#L666
var eventTargets = ['EventTarget', 'Window', 'Node', 'ApplicationCache', 'AudioTrackList', 'ChannelMergerNode', 'CryptoOperation', 'EventSource', 'FileReader', 'HTMLUnknownElement', 'IDBDatabase', 'IDBRequest', 'IDBTransaction', 'KeyOperation', 'MediaController', 'MessagePort', 'ModalWindow', 'Notification', 'SVGElementInstance', 'Screen', 'TextTrack', 'TextTrackCue', 'TextTrackList', 'WebSocket', 'WebSocketWorker', 'Worker', 'XMLHttpRequest', 'XMLHttpRequestEventTarget', 'XMLHttpRequestUpload'];
for (var i = 0; i < eventTargets.length; i++) {
wrapEventTarget(eventTargets[i]);
}
var $ = _window.jQuery || _window.$;
if ($ && $.fn && $.fn.ready) {
fill($.fn, 'ready', function (orig) {
return function (fn) {
return orig.call(this, self.wrap(fn));
};
}, wrappedBuiltIns);
}
}
}
exports["default"] = Handler;
/***/ }),
/***/ "./packages/@logrocket/exceptions/src/registerExceptions.js":
/*!******************************************************************!*\
!*** ./packages/@logrocket/exceptions/src/registerExceptions.js ***!
\******************************************************************/
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
"use strict";
var _interopRequireDefault = __webpack_require__(/*! @babel/runtime/helpers/interopRequireDefault */ "./node_modules/.pnpm/@babel+runtime@7.29.2/node_modules/@babel/runtime/helpers/interopRequireDefault.js");
Object.defineProperty(exports, "__esModule", ({
value: true
}));
exports["default"] = registerCore;
var _raven = _interopRequireDefault(__webpack_require__(/*! ./raven/raven */ "./packages/@logrocket/exceptions/src/raven/raven.js"));
var Capture = _interopRequireWildcard(__webpack_require__(/*! ./Capture */ "./packages/@logrocket/exceptions/src/Capture.js"));
function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
function registerCore(logger) {
const raven = new _raven.default({
captureException(errorReport) {
Capture.captureException(logger, null, null, errorReport);
}
});
const rejectionHandler = evt => {
// http://2ality.com/2016/04/unhandled-rejections.html
if (evt.reason instanceof Error) {
Capture.captureException(logger, evt.reason, null, null, 'UNHANDLED_REJECTION');
} else {
logger.addEvent('lr.core.Exception', () => ({
exceptionType: 'UNHANDLED_REJECTION',
message: evt.reason || 'Unhandled Promise rejection'
}));
}
};
window.addEventListener('unhandledrejection', rejectionHandler);
return () => {
window.removeEventListener('unhandledrejection', rejectionHandler);
raven.uninstall();
};
}
/***/ }),
/***/ "./packages/@logrocket/exceptions/src/stackTraceFromError.js":
/*!*******************************************************************!*\
!*** ./packages/@logrocket/exceptions/src/stackTraceFromError.js ***!
\*******************************************************************/
/***/ (function(__unused_webpack_module, exports) {
"use strict";
Object.defineProperty(exports, "__esModule", ({
value: true
}));
exports["default"] = stackTraceFromError;
function stackTraceFromError(errorReport) {
function makeNotNull(val) {
return val === null ? undefined : val;
}
return errorReport.stack ? errorReport.stack.map(frame => ({
lineNumber: makeNotNull(frame.line),
columnNumber: makeNotNull(frame.column),
fileName: makeNotNull(frame.url),
functionName: makeNotNull(frame.func)
})) : undefined;
}
/***/ }),
/***/ "./packages/@logrocket/network/src/fetchIntercept.js":
/*!***********************************************************!*\
!*** ./packages/@logrocket/network/src/fetchIntercept.js ***!
\***********************************************************/
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", ({
value: true
}));
exports["default"] = void 0;
var _registerXHR = __webpack_require__(/*! ./registerXHR */ "./packages/@logrocket/network/src/registerXHR.js");
/* eslint-disable @typescript-eslint/no-shadow */
let interceptors = [];
function makeInterceptor(fetch, fetchId) {
const reversedInterceptors = interceptors.reduce((array, interceptor) => [interceptor].concat(array), []);
// if a browser supports fetch, it supports promise
for (var _len = arguments.length, args = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
args[_key - 2] = arguments[_key];
}
let promise = Promise.resolve(args);
// Register request interceptors
reversedInterceptors.forEach(_ref => {
let {
request,
requestError
} = _ref;
if (request || requestError) {
promise = promise.then(args => request(fetchId, ...args), args => requestError(fetchId, ...args));
}
});
promise = promise.then(args => {
(0, _registerXHR.setActive)(false);
let res;
let err;
try {
res = fetch(...args);
} catch (_err) {
err = _err;
}
(0, _registerXHR.setActive)(true);
if (err) {
throw err;
}
return res;
});
reversedInterceptors.forEach(_ref2 => {
let {
response,
responseError
} = _ref2;
if (response || responseError) {
promise = promise.then(res => response(fetchId, res), err => responseError && responseError(fetchId, err));
}
});
return promise;
}
function attach(env) {
if (!env.fetch || !env.Promise) {
// Make sure fetch is available in the given environment. If it's not, then
// default to using XHR intercept.
return;
}
const isPolyfill = env.fetch.polyfill;
env.fetch = (fetch => {
let fetchId = 0;
return function () {
for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
args[_key2] = arguments[_key2];
}
return makeInterceptor(fetch, fetchId++, ...args);
};
})(env.fetch);
// Forward the polyfill properly from fetch (set by github/whatwg-fetch).
if (isPolyfill) {
env.fetch.polyfill = isPolyfill;
}
}
// TODO: React Native
// attach(global);
let didAttach = false;
var _default = exports["default"] = {
register(interceptor) {
if (!didAttach) {
didAttach = true;
attach(window);
}
interceptors.push(interceptor);
return () => {
const index = interceptors.indexOf(interceptor);
if (index >= 0) {
interceptors.splice(index, 1);
}
};
},
clear() {
interceptors = [];
}
};
/***/ }),
/***/ "./packages/@logrocket/network/src/index.js":
/*!**************************************************!*\
!*** ./packages/@logrocket/network/src/index.js ***!
\**************************************************/
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
"use strict";
var _interopRequireDefault = __webpack_require__(/*! @babel/runtime/helpers/interopRequireDefault */ "./node_modules/.pnpm/@babel+runtime@7.29.2/node_modules/@babel/runtime/helpers/interopRequireDefault.js");
Object.defineProperty(exports, "__esModule", ({
value: true
}));
exports["default"] = registerNetwork;
var _defineProperty2 = _interopRequireDefault(__webpack_require__(/*! @babel/runtime/helpers/defineProperty */ "./node_modules/.pnpm/@babel+runtime@7.29.2/node_modules/@babel/runtime/helpers/defineProperty.js"));
var _registerFetch = _interopRequireDefault(__webpack_require__(/*! ./registerFetch */ "./packages/@logrocket/network/src/registerFetch.js"));
var _registerIonic = __webpack_require__(/*! ./registerIonic */ "./packages/@logrocket/network/src/registerIonic.ts");
var _registerNetworkInformation = _interopRequireDefault(__webpack_require__(/*! ./registerNetworkInformation */ "./packages/@logrocket/network/src/registerNetworkInformation.js"));
var _registerXHR = _interopRequireDefault(__webpack_require__(/*! ./registerXHR */ "./packages/@logrocket/network/src/registerXHR.js"));
var _mapValues = _interopRequireDefault(__webpack_require__(/*! @logrocket/utils/src/mapValues */ "./packages/@logrocket/utils/src/mapValues.ts"));
function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2.default)(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
function registerNetwork(logger) {
let config = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {
isReactNative: false,
isDisabled: false
};
if ((config === null || config === void 0 ? void 0 : config.isDisabled) === true) {
return () => {};
}
const {
isReactNative,
shouldAugmentNPS,
shouldParseXHRBlob
} = config;
const ignoredNetwork = {};
// truncate if > 4MB in size
const truncate = data => {
const limit = 1024 * 1000 * 4;
let str = data;
if (typeof data === 'object' && data != null) {
const proto = Object.getPrototypeOf(data);
if (proto === Object.prototype || proto === null) {
// plain object - jsonify for the size check
str = JSON.stringify(data);
}
}
if (str && str.length && str.length > limit && typeof str === 'string') {
const beginning = str.substring(0, 1000);
return "".concat(beginning, " ... LogRocket truncating to first 1000 characters.\n Keep data under 4MB to prevent truncation. https://docs.logrocket.com/reference/network");
}
return data;
};
const addRequest = (reqId, request) => {
const method = request.method;
logger.addEvent('lr.network.RequestEvent', function () {
let {
isEnabled = true,
requestSanitizer = f => f
} = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
if (!isEnabled) {
return null;
}
let sanitized = null;
try {
// only try catch user defined functions
sanitized = requestSanitizer(_objectSpread(_objectSpread({}, request), {}, {
reqId
}));
} catch (err) {
console.error(err);
}
if (sanitized) {
let url = sanitized.url;
if (typeof document !== 'undefined' && typeof document.createElement === 'function') {
// Writing and then reading from an a tag turns a relative
// url into an absolute one.
const a = document.createElement('a');
a.href = sanitized.url;
url = a.href;
}
return {
reqId,
// default
url,
// sanitized
headers: (0, _mapValues.default)(sanitized.headers, headerValue => {
// sanitized
return "".concat(headerValue);
}),
body: truncate(sanitized.body),
// sanitized
method,
// default
referrer: sanitized.referrer || undefined,
// sanitized
mode: sanitized.mode || undefined,
// sanitized
credentials: sanitized.credentials || undefined,
// sanitized
initiatorType: sanitized.initiatorType || 'UNKNOWN'
};
}
ignoredNetwork[reqId] = true;
return null;
});
};
const addResponse = (reqId, response) => {
const {
method,
status,
responseType
} = response;
logger.addEvent('lr.network.ResponseEvent', function () {
let {
isEnabled = true,
responseSanitizer = f => f
} = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
if (!isEnabled) {
return null;
} else if (ignoredNetwork[reqId]) {
delete ignoredNetwork[reqId];
return null;
}
let sanitized = null;
try {
// only try catch user defined functions
sanitized = responseSanitizer(_objectSpread(_objectSpread({}, response), {}, {
reqId
}));
} catch (err) {
console.error(err);
// fall through to redacted log
}
if (sanitized) {
return {
reqId,
// default
responseType,
status: sanitized.status,
// sanitized
headers: (0, _mapValues.default)(sanitized.headers, headerValue => {
// sanitized
return "".concat(headerValue);
}),
body: truncate(sanitized.body),
// sanitized
method // default
};
}
return {
reqId,
// default
responseType,
status,
// default
headers: {},
// redacted
body: null,
// redacted
method // default
};
});
};
const isIgnored = reqId => logger.isDisabled || ignoredNetwork[reqId] === true;
const unsubFetch = (0, _registerFetch.default)({
addRequest,
addResponse,
isIgnored
});
const unsubXHR = (0, _registerXHR.default)({
addRequest,
addResponse,
isIgnored,
logger,
shouldAugmentNPS,
shouldParseXHRBlob
});
const unsubIonic = (0, _registerIonic.registerIonic)({
addRequest,
addResponse,
isIgnored
});
const unsubNetworkInformation = isReactNative ? () => {} : (0, _registerNetworkInformation.default)(logger);
return () => {
unsubNetworkInformation();
unsubFetch();
unsubXHR();
unsubIonic();
};
}
/***/ }),
/***/ "./packages/@logrocket/network/src/registerFetch.js":
/*!**********************************************************!*\
!*** ./packages/@logrocket/network/src/registerFetch.js ***!
\**********************************************************/
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
"use strict";
var _interopRequireDef