@honeybadger-io/js 3.2.4 → 4.0.0-beta.0

package/dist/server/honeybadger.js

@@ -56,7 +56,45 @@ var __assign = function() {
         return t;
     };
     return __assign.apply(this, arguments);
-};
+};
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+function __generator(thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+}
 
 var UNKNOWN_FUNCTION = '<unknown>';
 /**
@@ -221,7 +259,8 @@ function objectIsEmpty(obj) {
 function makeBacktrace(stack, shift) {
     if (shift === void 0) { shift = 0; }
     try {
-        var backtrace = parse(stack).map(function (line) {
+        var backtrace = parse(stack)
+            .map(function (line) {
             return {
                 file: line.file,
                 method: line.methodName,
@@ -237,17 +276,39 @@ function makeBacktrace(stack, shift) {
         return [];
     }
 }
+function getSourceForBacktrace(backtrace, getSourceFileHandler, cb) {
+    if (!getSourceFileHandler || !backtrace || !backtrace.length) {
+        cb([]);
+        return;
+    }
+    var result = [];
+    var getSourceFromFile = function (index) {
+        if (index === void 0) { index = 0; }
+        if (!backtrace.length) {
+            return cb(result);
+        }
+        var trace = backtrace.splice(0)[index];
+        getSourceFileHandler(trace.file, (function (fileContent) {
+            result[index] = getSourceCodeSnippet(fileContent, trace.number);
+            getSourceFromFile(index + 1);
+        }));
+    };
+    getSourceFromFile();
+}
 function runBeforeNotifyHandlers(notice, handlers) {
+    var result = true;
     for (var i = 0, len = handlers.length; i < len; i++) {
         var handler = handlers[i];
         if (handler(notice) === false) {
-            return false;
+            result = false;
         }
     }
-    return true;
+    return result;
 }
 function runAfterNotifyHandlers(notice, handlers, error) {
-    if (error === void 0) { error = undefined; }
+    if (notice && notice.afterNotify) {
+        handlers.unshift(notice.afterNotify);
+    }
     for (var i = 0, len = handlers.length; i < len; i++) {
         handlers[i](error, notice);
     }
@@ -335,8 +396,13 @@ function logger(client) {
             for (var _i = 0; _i < arguments.length; _i++) {
                 args[_i] = arguments[_i];
             }
-            if (method === 'debug' && !client.config.debug) {
-                return;
+            if (method === 'debug') {
+                if (!client.config.debug) {
+                    return;
+                }
+                // Log at default level so that you don't need to also enable verbose
+                // logging in Chrome.
+                method = 'log';
             }
             args.unshift('[Honeybadger]');
             (_a = client.config.logger)[method].apply(_a, args);
@@ -375,7 +441,7 @@ function makeNotice(thing) {
 function endpoint(config, path) {
     var endpoint = config.endpoint.trim().replace(/\/$/, '');
     path = path.trim().replace(/(^\/|\/$)/g, '');
-    return endpoint + "/" + path;
+    return "".concat(endpoint, "/").concat(path);
 }
 function generateStackTrace() {
     try {
@@ -434,7 +500,9 @@ function filter(obj, filters) {
             return newObj;
         }
         if (is('Array', obj)) {
-            return obj.map(function (v) { return filter(v); });
+            return obj.map(function (v) {
+                return filter(v);
+            });
         }
         if (is('Function', obj)) {
             return '[FUNC]';
@@ -470,7 +538,7 @@ function filterUrl(url, filters) {
     query.split(/[&]\s?/).forEach(function (pair) {
         var _a = pair.split('=', 2), key = _a[0], value = _a[1];
         if (filterMatch(key, filters)) {
-            result = result.replace(key + "=" + value, key + "=[FILTERED]");
+            result = result.replace("".concat(key, "=").concat(value), "".concat(key, "=[FILTERED]"));
         }
     });
     return result;
@@ -484,11 +552,30 @@ function formatCGIData(vars, prefix) {
     });
     return formattedVars;
 }
+function getSourceCodeSnippet(fileData, lineNumber, sourceRadius) {
+    if (sourceRadius === void 0) { sourceRadius = 2; }
+    if (!fileData) {
+        return null;
+    }
+    var lines = fileData.split('\n');
+    // add one empty line because array index starts from 0, but error line number is counted from 1
+    lines.unshift('');
+    var start = lineNumber - sourceRadius;
+    var end = lineNumber + sourceRadius;
+    var result = {};
+    for (var i = start; i <= end; i++) {
+        var line = lines[i];
+        if (typeof line === 'string') {
+            result[i] = line;
+        }
+    }
+    return result;
+}
 
 var notifier = {
     name: 'honeybadger-js',
     url: 'https://github.com/honeybadger-io/honeybadger-js',
-    version: '3.2.4'
+    version: '4.0.0-beta.0'
 };
 // Split at commas
 var TAG_SEPARATOR = /,/;
@@ -511,7 +598,7 @@ var Client = /** @class */ (function () {
         this.__beforeNotifyHandlers = [];
         /** @internal */
         this.__afterNotifyHandlers = [];
-        this.config = __assign({ apiKey: null, endpoint: 'https://api.honeybadger.io', environment: null, hostname: null, projectRoot: null, component: null, action: null, revision: null, reportData: null, breadcrumbsEnabled: true, maxBreadcrumbs: 40, maxObjectDepth: 8, logger: console, developmentEnvironments: ['dev', 'development', 'test'], disabled: false, debug: false, tags: null, enableUncaught: true, enableUnhandledRejection: true, afterUncaught: function () { return true; }, filters: ['creditcard', 'password'], __plugins: [] }, opts);
+        this.config = __assign({ apiKey: null, endpoint: 'https://api.honeybadger.io', environment: null, hostname: null, projectRoot: null, component: null, action: null, revision: null, reportData: null, breadcrumbsEnabled: true, maxBreadcrumbs: 40, maxObjectDepth: 8, logger: console, developmentEnvironments: ['dev', 'development', 'test'], debug: false, tags: null, enableUncaught: true, enableUnhandledRejection: true, afterUncaught: function () { return true; }, filters: ['creditcard', 'password'], __plugins: [] }, opts);
         this.logger = logger(this);
     }
     Client.prototype.factory = function (_opts) {
@@ -561,22 +648,106 @@ var Client = /** @class */ (function () {
         this.__breadcrumbs = [];
         return this;
     };
-    Client.prototype.notify = function (notice, name, extra) {
+    Client.prototype.notify = function (noticeable, name, extra) {
+        var _this = this;
         if (name === void 0) { name = undefined; }
         if (extra === void 0) { extra = undefined; }
-        if (!this.config.apiKey) {
-            this.logger.warn('Unable to send error report: no API key has been configured');
-            return false;
+        var preConditionError = null;
+        var notice = this.makeNotice(noticeable, name, extra);
+        if (!notice) {
+            this.logger.debug('failed to build error report');
+            preConditionError = new Error('failed to build error report');
         }
-        if (this.config.disabled) {
-            this.logger.warn('Deprecation warning: instead of `disabled: true`, use `reportData: false` to explicitly disable Honeybadger reporting. (Dropping notice: honeybadger.js is disabled)');
-            return false;
+        if (!preConditionError && this.config.reportData === false) {
+            this.logger.debug('skipping error report: honeybadger.js is disabled', notice);
+            preConditionError = new Error('honeybadger.js is disabled');
+        }
+        if (!preConditionError && this.__developmentMode()) {
+            this.logger.log('honeybadger.js is in development mode; the following error report will be sent in production.', notice);
+            preConditionError = new Error('honeybadger.js is in development mode');
+        }
+        if (!preConditionError && !this.config.apiKey) {
+            this.logger.warn('could not send error report: no API key has been configured', notice);
+            preConditionError = new Error('missing API key');
+        }
+        var beforeNotifyResult = runBeforeNotifyHandlers(notice, this.__beforeNotifyHandlers);
+        if (!preConditionError && !beforeNotifyResult) {
+            this.logger.debug('skipping error report: beforeNotify handlers returned false', notice);
+            preConditionError = new Error('beforeNotify handlers returned false');
         }
-        if (!this.__reportData()) {
-            this.logger.debug('Dropping notice: honeybadger.js is in development mode');
+        if (preConditionError) {
+            runAfterNotifyHandlers(notice, this.__afterNotifyHandlers, preConditionError);
             return false;
         }
-        notice = makeNotice(notice);
+        this.addBreadcrumb('Honeybadger Notice', {
+            category: 'notice',
+            metadata: {
+                message: notice.message,
+                name: notice.name,
+                stack: notice.stack
+            }
+        });
+        notice.__breadcrumbs = this.config.breadcrumbsEnabled ? this.__breadcrumbs.slice() : [];
+        // we need to have the source file data before the beforeNotifyHandlers,
+        // in case they modify them
+        var sourceCodeData = notice ? notice.backtrace.slice() : null;
+        getSourceForBacktrace(sourceCodeData, this.__getSourceFileHandler, function (sourcePerTrace) {
+            sourcePerTrace.forEach(function (source, index) {
+                notice.backtrace[index].source = source;
+            });
+            _this.__send(notice);
+        });
+        return true;
+    };
+    /**
+     * An async version of {@link notify} that resolves only after the notice has been reported to Honeybadger.
+     * Implemented using the {@link afterNotify} hook.
+     * Rejects if for any reason the report failed to be reported.
+     * Useful in serverless environments (AWS Lambda).
+     */
+    Client.prototype.notifyAsync = function (noticeable, name, extra) {
+        var _this = this;
+        if (name === void 0) { name = undefined; }
+        if (extra === void 0) { extra = undefined; }
+        return new Promise(function (resolve, reject) {
+            var applyAfterNotify = function (partialNotice) {
+                var originalAfterNotify = partialNotice.afterNotify;
+                partialNotice.afterNotify = function (err) {
+                    originalAfterNotify === null || originalAfterNotify === void 0 ? void 0 : originalAfterNotify.call(_this, err);
+                    if (err) {
+                        return reject(err);
+                    }
+                    resolve();
+                };
+            };
+            // We have to respect any afterNotify hooks that come from the arguments
+            var objectToOverride;
+            if (noticeable.afterNotify) {
+                objectToOverride = noticeable;
+            }
+            else if (name && name.afterNotify) {
+                objectToOverride = name;
+            }
+            else if (extra && extra.afterNotify) {
+                objectToOverride = extra;
+            }
+            else if (name && typeof name === 'object') {
+                objectToOverride = name;
+            }
+            else if (extra) {
+                objectToOverride = extra;
+            }
+            else {
+                objectToOverride = name = {};
+            }
+            applyAfterNotify(objectToOverride);
+            _this.notify(noticeable, name, extra);
+        });
+    };
+    Client.prototype.makeNotice = function (noticeable, name, extra) {
+        if (name === void 0) { name = undefined; }
+        if (extra === void 0) { extra = undefined; }
+        var notice = makeNotice(noticeable);
         if (name && !(typeof name === 'object')) {
             var n = String(name);
             name = { name: n };
@@ -588,7 +759,7 @@ var Client = /** @class */ (function () {
             notice = mergeNotice(notice, extra);
         }
         if (objectIsEmpty(notice)) {
-            return false;
+            return null;
         }
         var noticeTags = this.__constructTags(notice.tags);
         var contextTags = this.__constructTags(this.__context["tags"]);
@@ -612,19 +783,7 @@ var Client = /** @class */ (function () {
             backtraceShift = 2;
         }
         notice.backtrace = makeBacktrace(notice.stack, backtraceShift);
-        if (!runBeforeNotifyHandlers(notice, this.__beforeNotifyHandlers)) {
-            return false;
-        }
-        this.addBreadcrumb('Honeybadger Notice', {
-            category: 'notice',
-            metadata: {
-                message: notice.message,
-                name: notice.name,
-                stack: notice.stack
-            }
-        });
-        notice.__breadcrumbs = this.config.breadcrumbsEnabled ? this.__breadcrumbs.slice() : [];
-        return this.__send(notice);
+        return notice;
     };
     Client.prototype.addBreadcrumb = function (message, opts) {
         if (!this.config.breadcrumbsEnabled) {
@@ -647,11 +806,11 @@ var Client = /** @class */ (function () {
         return this;
     };
     /** @internal */
-    Client.prototype.__reportData = function () {
-        if (this.config.reportData !== null) {
-            return this.config.reportData;
+    Client.prototype.__developmentMode = function () {
+        if (this.config.reportData === true) {
+            return false;
         }
-        return !(this.config.environment && this.config.developmentEnvironments.includes(this.config.environment));
+        return (this.config.environment && this.config.developmentEnvironments.includes(this.config.environment));
     };
     /** @internal */
     Client.prototype.__send = function (_notice) {
@@ -711,7 +870,7 @@ function fatallyLogAndExit(err) {
     process.exit(1);
 }
 function getStats(cb) {
-    var load = os__default['default'].loadavg(), stats = {
+    var load = os__default["default"].loadavg(), stats = {
         load: {
             one: load[0],
             five: load[1],
@@ -719,8 +878,8 @@ function getStats(cb) {
         },
         mem: {}
     };
-    if (fs__default['default'].existsSync('/proc/meminfo')) {
-        return fs__default['default'].readFile('/proc/meminfo', 'utf8', parseStats);
+    if (fs__default["default"].existsSync('/proc/meminfo')) {
+        return fs__default["default"].readFile('/proc/meminfo', 'utf8', parseStats);
     }
     fallback();
     function parseStats(err, memData) {
@@ -743,21 +902,117 @@ function getStats(cb) {
     }
     function fallback() {
         stats.mem = {
-            free: os__default['default'].freemem(),
-            total: os__default['default'].totalmem()
+            free: os__default["default"].freemem(),
+            total: os__default["default"].totalmem()
         };
         return cb(stats);
     }
 }
+/**
+ * Get source file if possible, used to build `notice.backtrace.source`
+ *
+ * @param path to source code
+ * @param cb callback with fileContent
+ */
+function getSourceFile(path, cb) {
+    fs__default["default"].readFile(path, 'utf-8', function (err, data) {
+        cb(err ? null : data);
+    });
+}
+
+function isHandlerSync(handler) {
+    return handler.length > 2;
+}
+function asyncHandler(handler, hb) {
+    var _this = this;
+    return function (event, context) { return __awaiter(_this, void 0, void 0, function () {
+        var err_1;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    _a.trys.push([0, 2, , 3]);
+                    return [4 /*yield*/, handler(event, context)];
+                case 1: return [2 /*return*/, _a.sent()];
+                case 2:
+                    err_1 = _a.sent();
+                    return [2 /*return*/, new Promise(function (_, reject) {
+                            hb.notify(err_1, {
+                                afterNotify: function () {
+                                    hb.clear();
+                                    reject(err_1);
+                                }
+                            });
+                        })];
+                case 3: return [2 /*return*/];
+            }
+        });
+    }); };
+}
+function syncHandler(handler, hb) {
+    return function (event, context, cb) {
+        var hbHandler = function (err) {
+            hb.notify(err, {
+                afterNotify: function () {
+                    hb.clear();
+                    cb(err);
+                }
+            });
+        };
+        try {
+            handler(event, context, function (error, result) {
+                if (error) {
+                    return hbHandler(error);
+                }
+                cb(null, result);
+            });
+        }
+        catch (err) {
+            hbHandler(err);
+        }
+    };
+}
+function lambdaHandler(handler) {
+    // eslint-disable-next-line @typescript-eslint/no-this-alias
+    var hb = this;
+    if (isHandlerSync(handler)) {
+        return syncHandler(handler, hb);
+    }
+    return asyncHandler(handler, hb);
+}
+var listenerRemoved = false;
+/**
+ * Removes AWS Lambda default listener that
+ * exits the process before letting us report to honeybadger.
+ */
+function removeAwsDefaultUncaughtExceptionListener() {
+    if (listenerRemoved) {
+        return;
+    }
+    listenerRemoved = true;
+    var listeners = process.listeners('uncaughtException');
+    if (listeners.length === 0) {
+        return;
+    }
+    // We assume it's the first listener
+    process.removeListener('uncaughtException', listeners[0]);
+}
 
 var count = 0;
+function removeAwsLambdaListener() {
+    var isLambda = !!process.env.LAMBDA_TASK_ROOT;
+    if (!isLambda) {
+        return;
+    }
+    removeAwsDefaultUncaughtExceptionListener();
+}
 function uncaughtException () {
     return {
         load: function (client) {
             if (!client.config.enableUncaught) {
                 return;
             }
-            process.on('uncaughtException', function (uncaughtError) {
+            removeAwsLambdaListener();
+            process.on('uncaughtException', function honeybadgerUncaughtExceptionListener(uncaughtError) {
                 // Prevent recursive errors
                 if (count > 1) {
                     fatallyLogAndExit(uncaughtError);
@@ -801,7 +1056,7 @@ function fullUrl(req) {
     // @ts-ignore The old @types/node incorrectly defines `address` as string|Address
     var port = address ? address.port : undefined;
     // @ts-ignore
-    return url__default['default'].format({
+    return url__default["default"].format({
         protocol: req.protocol,
         hostname: req.hostname,
         port: port,
@@ -811,7 +1066,7 @@ function fullUrl(req) {
 }
 function requestHandler(req, res, next) {
     this.clear();
-    var dom = domain__default['default'].create();
+    var dom = domain__default["default"].create();
     dom.on('error', next);
     dom.run(next);
 }
@@ -828,43 +1083,12 @@ function errorHandler(err, req, _res, next) {
     });
     return next(err);
 }
-function lambdaHandler(handler) {
-    return function lambdaHandler(event, context, callback) {
-        // eslint-disable-next-line prefer-rest-params
-        var args = arguments;
-        var dom = domain__default['default'].create();
-        // eslint-disable-next-line @typescript-eslint/no-this-alias
-        var hb = this;
-        dom.on('error', function (err) {
-            hb.notify(err, {
-                afterNotify: function () {
-                    hb.clear();
-                    callback(err);
-                }
-            });
-        });
-        dom.run(function () {
-            process.nextTick(function () {
-                Promise.resolve(handler.apply(this, args))
-                    .then(function () { hb.clear(); })
-                    .catch(function (err) {
-                    hb.notify(err, {
-                        afterNotify: function () {
-                            hb.clear();
-                            callback(err);
-                        }
-                    });
-                });
-            });
-        });
-    }.bind(this);
-}
 
 var Honeybadger = /** @class */ (function (_super) {
     __extends(Honeybadger, _super);
     function Honeybadger(opts) {
         if (opts === void 0) { opts = {}; }
-        var _this = _super.call(this, __assign({ afterUncaught: fatallyLogAndExit, projectRoot: process.cwd(), hostname: os__default['default'].hostname() }, opts)) || this;
+        var _this = _super.call(this, __assign({ afterUncaught: fatallyLogAndExit, projectRoot: process.cwd(), hostname: os__default["default"].hostname() }, opts)) || this;
         /** @internal */
         _this.__beforeNotifyHandlers = [
             function (notice) {
@@ -877,6 +1101,7 @@ var Honeybadger = /** @class */ (function (_super) {
                 });
             }
         ];
+        _this.__getSourceFileHandler = getSourceFile.bind(_this);
         _this.errorHandler = errorHandler.bind(_this);
         _this.requestHandler = requestHandler.bind(_this);
         _this.lambdaHandler = lambdaHandler.bind(_this);
@@ -889,13 +1114,9 @@ var Honeybadger = /** @class */ (function (_super) {
     Honeybadger.prototype.__send = function (notice) {
         var _this = this;
         var protocol = new url.URL(this.config.endpoint).protocol;
-        var transport = (protocol === "http:" ? http__default['default'] : https__default['default']);
+        var transport = (protocol === "http:" ? http__default["default"] : https__default["default"]);
         var payload = this.__buildPayload(notice);
         payload.server.pid = process.pid;
-        var handlers = Array.prototype.slice.call(this.__afterNotifyHandlers);
-        if (notice.afterNotify) {
-            handlers.unshift(notice.afterNotify);
-        }
         getStats(function (stats) {
             payload.server.stats = stats;
             var data = Buffer.from(JSON.stringify(sanitize(payload, _this.config.maxObjectDepth)), 'utf8');
@@ -908,32 +1129,31 @@ var Honeybadger = /** @class */ (function (_super) {
                 }
             };
             var req = transport.request(endpoint(_this.config, '/v1/notices/js'), options, function (res) {
-                _this.logger.debug("statusCode: " + res.statusCode);
+                _this.logger.debug("statusCode: ".concat(res.statusCode));
                 var body = '';
                 res.on('data', function (chunk) {
                     body += chunk;
                 });
                 res.on('end', function () {
                     if (res.statusCode !== 201) {
-                        runAfterNotifyHandlers(notice, handlers, new Error("Bad HTTP response: " + res.statusCode));
-                        _this.logger.warn("Error report failed: unknown response from server. code=" + res.statusCode);
+                        runAfterNotifyHandlers(notice, _this.__afterNotifyHandlers, new Error("Bad HTTP response: ".concat(res.statusCode)));
+                        _this.logger.warn("Error report failed: unknown response from server. code=".concat(res.statusCode));
                         return;
                     }
                     var uuid = JSON.parse(body).id;
                     runAfterNotifyHandlers(merge(notice, {
                         id: uuid
-                    }), handlers);
-                    _this.logger.info('Error report sent.', "id=" + uuid);
+                    }), _this.__afterNotifyHandlers);
+                    _this.logger.info('Error report sent.', "id=".concat(uuid));
                 });
             });
             req.on('error', function (err) {
-                _this.logger.error('Error report failed: an unknown error occurred.', "message=" + err.message);
-                runAfterNotifyHandlers(notice, handlers, err);
+                _this.logger.error('Error report failed: an unknown error occurred.', "message=".concat(err.message));
+                runAfterNotifyHandlers(notice, _this.__afterNotifyHandlers, err);
             });
             req.write(data);
             req.end();
         });
-        return true;
     };
     return Honeybadger;
 }(Client));

package/dist/server/types/browser/integrations/breadcrumbs.d.ts

@@ -0,0 +1,2 @@
+import { Plugin } from '../../core/types';
+export default function (_window?: Window & typeof globalThis): Plugin;

package/dist/server/types/browser/integrations/event_listeners.d.ts

@@ -0,0 +1,2 @@
+import { Plugin } from '../../core/types';
+export default function (_window?: Window & typeof globalThis): Plugin;

package/dist/server/types/browser/integrations/onerror.d.ts

@@ -0,0 +1,3 @@
+import { Plugin } from '../../core/types';
+export declare function ignoreNextOnError(): void;
+export declare function onError(_window?: any): Plugin;

package/dist/server/types/browser/integrations/onunhandledrejection.d.ts

@@ -0,0 +1,2 @@
+import { Plugin } from '../../core/types';
+export default function (_window?: any): Plugin;

package/dist/server/types/browser/integrations/timers.d.ts

@@ -0,0 +1,2 @@
+import { Plugin } from '../../core/types';
+export default function (_window?: Window & typeof globalThis): Plugin;

package/dist/server/types/browser/util.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Converts an HTMLElement into a human-readable string.
+ * @param {!HTMLElement} element
+ * @return {string}
+ */
+export declare function stringNameOfElement(element: HTMLElement): string;
+export declare function stringSelectorOfElement(element: any): any;
+export declare function stringTextOfElement(element: any): any;
+export declare function nativeFetch(): boolean;
+export declare function parseURL(url: any): {
+    protocol: any;
+    host: any;
+    pathname: any;
+};
+export declare function localURLPathname(url: any): any;
+export declare function decodeCookie(string: string): Record<string, unknown>;
+export declare function encodeCookie(object: any): string;
+export declare const preferCatch: boolean;

package/dist/server/types/browser.d.ts

@@ -0,0 +1,15 @@
+import Client from './core/client';
+import { Config } from './core/types';
+interface BrowserConfig extends Config {
+    async: boolean;
+    maxErrors: number;
+}
+declare class Honeybadger extends Client {
+    config: BrowserConfig;
+    constructor(opts?: Partial<BrowserConfig>);
+    configure(opts?: Partial<BrowserConfig>): Client;
+    resetMaxErrors(): number;
+    factory(opts?: Partial<BrowserConfig>): Honeybadger;
+}
+declare const _default: Honeybadger;
+export default _default;