@honeybadger-io/react 1.0.1 → 2.0.1

package/README.md

@@ -54,7 +54,7 @@ REACT_APP_HONEYBADGER_API_KEY=b425b636 npm run start
 
 This will serve the demo app with hot reload at localhost:3000
 
-For a detailed explanation on how hot reloading works, check out the [guide](http://reactjs-templates.github.io/webpack/) and [docs for react-loader](http://reactjs.github.io/react-loader).
+For a detailed explanation on how hot reloading works, check out the [documentation](https://webpack.js.org/concepts/hot-module-replacement/).
 
 ## Changelog
 

package/dist/DefaultErrorComponent.d.ts

@@ -0,0 +1,13 @@
+import React, { Component } from "react";
+import PropTypes from "prop-types";
+export interface DefaultErrorComponentProps {
+    error: Error | null;
+    info: React.ErrorInfo | null;
+}
+export default class DefaultErrorComponent extends Component<DefaultErrorComponentProps, {}> {
+    static propTypes: {
+        error: PropTypes.Requireable<object>;
+        info: PropTypes.Requireable<object>;
+    };
+    render(): JSX.Element;
+}

package/dist/HoneybadgerErrorBoundary.d.ts

@@ -0,0 +1,24 @@
+import React, { Component, ReactNode } from 'react';
+import HoneybadgerClient from '@honeybadger-io/js/dist/browser/types/core/client';
+import { DefaultErrorComponentProps } from "./DefaultErrorComponent";
+import PropTypes from "prop-types";
+interface HoneybadgerErrorBoundaryProps {
+    honeybadger: HoneybadgerClient;
+    ErrorComponent?: ReactNode;
+}
+interface HoneybadgerErrorBoundaryState extends DefaultErrorComponentProps {
+    errorOccurred: boolean;
+}
+export default class HoneybadgerErrorBoundary extends Component<HoneybadgerErrorBoundaryProps, HoneybadgerErrorBoundaryState> {
+    static propTypes: {
+        honeybadger: PropTypes.Validator<object>;
+        children: PropTypes.Requireable<PropTypes.ReactElementLike>;
+        ErrorComponent: PropTypes.Requireable<PropTypes.ReactElementLike | ((...args: any[]) => any)>;
+    };
+    constructor(props: HoneybadgerErrorBoundaryProps);
+    static getDerivedStateFromError(error: Error): HoneybadgerErrorBoundaryState;
+    componentDidCatch(error: Error, errorInfo: React.ErrorInfo): void;
+    private getErrorComponent;
+    render(): JSX.Element;
+}
+export {};

package/dist/honeybadger-react.cjs.js

@@ -1,211 +1,66 @@
 'use strict';
 
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var js = require('@honeybadger-io/js');
+var jsxRuntime = require('react/jsx-runtime');
 var React = require('react');
 var PropTypes = require('prop-types');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
+var js__default = /*#__PURE__*/_interopDefaultLegacy(js);
 var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
 var PropTypes__default = /*#__PURE__*/_interopDefaultLegacy(PropTypes);
 
-function _classCallCheck(instance, Constructor) {
-  if (!(instance instanceof Constructor)) {
-    throw new TypeError("Cannot call a class as a function");
-  }
-}
-
-function _defineProperties(target, props) {
-  for (var i = 0; i < props.length; i++) {
-    var descriptor = props[i];
-    descriptor.enumerable = descriptor.enumerable || false;
-    descriptor.configurable = true;
-    if ("value" in descriptor) descriptor.writable = true;
-    Object.defineProperty(target, descriptor.key, descriptor);
-  }
-}
-
-function _createClass(Constructor, protoProps, staticProps) {
-  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
-  if (staticProps) _defineProperties(Constructor, staticProps);
-  return Constructor;
-}
-
-function _defineProperty(obj, key, value) {
-  if (key in obj) {
-    Object.defineProperty(obj, key, {
-      value: value,
-      enumerable: true,
-      configurable: true,
-      writable: true
-    });
-  } else {
-    obj[key] = value;
-  }
-
-  return obj;
-}
-
-function _inherits(subClass, superClass) {
-  if (typeof superClass !== "function" && superClass !== null) {
-    throw new TypeError("Super expression must either be null or a function");
-  }
-
-  subClass.prototype = Object.create(superClass && superClass.prototype, {
-    constructor: {
-      value: subClass,
-      writable: true,
-      configurable: true
+class DefaultErrorComponent extends React.Component {
+    render() {
+        return (jsxRuntime.jsxs("div", Object.assign({ className: 'error' }, { children: [jsxRuntime.jsx("div", { children: "An Error Occurred" }, void 0), jsxRuntime.jsx("div", { children: JSON.stringify(this.props.error, null, 2) }, void 0), jsxRuntime.jsx("div", { children: this.props.info ? JSON.stringify(this.props.info, null, 2) : '' }, void 0)] }), void 0));
     }
-  });
-  if (superClass) _setPrototypeOf(subClass, superClass);
-}
-
-function _getPrototypeOf(o) {
-  _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
-    return o.__proto__ || Object.getPrototypeOf(o);
-  };
-  return _getPrototypeOf(o);
-}
-
-function _setPrototypeOf(o, p) {
-  _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
-    o.__proto__ = p;
-    return o;
-  };
-
-  return _setPrototypeOf(o, p);
-}
-
-function _isNativeReflectConstruct() {
-  if (typeof Reflect === "undefined" || !Reflect.construct) return false;
-  if (Reflect.construct.sham) return false;
-  if (typeof Proxy === "function") return true;
-
-  try {
-    Date.prototype.toString.call(Reflect.construct(Date, [], function () {}));
-    return true;
-  } catch (e) {
-    return false;
-  }
-}
-
-function _assertThisInitialized(self) {
-  if (self === void 0) {
-    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
-  }
-
-  return self;
-}
-
-function _possibleConstructorReturn(self, call) {
-  if (call && (typeof call === "object" || typeof call === "function")) {
-    return call;
-  }
-
-  return _assertThisInitialized(self);
 }
-
-function _createSuper(Derived) {
-  var hasNativeReflectConstruct = _isNativeReflectConstruct();
-
-  return function _createSuperInternal() {
-    var Super = _getPrototypeOf(Derived),
-        result;
-
-    if (hasNativeReflectConstruct) {
-      var NewTarget = _getPrototypeOf(this).constructor;
-
-      result = Reflect.construct(Super, arguments, NewTarget);
-    } else {
-      result = Super.apply(this, arguments);
+DefaultErrorComponent.propTypes = {
+    error: PropTypes__default['default'].object,
+    info: PropTypes__default['default'].object
+};
+
+class HoneybadgerErrorBoundary extends React.Component {
+    constructor(props) {
+        super(props);
+        this.state = {
+            error: null,
+            info: null,
+            errorOccurred: false
+        };
     }
-
-    return _possibleConstructorReturn(this, result);
-  };
-}
-
-var DefaultErrorComponent = /*#__PURE__*/function (_Component) {
-  _inherits(DefaultErrorComponent, _Component);
-
-  var _super = _createSuper(DefaultErrorComponent);
-
-  function DefaultErrorComponent() {
-    _classCallCheck(this, DefaultErrorComponent);
-
-    return _super.apply(this, arguments);
-  }
-
-  _createClass(DefaultErrorComponent, [{
-    key: "render",
-    value: function render() {
-      return /*#__PURE__*/React__default['default'].createElement("div", {
-        className: "error"
-      }, /*#__PURE__*/React__default['default'].createElement("div", null, "An Error Occurred"), /*#__PURE__*/React__default['default'].createElement("div", null, this.error), /*#__PURE__*/React__default['default'].createElement("div", null, this.info));
+    static getDerivedStateFromError(error) {
+        return { error: error, errorOccurred: true, info: null };
     }
-  }]);
-
-  return DefaultErrorComponent;
-}(React.Component);
-
-var HoneyBadgerErrorBoundary = /*#__PURE__*/function (_Component2) {
-  _inherits(HoneyBadgerErrorBoundary, _Component2);
-
-  var _super2 = _createSuper(HoneyBadgerErrorBoundary);
-
-  function HoneyBadgerErrorBoundary(props) {
-    var _this;
-
-    _classCallCheck(this, HoneyBadgerErrorBoundary);
-
-    _this = _super2.call(this, props);
-    _this.state = {
-      error: null,
-      info: null,
-      errorOccurred: false
-    };
-    return _this;
-  }
-
-  _createClass(HoneyBadgerErrorBoundary, [{
-    key: "componentDidCatch",
-    value: function componentDidCatch(error, info) {
-      this.setState({
-        errorOccurred: true,
-        error: error,
-        info: info
-      });
-      this.props.honeybadger.notify(error, {
-        context: info
-      });
+    componentDidCatch(error, errorInfo) {
+        this.setState({ errorOccurred: true, error: error, info: errorInfo });
+        this.props.honeybadger.notify(error, { context: errorInfo });
     }
-  }, {
-    key: "render",
-    value: function render() {
-      if (this.state.errorOccurred) {
-        var ErrorComponent = this.props.ErrorComponent;
-        return ErrorComponent ? /*#__PURE__*/React__default['default'].createElement(ErrorComponent, this.state) : /*#__PURE__*/React__default['default'].createElement(DefaultErrorComponent, null);
-      } else {
-        return this.props.children;
-      }
+    getErrorComponent() {
+        return this.props.ErrorComponent
+            ? React__default['default'].createElement(this.props.ErrorComponent, this.state)
+            : jsxRuntime.jsx(DefaultErrorComponent, Object.assign({}, this.state), void 0);
     }
-  }], [{
-    key: "getDerivedStateFromError",
-    value: function getDerivedStateFromError(error) {
-      return {
-        errorOccurred: true,
-        error: error
-      };
+    render() {
+        return (jsxRuntime.jsx(jsxRuntime.Fragment, { children: this.state.errorOccurred
+                ? this.getErrorComponent()
+                : this.props.children }, void 0));
+    }
+}
+HoneybadgerErrorBoundary.propTypes = {
+    honeybadger: PropTypes__default['default'].object.isRequired,
+    children: PropTypes__default['default'].element,
+    ErrorComponent: PropTypes__default['default'].oneOfType([PropTypes__default['default'].element, PropTypes__default['default'].func])
+};
+
+Object.defineProperty(exports, 'Honeybadger', {
+    enumerable: true,
+    get: function () {
+        return js__default['default'];
     }
-  }]);
-
-  return HoneyBadgerErrorBoundary;
-}(React.Component);
-
-_defineProperty(HoneyBadgerErrorBoundary, "propTypes", {
-  honeybadger: PropTypes__default['default'].object,
-  children: PropTypes__default['default'].element,
-  ErrorComponent: PropTypes__default['default'].oneOfType([PropTypes__default['default'].element, PropTypes__default['default'].func])
 });
-
-module.exports = HoneyBadgerErrorBoundary;
+exports.HoneybadgerErrorBoundary = HoneybadgerErrorBoundary;
 //# sourceMappingURL=honeybadger-react.cjs.js.map

package/dist/honeybadger-react.cjs.js.map

@@ -1 +1 @@
-{"version":3,"file":"honeybadger-react.cjs.js","sources":["../../src/index.js"],"sourcesContent":["import React, { Component } from 'react'\nimport PropTypes from 'prop-types'\n\nclass DefaultErrorComponent extends Component {\n  render() {\n    return (\n      <div className='error'>\n        <div>An Error Occurred</div>\n        <div>{this.error}</div>\n        <div>{this.info}</div>\n      </div>\n    )\n  }\n}\n\nexport default class HoneyBadgerErrorBoundary extends Component {\n  static propTypes = {\n    honeybadger: PropTypes.object,\n    children: PropTypes.element,\n    ErrorComponent: PropTypes.oneOfType([PropTypes.element, PropTypes.func])\n  }\n\n  constructor (props) {\n    super(props)\n    this.state = {\n      error: null,\n      info: null,\n      errorOccurred: false\n    }\n  }\n\n  static getDerivedStateFromError (error) {\n    return { errorOccurred: true, error: error }\n  }\n\n  componentDidCatch (error, info) {\n    this.setState({errorOccurred: true, error: error, info: info})\n    this.props.honeybadger.notify(error, { context: info })\n  }\n  render() {\n    if (this.state.errorOccurred) {\n      const {ErrorComponent} = this.props\n      return ErrorComponent ? React.createElement(ErrorComponent, this.state) : <DefaultErrorComponent />\n    } else {\n      return this.props.children\n    }\n  }\n}\n"],"names":["DefaultErrorComponent","React","error","info","Component","HoneyBadgerErrorBoundary","props","state","errorOccurred","setState","honeybadger","notify","context","ErrorComponent","createElement","children","PropTypes","object","element","oneOfType","func"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAGMA;;;;;;;;;;;;;6BACK;AACP,0BACEC;AAAK,QAAA,SAAS,EAAC;AAAf,sBACEA,yEADF,eAEEA,qDAAM,KAAKC,KAAX,CAFF,eAGED,qDAAM,KAAKE,IAAX,CAHF,CADF;AAOD;;;;EATiCC;;IAYfC;;;;;AAOnB,oCAAaC,KAAb,EAAoB;AAAA;;AAAA;;AAClB,+BAAMA,KAAN;AACA,UAAKC,KAAL,GAAa;AACXL,MAAAA,KAAK,EAAE,IADI;AAEXC,MAAAA,IAAI,EAAE,IAFK;AAGXK,MAAAA,aAAa,EAAE;AAHJ,KAAb;AAFkB;AAOnB;;;;sCAMkBN,OAAOC,MAAM;AAC9B,WAAKM,QAAL,CAAc;AAACD,QAAAA,aAAa,EAAE,IAAhB;AAAsBN,QAAAA,KAAK,EAAEA,KAA7B;AAAoCC,QAAAA,IAAI,EAAEA;AAA1C,OAAd;AACA,WAAKG,KAAL,CAAWI,WAAX,CAAuBC,MAAvB,CAA8BT,KAA9B,EAAqC;AAAEU,QAAAA,OAAO,EAAET;AAAX,OAArC;AACD;;;6BACQ;AACP,UAAI,KAAKI,KAAL,CAAWC,aAAf,EAA8B;AAAA,YACrBK,cADqB,GACH,KAAKP,KADF,CACrBO,cADqB;AAE5B,eAAOA,cAAc,gBAAGZ,yBAAK,CAACa,aAAN,CAAoBD,cAApB,EAAoC,KAAKN,KAAzC,CAAH,gBAAqDN,wCAAC,qBAAD,OAA1E;AACD,OAHD,MAGO;AACL,eAAO,KAAKK,KAAL,CAAWS,QAAlB;AACD;AACF;;;6CAfgCb,OAAO;AACtC,aAAO;AAAEM,QAAAA,aAAa,EAAE,IAAjB;AAAuBN,QAAAA,KAAK,EAAEA;AAA9B,OAAP;AACD;;;;EAlBmDE;;gBAAjCC,uCACA;AACjBK,EAAAA,WAAW,EAAEM,6BAAS,CAACC,MADN;AAEjBF,EAAAA,QAAQ,EAAEC,6BAAS,CAACE,OAFH;AAGjBL,EAAAA,cAAc,EAAEG,6BAAS,CAACG,SAAV,CAAoB,CAACH,6BAAS,CAACE,OAAX,EAAoBF,6BAAS,CAACI,IAA9B,CAApB;AAHC;;;;"}
+{"version":3,"file":"honeybadger-react.cjs.js","sources":["../../src/DefaultErrorComponent.tsx","../../src/HoneybadgerErrorBoundary.tsx"],"sourcesContent":["import React, {Component} from \"react\"\nimport PropTypes from \"prop-types\";\n\nexport interface DefaultErrorComponentProps {\n  error: Error | null\n  info: React.ErrorInfo | null\n}\n\nexport default class DefaultErrorComponent extends Component<DefaultErrorComponentProps, {}> {\n\n  static propTypes = {\n    error: PropTypes.object,\n    info: PropTypes.object\n  }\n\n  render() {\n    return (\n      <div className='error'>\n        <div>\n          An Error Occurred\n        </div>\n        <div>\n          {JSON.stringify(this.props.error, null, 2)}\n        </div>\n        <div>\n          {this.props.info ? JSON.stringify(this.props.info, null, 2) : ''}\n        </div>\n      </div>\n    )\n  }\n}\n","import React, {Component, ReactNode} from 'react'\nimport HoneybadgerClient from '@honeybadger-io/js/dist/browser/types/core/client'\nimport DefaultErrorComponent, {DefaultErrorComponentProps} from \"./DefaultErrorComponent\"\nimport PropTypes from \"prop-types\";\n\ninterface HoneybadgerErrorBoundaryProps {\n  honeybadger: HoneybadgerClient\n  ErrorComponent?: ReactNode\n}\n\ninterface HoneybadgerErrorBoundaryState extends DefaultErrorComponentProps {\n  errorOccurred: boolean\n}\n\nexport default class HoneybadgerErrorBoundary extends Component<HoneybadgerErrorBoundaryProps, HoneybadgerErrorBoundaryState> {\n\n  static propTypes = {\n    honeybadger: PropTypes.object.isRequired,\n    children: PropTypes.element,\n    ErrorComponent: PropTypes.oneOfType([PropTypes.element, PropTypes.func])\n  }\n\n  constructor(props: HoneybadgerErrorBoundaryProps) {\n    super(props)\n    this.state = {\n      error: null,\n      info: null,\n      errorOccurred: false\n    }\n  }\n\n  public static getDerivedStateFromError(error: Error): HoneybadgerErrorBoundaryState {\n    return {error: error, errorOccurred: true, info: null}\n  }\n\n  componentDidCatch(error: Error, errorInfo: React.ErrorInfo) {\n    this.setState({errorOccurred: true, error: error, info: errorInfo})\n    this.props.honeybadger.notify(error, {context: errorInfo as any})\n  }\n\n  private getErrorComponent(): ReactNode {\n    return this.props.ErrorComponent\n      ? React.createElement(this.props.ErrorComponent as any, this.state)\n      : <DefaultErrorComponent {...this.state} />\n  }\n\n  render() {\n    return (\n      <>\n        {this.state.errorOccurred\n          ? this.getErrorComponent()\n          : this.props.children\n        }\n      </>\n    )\n  }\n}\n"],"names":["Component","_jsxs","_jsx","PropTypes","React"],"mappings":";;;;;;;;;;;;;;;MAQqB,qBAAsB,SAAQA,eAAyC;IAO1F,MAAM;QACJ,QACEC,uCAAK,SAAS,EAAC,OAAO,iBACpBC,gEAEM,EACNA,kCACG,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC,WACtC,EACNA,kCACG,IAAI,CAAC,KAAK,CAAC,IAAI,GAAG,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC,GAAG,EAAE,WAC5D,aACF,EACP;KACF;;AAnBM,+BAAS,GAAG;IACjB,KAAK,EAAEC,6BAAS,CAAC,MAAM;IACvB,IAAI,EAAEA,6BAAS,CAAC,MAAM;CACvB;;MCCkB,wBAAyB,SAAQH,eAAuE;IAQ3H,YAAY,KAAoC;QAC9C,KAAK,CAAC,KAAK,CAAC,CAAA;QACZ,IAAI,CAAC,KAAK,GAAG;YACX,KAAK,EAAE,IAAI;YACX,IAAI,EAAE,IAAI;YACV,aAAa,EAAE,KAAK;SACrB,CAAA;KACF;IAEM,OAAO,wBAAwB,CAAC,KAAY;QACjD,OAAO,EAAC,KAAK,EAAE,KAAK,EAAE,aAAa,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAC,CAAA;KACvD;IAED,iBAAiB,CAAC,KAAY,EAAE,SAA0B;QACxD,IAAI,CAAC,QAAQ,CAAC,EAAC,aAAa,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,SAAS,EAAC,CAAC,CAAA;QACnE,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,MAAM,CAAC,KAAK,EAAE,EAAC,OAAO,EAAE,SAAgB,EAAC,CAAC,CAAA;KAClE;IAEO,iBAAiB;QACvB,OAAO,IAAI,CAAC,KAAK,CAAC,cAAc;cAC5BI,yBAAK,CAAC,aAAa,CAAC,IAAI,CAAC,KAAK,CAAC,cAAqB,EAAE,IAAI,CAAC,KAAK,CAAC;cACjEF,eAAC,qBAAqB,oBAAK,IAAI,CAAC,KAAK,UAAI,CAAA;KAC9C;IAED,MAAM;QACJ,QACEA,gDACG,IAAI,CAAC,KAAK,CAAC,aAAa;kBACrB,IAAI,CAAC,iBAAiB,EAAE;kBACxB,IAAI,CAAC,KAAK,CAAC,QAAQ,WAEtB,EACJ;KACF;;AAvCM,kCAAS,GAAG;IACjB,WAAW,EAAEC,6BAAS,CAAC,MAAM,CAAC,UAAU;IACxC,QAAQ,EAAEA,6BAAS,CAAC,OAAO;IAC3B,cAAc,EAAEA,6BAAS,CAAC,SAAS,CAAC,CAACA,6BAAS,CAAC,OAAO,EAAEA,6BAAS,CAAC,IAAI,CAAC,CAAC;CACzE;;;;;;;;;;"}

package/dist/honeybadger-react.esm.js

@@ -1,204 +1,50 @@
+export { default as Honeybadger } from '@honeybadger-io/js';
+import { jsxs, jsx, Fragment } from 'react/jsx-runtime';
 import React, { Component } from 'react';
 import PropTypes from 'prop-types';
 
-function _classCallCheck(instance, Constructor) {
-  if (!(instance instanceof Constructor)) {
-    throw new TypeError("Cannot call a class as a function");
-  }
-}
-
-function _defineProperties(target, props) {
-  for (var i = 0; i < props.length; i++) {
-    var descriptor = props[i];
-    descriptor.enumerable = descriptor.enumerable || false;
-    descriptor.configurable = true;
-    if ("value" in descriptor) descriptor.writable = true;
-    Object.defineProperty(target, descriptor.key, descriptor);
-  }
-}
-
-function _createClass(Constructor, protoProps, staticProps) {
-  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
-  if (staticProps) _defineProperties(Constructor, staticProps);
-  return Constructor;
-}
-
-function _defineProperty(obj, key, value) {
-  if (key in obj) {
-    Object.defineProperty(obj, key, {
-      value: value,
-      enumerable: true,
-      configurable: true,
-      writable: true
-    });
-  } else {
-    obj[key] = value;
-  }
-
-  return obj;
-}
-
-function _inherits(subClass, superClass) {
-  if (typeof superClass !== "function" && superClass !== null) {
-    throw new TypeError("Super expression must either be null or a function");
-  }
-
-  subClass.prototype = Object.create(superClass && superClass.prototype, {
-    constructor: {
-      value: subClass,
-      writable: true,
-      configurable: true
+class DefaultErrorComponent extends Component {
+    render() {
+        return (jsxs("div", Object.assign({ className: 'error' }, { children: [jsx("div", { children: "An Error Occurred" }, void 0), jsx("div", { children: JSON.stringify(this.props.error, null, 2) }, void 0), jsx("div", { children: this.props.info ? JSON.stringify(this.props.info, null, 2) : '' }, void 0)] }), void 0));
     }
-  });
-  if (superClass) _setPrototypeOf(subClass, superClass);
-}
-
-function _getPrototypeOf(o) {
-  _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
-    return o.__proto__ || Object.getPrototypeOf(o);
-  };
-  return _getPrototypeOf(o);
 }
-
-function _setPrototypeOf(o, p) {
-  _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
-    o.__proto__ = p;
-    return o;
-  };
-
-  return _setPrototypeOf(o, p);
-}
-
-function _isNativeReflectConstruct() {
-  if (typeof Reflect === "undefined" || !Reflect.construct) return false;
-  if (Reflect.construct.sham) return false;
-  if (typeof Proxy === "function") return true;
-
-  try {
-    Date.prototype.toString.call(Reflect.construct(Date, [], function () {}));
-    return true;
-  } catch (e) {
-    return false;
-  }
-}
-
-function _assertThisInitialized(self) {
-  if (self === void 0) {
-    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
-  }
-
-  return self;
-}
-
-function _possibleConstructorReturn(self, call) {
-  if (call && (typeof call === "object" || typeof call === "function")) {
-    return call;
-  }
-
-  return _assertThisInitialized(self);
-}
-
-function _createSuper(Derived) {
-  var hasNativeReflectConstruct = _isNativeReflectConstruct();
-
-  return function _createSuperInternal() {
-    var Super = _getPrototypeOf(Derived),
-        result;
-
-    if (hasNativeReflectConstruct) {
-      var NewTarget = _getPrototypeOf(this).constructor;
-
-      result = Reflect.construct(Super, arguments, NewTarget);
-    } else {
-      result = Super.apply(this, arguments);
+DefaultErrorComponent.propTypes = {
+    error: PropTypes.object,
+    info: PropTypes.object
+};
+
+class HoneybadgerErrorBoundary extends Component {
+    constructor(props) {
+        super(props);
+        this.state = {
+            error: null,
+            info: null,
+            errorOccurred: false
+        };
     }
-
-    return _possibleConstructorReturn(this, result);
-  };
-}
-
-var DefaultErrorComponent = /*#__PURE__*/function (_Component) {
-  _inherits(DefaultErrorComponent, _Component);
-
-  var _super = _createSuper(DefaultErrorComponent);
-
-  function DefaultErrorComponent() {
-    _classCallCheck(this, DefaultErrorComponent);
-
-    return _super.apply(this, arguments);
-  }
-
-  _createClass(DefaultErrorComponent, [{
-    key: "render",
-    value: function render() {
-      return /*#__PURE__*/React.createElement("div", {
-        className: "error"
-      }, /*#__PURE__*/React.createElement("div", null, "An Error Occurred"), /*#__PURE__*/React.createElement("div", null, this.error), /*#__PURE__*/React.createElement("div", null, this.info));
+    static getDerivedStateFromError(error) {
+        return { error: error, errorOccurred: true, info: null };
     }
-  }]);
-
-  return DefaultErrorComponent;
-}(Component);
-
-var HoneyBadgerErrorBoundary = /*#__PURE__*/function (_Component2) {
-  _inherits(HoneyBadgerErrorBoundary, _Component2);
-
-  var _super2 = _createSuper(HoneyBadgerErrorBoundary);
-
-  function HoneyBadgerErrorBoundary(props) {
-    var _this;
-
-    _classCallCheck(this, HoneyBadgerErrorBoundary);
-
-    _this = _super2.call(this, props);
-    _this.state = {
-      error: null,
-      info: null,
-      errorOccurred: false
-    };
-    return _this;
-  }
-
-  _createClass(HoneyBadgerErrorBoundary, [{
-    key: "componentDidCatch",
-    value: function componentDidCatch(error, info) {
-      this.setState({
-        errorOccurred: true,
-        error: error,
-        info: info
-      });
-      this.props.honeybadger.notify(error, {
-        context: info
-      });
+    componentDidCatch(error, errorInfo) {
+        this.setState({ errorOccurred: true, error: error, info: errorInfo });
+        this.props.honeybadger.notify(error, { context: errorInfo });
     }
-  }, {
-    key: "render",
-    value: function render() {
-      if (this.state.errorOccurred) {
-        var ErrorComponent = this.props.ErrorComponent;
-        return ErrorComponent ? /*#__PURE__*/React.createElement(ErrorComponent, this.state) : /*#__PURE__*/React.createElement(DefaultErrorComponent, null);
-      } else {
-        return this.props.children;
-      }
+    getErrorComponent() {
+        return this.props.ErrorComponent
+            ? React.createElement(this.props.ErrorComponent, this.state)
+            : jsx(DefaultErrorComponent, Object.assign({}, this.state), void 0);
     }
-  }], [{
-    key: "getDerivedStateFromError",
-    value: function getDerivedStateFromError(error) {
-      return {
-        errorOccurred: true,
-        error: error
-      };
+    render() {
+        return (jsx(Fragment, { children: this.state.errorOccurred
+                ? this.getErrorComponent()
+                : this.props.children }, void 0));
     }
-  }]);
-
-  return HoneyBadgerErrorBoundary;
-}(Component);
-
-_defineProperty(HoneyBadgerErrorBoundary, "propTypes", {
-  honeybadger: PropTypes.object,
-  children: PropTypes.element,
-  ErrorComponent: PropTypes.oneOfType([PropTypes.element, PropTypes.func])
-});
+}
+HoneybadgerErrorBoundary.propTypes = {
+    honeybadger: PropTypes.object.isRequired,
+    children: PropTypes.element,
+    ErrorComponent: PropTypes.oneOfType([PropTypes.element, PropTypes.func])
+};
 
-export default HoneyBadgerErrorBoundary;
+export { HoneybadgerErrorBoundary };
 //# sourceMappingURL=honeybadger-react.esm.js.map

package/dist/honeybadger-react.esm.js.map

@@ -1 +1 @@
-{"version":3,"file":"honeybadger-react.esm.js","sources":["../../src/index.js"],"sourcesContent":["import React, { Component } from 'react'\nimport PropTypes from 'prop-types'\n\nclass DefaultErrorComponent extends Component {\n  render() {\n    return (\n      <div className='error'>\n        <div>An Error Occurred</div>\n        <div>{this.error}</div>\n        <div>{this.info}</div>\n      </div>\n    )\n  }\n}\n\nexport default class HoneyBadgerErrorBoundary extends Component {\n  static propTypes = {\n    honeybadger: PropTypes.object,\n    children: PropTypes.element,\n    ErrorComponent: PropTypes.oneOfType([PropTypes.element, PropTypes.func])\n  }\n\n  constructor (props) {\n    super(props)\n    this.state = {\n      error: null,\n      info: null,\n      errorOccurred: false\n    }\n  }\n\n  static getDerivedStateFromError (error) {\n    return { errorOccurred: true, error: error }\n  }\n\n  componentDidCatch (error, info) {\n    this.setState({errorOccurred: true, error: error, info: info})\n    this.props.honeybadger.notify(error, { context: info })\n  }\n  render() {\n    if (this.state.errorOccurred) {\n      const {ErrorComponent} = this.props\n      return ErrorComponent ? React.createElement(ErrorComponent, this.state) : <DefaultErrorComponent />\n    } else {\n      return this.props.children\n    }\n  }\n}\n"],"names":["DefaultErrorComponent","error","info","Component","HoneyBadgerErrorBoundary","props","state","errorOccurred","setState","honeybadger","notify","context","ErrorComponent","React","createElement","children","PropTypes","object","element","oneOfType","func"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAGMA;;;;;;;;;;;;;6BACK;AACP,0BACE;AAAK,QAAA,SAAS,EAAC;AAAf,sBACE,qDADF,eAEE,iCAAM,KAAKC,KAAX,CAFF,eAGE,iCAAM,KAAKC,IAAX,CAHF,CADF;AAOD;;;;EATiCC;;IAYfC;;;;;AAOnB,oCAAaC,KAAb,EAAoB;AAAA;;AAAA;;AAClB,+BAAMA,KAAN;AACA,UAAKC,KAAL,GAAa;AACXL,MAAAA,KAAK,EAAE,IADI;AAEXC,MAAAA,IAAI,EAAE,IAFK;AAGXK,MAAAA,aAAa,EAAE;AAHJ,KAAb;AAFkB;AAOnB;;;;sCAMkBN,OAAOC,MAAM;AAC9B,WAAKM,QAAL,CAAc;AAACD,QAAAA,aAAa,EAAE,IAAhB;AAAsBN,QAAAA,KAAK,EAAEA,KAA7B;AAAoCC,QAAAA,IAAI,EAAEA;AAA1C,OAAd;AACA,WAAKG,KAAL,CAAWI,WAAX,CAAuBC,MAAvB,CAA8BT,KAA9B,EAAqC;AAAEU,QAAAA,OAAO,EAAET;AAAX,OAArC;AACD;;;6BACQ;AACP,UAAI,KAAKI,KAAL,CAAWC,aAAf,EAA8B;AAAA,YACrBK,cADqB,GACH,KAAKP,KADF,CACrBO,cADqB;AAE5B,eAAOA,cAAc,gBAAGC,KAAK,CAACC,aAAN,CAAoBF,cAApB,EAAoC,KAAKN,KAAzC,CAAH,gBAAqD,oBAAC,qBAAD,OAA1E;AACD,OAHD,MAGO;AACL,eAAO,KAAKD,KAAL,CAAWU,QAAlB;AACD;AACF;;;6CAfgCd,OAAO;AACtC,aAAO;AAAEM,QAAAA,aAAa,EAAE,IAAjB;AAAuBN,QAAAA,KAAK,EAAEA;AAA9B,OAAP;AACD;;;;EAlBmDE;;gBAAjCC,uCACA;AACjBK,EAAAA,WAAW,EAAEO,SAAS,CAACC,MADN;AAEjBF,EAAAA,QAAQ,EAAEC,SAAS,CAACE,OAFH;AAGjBN,EAAAA,cAAc,EAAEI,SAAS,CAACG,SAAV,CAAoB,CAACH,SAAS,CAACE,OAAX,EAAoBF,SAAS,CAACI,IAA9B,CAApB;AAHC;;;;"}
+{"version":3,"file":"honeybadger-react.esm.js","sources":["../../src/DefaultErrorComponent.tsx","../../src/HoneybadgerErrorBoundary.tsx"],"sourcesContent":["import React, {Component} from \"react\"\nimport PropTypes from \"prop-types\";\n\nexport interface DefaultErrorComponentProps {\n  error: Error | null\n  info: React.ErrorInfo | null\n}\n\nexport default class DefaultErrorComponent extends Component<DefaultErrorComponentProps, {}> {\n\n  static propTypes = {\n    error: PropTypes.object,\n    info: PropTypes.object\n  }\n\n  render() {\n    return (\n      <div className='error'>\n        <div>\n          An Error Occurred\n        </div>\n        <div>\n          {JSON.stringify(this.props.error, null, 2)}\n        </div>\n        <div>\n          {this.props.info ? JSON.stringify(this.props.info, null, 2) : ''}\n        </div>\n      </div>\n    )\n  }\n}\n","import React, {Component, ReactNode} from 'react'\nimport HoneybadgerClient from '@honeybadger-io/js/dist/browser/types/core/client'\nimport DefaultErrorComponent, {DefaultErrorComponentProps} from \"./DefaultErrorComponent\"\nimport PropTypes from \"prop-types\";\n\ninterface HoneybadgerErrorBoundaryProps {\n  honeybadger: HoneybadgerClient\n  ErrorComponent?: ReactNode\n}\n\ninterface HoneybadgerErrorBoundaryState extends DefaultErrorComponentProps {\n  errorOccurred: boolean\n}\n\nexport default class HoneybadgerErrorBoundary extends Component<HoneybadgerErrorBoundaryProps, HoneybadgerErrorBoundaryState> {\n\n  static propTypes = {\n    honeybadger: PropTypes.object.isRequired,\n    children: PropTypes.element,\n    ErrorComponent: PropTypes.oneOfType([PropTypes.element, PropTypes.func])\n  }\n\n  constructor(props: HoneybadgerErrorBoundaryProps) {\n    super(props)\n    this.state = {\n      error: null,\n      info: null,\n      errorOccurred: false\n    }\n  }\n\n  public static getDerivedStateFromError(error: Error): HoneybadgerErrorBoundaryState {\n    return {error: error, errorOccurred: true, info: null}\n  }\n\n  componentDidCatch(error: Error, errorInfo: React.ErrorInfo) {\n    this.setState({errorOccurred: true, error: error, info: errorInfo})\n    this.props.honeybadger.notify(error, {context: errorInfo as any})\n  }\n\n  private getErrorComponent(): ReactNode {\n    return this.props.ErrorComponent\n      ? React.createElement(this.props.ErrorComponent as any, this.state)\n      : <DefaultErrorComponent {...this.state} />\n  }\n\n  render() {\n    return (\n      <>\n        {this.state.errorOccurred\n          ? this.getErrorComponent()\n          : this.props.children\n        }\n      </>\n    )\n  }\n}\n"],"names":["_jsxs","_jsx"],"mappings":";;;;;MAQqB,qBAAsB,SAAQ,SAAyC;IAO1F,MAAM;QACJ,QACEA,4BAAK,SAAS,EAAC,OAAO,iBACpBC,qDAEM,EACNA,uBACG,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC,WACtC,EACNA,uBACG,IAAI,CAAC,KAAK,CAAC,IAAI,GAAG,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC,GAAG,EAAE,WAC5D,aACF,EACP;KACF;;AAnBM,+BAAS,GAAG;IACjB,KAAK,EAAE,SAAS,CAAC,MAAM;IACvB,IAAI,EAAE,SAAS,CAAC,MAAM;CACvB;;MCCkB,wBAAyB,SAAQ,SAAuE;IAQ3H,YAAY,KAAoC;QAC9C,KAAK,CAAC,KAAK,CAAC,CAAA;QACZ,IAAI,CAAC,KAAK,GAAG;YACX,KAAK,EAAE,IAAI;YACX,IAAI,EAAE,IAAI;YACV,aAAa,EAAE,KAAK;SACrB,CAAA;KACF;IAEM,OAAO,wBAAwB,CAAC,KAAY;QACjD,OAAO,EAAC,KAAK,EAAE,KAAK,EAAE,aAAa,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAC,CAAA;KACvD;IAED,iBAAiB,CAAC,KAAY,EAAE,SAA0B;QACxD,IAAI,CAAC,QAAQ,CAAC,EAAC,aAAa,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,SAAS,EAAC,CAAC,CAAA;QACnE,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,MAAM,CAAC,KAAK,EAAE,EAAC,OAAO,EAAE,SAAgB,EAAC,CAAC,CAAA;KAClE;IAEO,iBAAiB;QACvB,OAAO,IAAI,CAAC,KAAK,CAAC,cAAc;cAC5B,KAAK,CAAC,aAAa,CAAC,IAAI,CAAC,KAAK,CAAC,cAAqB,EAAE,IAAI,CAAC,KAAK,CAAC;cACjEA,IAAC,qBAAqB,oBAAK,IAAI,CAAC,KAAK,UAAI,CAAA;KAC9C;IAED,MAAM;QACJ,QACEA,0BACG,IAAI,CAAC,KAAK,CAAC,aAAa;kBACrB,IAAI,CAAC,iBAAiB,EAAE;kBACxB,IAAI,CAAC,KAAK,CAAC,QAAQ,WAEtB,EACJ;KACF;;AAvCM,kCAAS,GAAG;IACjB,WAAW,EAAE,SAAS,CAAC,MAAM,CAAC,UAAU;IACxC,QAAQ,EAAE,SAAS,CAAC,OAAO;IAC3B,cAAc,EAAE,SAAS,CAAC,SAAS,CAAC,CAAC,SAAS,CAAC,OAAO,EAAE,SAAS,CAAC,IAAI,CAAC,CAAC;CACzE;;;;"}

package/dist/honeybadger-react.js

@@ -1,211 +1,66 @@
-var HoneybadgerReact = (function (React, PropTypes) {
-  'use strict';
+var HoneybadgerReact = (function (exports, js, jsxRuntime, React, PropTypes) {
+    'use strict';
 
-  function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+    function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
-  var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
-  var PropTypes__default = /*#__PURE__*/_interopDefaultLegacy(PropTypes);
+    var js__default = /*#__PURE__*/_interopDefaultLegacy(js);
+    var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
+    var PropTypes__default = /*#__PURE__*/_interopDefaultLegacy(PropTypes);
 
-  function _classCallCheck(instance, Constructor) {
-    if (!(instance instanceof Constructor)) {
-      throw new TypeError("Cannot call a class as a function");
-    }
-  }
-
-  function _defineProperties(target, props) {
-    for (var i = 0; i < props.length; i++) {
-      var descriptor = props[i];
-      descriptor.enumerable = descriptor.enumerable || false;
-      descriptor.configurable = true;
-      if ("value" in descriptor) descriptor.writable = true;
-      Object.defineProperty(target, descriptor.key, descriptor);
-    }
-  }
-
-  function _createClass(Constructor, protoProps, staticProps) {
-    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
-    if (staticProps) _defineProperties(Constructor, staticProps);
-    return Constructor;
-  }
-
-  function _defineProperty(obj, key, value) {
-    if (key in obj) {
-      Object.defineProperty(obj, key, {
-        value: value,
-        enumerable: true,
-        configurable: true,
-        writable: true
-      });
-    } else {
-      obj[key] = value;
-    }
-
-    return obj;
-  }
-
-  function _inherits(subClass, superClass) {
-    if (typeof superClass !== "function" && superClass !== null) {
-      throw new TypeError("Super expression must either be null or a function");
+    class DefaultErrorComponent extends React.Component {
+        render() {
+            return (jsxRuntime.jsxs("div", Object.assign({ className: 'error' }, { children: [jsxRuntime.jsx("div", { children: "An Error Occurred" }, void 0), jsxRuntime.jsx("div", { children: JSON.stringify(this.props.error, null, 2) }, void 0), jsxRuntime.jsx("div", { children: this.props.info ? JSON.stringify(this.props.info, null, 2) : '' }, void 0)] }), void 0));
+        }
     }
-
-    subClass.prototype = Object.create(superClass && superClass.prototype, {
-      constructor: {
-        value: subClass,
-        writable: true,
-        configurable: true
-      }
-    });
-    if (superClass) _setPrototypeOf(subClass, superClass);
-  }
-
-  function _getPrototypeOf(o) {
-    _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
-      return o.__proto__ || Object.getPrototypeOf(o);
+    DefaultErrorComponent.propTypes = {
+        error: PropTypes__default['default'].object,
+        info: PropTypes__default['default'].object
     };
-    return _getPrototypeOf(o);
-  }
 
-  function _setPrototypeOf(o, p) {
-    _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
-      o.__proto__ = p;
-      return o;
-    };
-
-    return _setPrototypeOf(o, p);
-  }
-
-  function _isNativeReflectConstruct() {
-    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
-    if (Reflect.construct.sham) return false;
-    if (typeof Proxy === "function") return true;
-
-    try {
-      Date.prototype.toString.call(Reflect.construct(Date, [], function () {}));
-      return true;
-    } catch (e) {
-      return false;
-    }
-  }
-
-  function _assertThisInitialized(self) {
-    if (self === void 0) {
-      throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
-    }
-
-    return self;
-  }
-
-  function _possibleConstructorReturn(self, call) {
-    if (call && (typeof call === "object" || typeof call === "function")) {
-      return call;
+    class HoneybadgerErrorBoundary extends React.Component {
+        constructor(props) {
+            super(props);
+            this.state = {
+                error: null,
+                info: null,
+                errorOccurred: false
+            };
+        }
+        static getDerivedStateFromError(error) {
+            return { error: error, errorOccurred: true, info: null };
+        }
+        componentDidCatch(error, errorInfo) {
+            this.setState({ errorOccurred: true, error: error, info: errorInfo });
+            this.props.honeybadger.notify(error, { context: errorInfo });
+        }
+        getErrorComponent() {
+            return this.props.ErrorComponent
+                ? React__default['default'].createElement(this.props.ErrorComponent, this.state)
+                : jsxRuntime.jsx(DefaultErrorComponent, Object.assign({}, this.state), void 0);
+        }
+        render() {
+            return (jsxRuntime.jsx(jsxRuntime.Fragment, { children: this.state.errorOccurred
+                    ? this.getErrorComponent()
+                    : this.props.children }, void 0));
+        }
     }
-
-    return _assertThisInitialized(self);
-  }
-
-  function _createSuper(Derived) {
-    var hasNativeReflectConstruct = _isNativeReflectConstruct();
-
-    return function _createSuperInternal() {
-      var Super = _getPrototypeOf(Derived),
-          result;
-
-      if (hasNativeReflectConstruct) {
-        var NewTarget = _getPrototypeOf(this).constructor;
-
-        result = Reflect.construct(Super, arguments, NewTarget);
-      } else {
-        result = Super.apply(this, arguments);
-      }
-
-      return _possibleConstructorReturn(this, result);
+    HoneybadgerErrorBoundary.propTypes = {
+        honeybadger: PropTypes__default['default'].object.isRequired,
+        children: PropTypes__default['default'].element,
+        ErrorComponent: PropTypes__default['default'].oneOfType([PropTypes__default['default'].element, PropTypes__default['default'].func])
     };
-  }
-
-  var DefaultErrorComponent = /*#__PURE__*/function (_Component) {
-    _inherits(DefaultErrorComponent, _Component);
-
-    var _super = _createSuper(DefaultErrorComponent);
-
-    function DefaultErrorComponent() {
-      _classCallCheck(this, DefaultErrorComponent);
-
-      return _super.apply(this, arguments);
-    }
-
-    _createClass(DefaultErrorComponent, [{
-      key: "render",
-      value: function render() {
-        return /*#__PURE__*/React__default['default'].createElement("div", {
-          className: "error"
-        }, /*#__PURE__*/React__default['default'].createElement("div", null, "An Error Occurred"), /*#__PURE__*/React__default['default'].createElement("div", null, this.error), /*#__PURE__*/React__default['default'].createElement("div", null, this.info));
-      }
-    }]);
-
-    return DefaultErrorComponent;
-  }(React.Component);
-
-  var HoneyBadgerErrorBoundary = /*#__PURE__*/function (_Component2) {
-    _inherits(HoneyBadgerErrorBoundary, _Component2);
-
-    var _super2 = _createSuper(HoneyBadgerErrorBoundary);
-
-    function HoneyBadgerErrorBoundary(props) {
-      var _this;
 
-      _classCallCheck(this, HoneyBadgerErrorBoundary);
-
-      _this = _super2.call(this, props);
-      _this.state = {
-        error: null,
-        info: null,
-        errorOccurred: false
-      };
-      return _this;
-    }
-
-    _createClass(HoneyBadgerErrorBoundary, [{
-      key: "componentDidCatch",
-      value: function componentDidCatch(error, info) {
-        this.setState({
-          errorOccurred: true,
-          error: error,
-          info: info
-        });
-        this.props.honeybadger.notify(error, {
-          context: info
-        });
-      }
-    }, {
-      key: "render",
-      value: function render() {
-        if (this.state.errorOccurred) {
-          var ErrorComponent = this.props.ErrorComponent;
-          return ErrorComponent ? /*#__PURE__*/React__default['default'].createElement(ErrorComponent, this.state) : /*#__PURE__*/React__default['default'].createElement(DefaultErrorComponent, null);
-        } else {
-          return this.props.children;
+    Object.defineProperty(exports, 'Honeybadger', {
+        enumerable: true,
+        get: function () {
+            return js__default['default'];
         }
-      }
-    }], [{
-      key: "getDerivedStateFromError",
-      value: function getDerivedStateFromError(error) {
-        return {
-          errorOccurred: true,
-          error: error
-        };
-      }
-    }]);
-
-    return HoneyBadgerErrorBoundary;
-  }(React.Component);
+    });
+    exports.HoneybadgerErrorBoundary = HoneybadgerErrorBoundary;
 
-  _defineProperty(HoneyBadgerErrorBoundary, "propTypes", {
-    honeybadger: PropTypes__default['default'].object,
-    children: PropTypes__default['default'].element,
-    ErrorComponent: PropTypes__default['default'].oneOfType([PropTypes__default['default'].element, PropTypes__default['default'].func])
-  });
+    Object.defineProperty(exports, '__esModule', { value: true });
 
-  return HoneyBadgerErrorBoundary;
+    return exports;
 
-}(React, PropTypes));
+}({}, Honeybadger, jsxRuntime, React, PropTypes));
 //# sourceMappingURL=honeybadger-react.js.map

package/dist/honeybadger-react.js.map

@@ -1 +1 @@
-{"version":3,"file":"honeybadger-react.js","sources":["../../src/index.js"],"sourcesContent":["import React, { Component } from 'react'\nimport PropTypes from 'prop-types'\n\nclass DefaultErrorComponent extends Component {\n  render() {\n    return (\n      <div className='error'>\n        <div>An Error Occurred</div>\n        <div>{this.error}</div>\n        <div>{this.info}</div>\n      </div>\n    )\n  }\n}\n\nexport default class HoneyBadgerErrorBoundary extends Component {\n  static propTypes = {\n    honeybadger: PropTypes.object,\n    children: PropTypes.element,\n    ErrorComponent: PropTypes.oneOfType([PropTypes.element, PropTypes.func])\n  }\n\n  constructor (props) {\n    super(props)\n    this.state = {\n      error: null,\n      info: null,\n      errorOccurred: false\n    }\n  }\n\n  static getDerivedStateFromError (error) {\n    return { errorOccurred: true, error: error }\n  }\n\n  componentDidCatch (error, info) {\n    this.setState({errorOccurred: true, error: error, info: info})\n    this.props.honeybadger.notify(error, { context: info })\n  }\n  render() {\n    if (this.state.errorOccurred) {\n      const {ErrorComponent} = this.props\n      return ErrorComponent ? React.createElement(ErrorComponent, this.state) : <DefaultErrorComponent />\n    } else {\n      return this.props.children\n    }\n  }\n}\n"],"names":["DefaultErrorComponent","React","error","info","Component","HoneyBadgerErrorBoundary","props","state","errorOccurred","setState","honeybadger","notify","context","ErrorComponent","createElement","children","PropTypes","object","element","oneOfType","func"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAGMA;;;;;;;;;;;;;+BACK;EACP,0BACEC;EAAK,QAAA,SAAS,EAAC;EAAf,sBACEA,yEADF,eAEEA,qDAAM,KAAKC,KAAX,CAFF,eAGED,qDAAM,KAAKE,IAAX,CAHF,CADF;EAOD;;;;IATiCC;;MAYfC;;;;;EAOnB,oCAAaC,KAAb,EAAoB;EAAA;;EAAA;;EAClB,+BAAMA,KAAN;EACA,UAAKC,KAAL,GAAa;EACXL,MAAAA,KAAK,EAAE,IADI;EAEXC,MAAAA,IAAI,EAAE,IAFK;EAGXK,MAAAA,aAAa,EAAE;EAHJ,KAAb;EAFkB;EAOnB;;;;wCAMkBN,OAAOC,MAAM;EAC9B,WAAKM,QAAL,CAAc;EAACD,QAAAA,aAAa,EAAE,IAAhB;EAAsBN,QAAAA,KAAK,EAAEA,KAA7B;EAAoCC,QAAAA,IAAI,EAAEA;EAA1C,OAAd;EACA,WAAKG,KAAL,CAAWI,WAAX,CAAuBC,MAAvB,CAA8BT,KAA9B,EAAqC;EAAEU,QAAAA,OAAO,EAAET;EAAX,OAArC;EACD;;;+BACQ;EACP,UAAI,KAAKI,KAAL,CAAWC,aAAf,EAA8B;EAAA,YACrBK,cADqB,GACH,KAAKP,KADF,CACrBO,cADqB;EAE5B,eAAOA,cAAc,gBAAGZ,yBAAK,CAACa,aAAN,CAAoBD,cAApB,EAAoC,KAAKN,KAAzC,CAAH,gBAAqDN,wCAAC,qBAAD,OAA1E;EACD,OAHD,MAGO;EACL,eAAO,KAAKK,KAAL,CAAWS,QAAlB;EACD;EACF;;;+CAfgCb,OAAO;EACtC,aAAO;EAAEM,QAAAA,aAAa,EAAE,IAAjB;EAAuBN,QAAAA,KAAK,EAAEA;EAA9B,OAAP;EACD;;;;IAlBmDE;;kBAAjCC,uCACA;EACjBK,EAAAA,WAAW,EAAEM,6BAAS,CAACC,MADN;EAEjBF,EAAAA,QAAQ,EAAEC,6BAAS,CAACE,OAFH;EAGjBL,EAAAA,cAAc,EAAEG,6BAAS,CAACG,SAAV,CAAoB,CAACH,6BAAS,CAACE,OAAX,EAAoBF,6BAAS,CAACI,IAA9B,CAApB;EAHC;;;;;;;;"}
+{"version":3,"file":"honeybadger-react.js","sources":["../../src/DefaultErrorComponent.tsx","../../src/HoneybadgerErrorBoundary.tsx"],"sourcesContent":["import React, {Component} from \"react\"\nimport PropTypes from \"prop-types\";\n\nexport interface DefaultErrorComponentProps {\n  error: Error | null\n  info: React.ErrorInfo | null\n}\n\nexport default class DefaultErrorComponent extends Component<DefaultErrorComponentProps, {}> {\n\n  static propTypes = {\n    error: PropTypes.object,\n    info: PropTypes.object\n  }\n\n  render() {\n    return (\n      <div className='error'>\n        <div>\n          An Error Occurred\n        </div>\n        <div>\n          {JSON.stringify(this.props.error, null, 2)}\n        </div>\n        <div>\n          {this.props.info ? JSON.stringify(this.props.info, null, 2) : ''}\n        </div>\n      </div>\n    )\n  }\n}\n","import React, {Component, ReactNode} from 'react'\nimport HoneybadgerClient from '@honeybadger-io/js/dist/browser/types/core/client'\nimport DefaultErrorComponent, {DefaultErrorComponentProps} from \"./DefaultErrorComponent\"\nimport PropTypes from \"prop-types\";\n\ninterface HoneybadgerErrorBoundaryProps {\n  honeybadger: HoneybadgerClient\n  ErrorComponent?: ReactNode\n}\n\ninterface HoneybadgerErrorBoundaryState extends DefaultErrorComponentProps {\n  errorOccurred: boolean\n}\n\nexport default class HoneybadgerErrorBoundary extends Component<HoneybadgerErrorBoundaryProps, HoneybadgerErrorBoundaryState> {\n\n  static propTypes = {\n    honeybadger: PropTypes.object.isRequired,\n    children: PropTypes.element,\n    ErrorComponent: PropTypes.oneOfType([PropTypes.element, PropTypes.func])\n  }\n\n  constructor(props: HoneybadgerErrorBoundaryProps) {\n    super(props)\n    this.state = {\n      error: null,\n      info: null,\n      errorOccurred: false\n    }\n  }\n\n  public static getDerivedStateFromError(error: Error): HoneybadgerErrorBoundaryState {\n    return {error: error, errorOccurred: true, info: null}\n  }\n\n  componentDidCatch(error: Error, errorInfo: React.ErrorInfo) {\n    this.setState({errorOccurred: true, error: error, info: errorInfo})\n    this.props.honeybadger.notify(error, {context: errorInfo as any})\n  }\n\n  private getErrorComponent(): ReactNode {\n    return this.props.ErrorComponent\n      ? React.createElement(this.props.ErrorComponent as any, this.state)\n      : <DefaultErrorComponent {...this.state} />\n  }\n\n  render() {\n    return (\n      <>\n        {this.state.errorOccurred\n          ? this.getErrorComponent()\n          : this.props.children\n        }\n      </>\n    )\n  }\n}\n"],"names":["Component","_jsxs","_jsx","PropTypes","React"],"mappings":";;;;;;;;;UAQqB,qBAAsB,SAAQA,eAAyC;QAO1F,MAAM;YACJ,QACEC,uCAAK,SAAS,EAAC,OAAO,iBACpBC,gEAEM,EACNA,kCACG,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC,WACtC,EACNA,kCACG,IAAI,CAAC,KAAK,CAAC,IAAI,GAAG,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC,GAAG,EAAE,WAC5D,aACF,EACP;SACF;;IAnBM,+BAAS,GAAG;QACjB,KAAK,EAAEC,6BAAS,CAAC,MAAM;QACvB,IAAI,EAAEA,6BAAS,CAAC,MAAM;KACvB;;UCCkB,wBAAyB,SAAQH,eAAuE;QAQ3H,YAAY,KAAoC;YAC9C,KAAK,CAAC,KAAK,CAAC,CAAA;YACZ,IAAI,CAAC,KAAK,GAAG;gBACX,KAAK,EAAE,IAAI;gBACX,IAAI,EAAE,IAAI;gBACV,aAAa,EAAE,KAAK;aACrB,CAAA;SACF;QAEM,OAAO,wBAAwB,CAAC,KAAY;YACjD,OAAO,EAAC,KAAK,EAAE,KAAK,EAAE,aAAa,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAC,CAAA;SACvD;QAED,iBAAiB,CAAC,KAAY,EAAE,SAA0B;YACxD,IAAI,CAAC,QAAQ,CAAC,EAAC,aAAa,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,SAAS,EAAC,CAAC,CAAA;YACnE,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,MAAM,CAAC,KAAK,EAAE,EAAC,OAAO,EAAE,SAAgB,EAAC,CAAC,CAAA;SAClE;QAEO,iBAAiB;YACvB,OAAO,IAAI,CAAC,KAAK,CAAC,cAAc;kBAC5BI,yBAAK,CAAC,aAAa,CAAC,IAAI,CAAC,KAAK,CAAC,cAAqB,EAAE,IAAI,CAAC,KAAK,CAAC;kBACjEF,eAAC,qBAAqB,oBAAK,IAAI,CAAC,KAAK,UAAI,CAAA;SAC9C;QAED,MAAM;YACJ,QACEA,gDACG,IAAI,CAAC,KAAK,CAAC,aAAa;sBACrB,IAAI,CAAC,iBAAiB,EAAE;sBACxB,IAAI,CAAC,KAAK,CAAC,QAAQ,WAEtB,EACJ;SACF;;IAvCM,kCAAS,GAAG;QACjB,WAAW,EAAEC,6BAAS,CAAC,MAAM,CAAC,UAAU;QACxC,QAAQ,EAAEA,6BAAS,CAAC,OAAO;QAC3B,cAAc,EAAEA,6BAAS,CAAC,SAAS,CAAC,CAACA,6BAAS,CAAC,OAAO,EAAEA,6BAAS,CAAC,IAAI,CAAC,CAAC;KACzE;;;;;;;;;;;;;;;;;;"}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+import Honeybadger from "@honeybadger-io/js";
+import HoneybadgerErrorBoundary from "./HoneybadgerErrorBoundary";
+export { Honeybadger, HoneybadgerErrorBoundary };

package/dist/index.test.d.ts

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@honeybadger-io/react",
-  "version": "1.0.1",
+  "version": "2.0.1",
   "description": "React.js integration for honeybadger",
   "author": "Jason Truesdell <jason@yuzuten.com> (https://github.com/JasonTrue)",
   "license": "MIT",
@@ -9,7 +9,7 @@
     "url": "git+ssh://git@github.com/honeybadger-io/honeybadger-react.git"
   },
   "main": "dist/honeybadger-react.cjs.js",
-  "types": "./honeybadger-react.d.ts",
+  "types": "./dist/index.d.ts",
   "module": "dist/honeybadger-react.esm.js",
   "unpkg": "dist/honeybadger-react.js",
   "jsnext:main": "dist/honeybadger-react.esm.js",
@@ -20,7 +20,7 @@
   "scripts": {
     "test": "cross-env CI=1 react-scripts test --env=jsdom",
     "test:watch": "react-scripts test --env=jsdom",
-    "build": "rollup -c",
+    "build": "tsc --emitDeclarationOnly --noEmit false && rollup -c",
     "start": "rollup -c -w",
     "prepare": "npm run build",
     "predeploy": "cd example && npm install && npm run build",
@@ -28,7 +28,7 @@
     "preversion": "npm test",
     "version": "scripts/update-versions.sh",
     "postversion": "git push && git push --tags",
-    "prepublishOnly": "npm build && npm test"
+    "prepublishOnly": "npm run build && npm test"
   },
   "peerDependencies": {
     "prop-types": "^15.5.4",
@@ -36,33 +36,25 @@
     "react-dom": "^15.0.0 || ^16.0.0 || ^17.0.0"
   },
   "devDependencies": {
-    "@babel/core": "^7.8.4",
-    "@babel/plugin-external-helpers": "^7.8.3",
-    "@babel/plugin-proposal-class-properties": "^7.8.3",
-    "@babel/preset-env": "^7.8.4",
-    "@babel/preset-react": "^7.8.3",
-    "@rollup/plugin-commonjs": "^17.0.0",
-    "@rollup/plugin-node-resolve": "^11.0.1",
-    "@rollup/plugin-url": "^6.0.0",
-    "@svgr/rollup": "^5.3.1",
+    "@rollup/plugin-commonjs": "^21.0.2",
+    "@rollup/plugin-typescript": "^8.3.1",
+    "@types/jest": "^27.4.1",
+    "@types/react": "^17.0.40",
+    "@types/react-test-renderer": "^17.0.1",
+    "@types/sinon": "^10.0.11",
     "cross-env": "^7.0.0",
-    "gh-pages": "^3.0.0",
-    "react": "^17.0.1",
-    "react-dom": "^17.0.1",
-    "react-scripts": "^4.0.0",
-    "react-test-renderer": "^17.0.1",
-    "rollup": "^2.37.1",
-    "rollup-plugin-babel": "^4.3.3",
-    "rollup-plugin-peer-deps-external": "^2.2.2",
-    "rollup-plugin-postcss": "^3.1.1",
-    "rollup-plugin-uglify": "^6.0.4",
-    "sinon": "^9.0.0"
+    "gh-pages": "^3.2.3",
+    "react": "^17.0.2",
+    "react-scripts": "^4.0.3",
+    "react-test-renderer": "^17.0.2",
+    "rollup": "^2.70.1",
+    "sinon": "^13.0.1",
+    "typescript": "^4.6.2"
   },
   "files": [
-    "dist",
-    "honeybadger-react.d.ts"
+    "dist"
   ],
   "dependencies": {
-    "@honeybadger-io/js": "^3.0.1"
+    "@honeybadger-io/js": "^3.2.8"
   }
 }

package/CHANGELOG.md

@@ -1,51 +0,0 @@
-# Changelog
-All notable changes to this project will be documented in this file.
-
-The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
-and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
-
-## [Unreleased]
-
-## [1.0.1] - 2021-02-18
-### Fixed
-- Bump peerDependencies version for React 17
-
-## [1.0.0] - 2021-01-19
-### Changed
-- Migrate honeybadger-js dependency to @honeybadger-io/js 3.0.0
-  See https://docs.honeybadger.io/lib/javascript/support/upgrading-to-v3.html
-
-## [0.0.8] - 2020-09-24
-### Fixed
-- Update honeybadger-js to 2.3.0
-
-## [0.0.7] - 2020-04-24
-### Fixed
-- Update honeybadger-js to 2.2.1 (security release, see
-    [here](https://github.com/honeybadger-io/honeybadger-js/blob/master/CHANGELOG.md#220---2020-03-16))
-
-## [0.0.6] - 2020-01-08
-### Fixed
-- Fix TypeScript type definitions
-
-## [0.0.5] - 2019-12-18
-### Fixed
-- Deps & security updates
-- Proptypes bug (#39) (#40)
-
-## [0.0.4] - 2019-07-01
-### Fixed
-- Fix PropType mismatch #38 @andrewsouthard
-
-## [0.0.3] - 2019-04-16
-### Changed
-- Update honeybadger-js to v1.0. See
-  https://github.com/honeybadger-io/honeybadger-js/blob/master/CHANGELOG.md
-
-## [0.0.2] - 2019-01-21
-### Added
-- Add TypeScript definition
-
-## [0.0.1] - 2018-11-30
-### Added
-- Initial release

package/honeybadger-react.d.ts

@@ -1,16 +0,0 @@
-declare module "@honeybadger-io/react" {
-  import { Component } from "react";
-  import Honeybadger from "@honeybadger-io/js";
-
-  interface Props {
-    honeybadger: Honeybadger;
-    children: React.ReactNode;
-    ErrorComponent?: React.ReactNode | Function;
-  }
-
-  class ErrorBoundary extends Component<Props> {}
-
-  namespace ErrorBoundary {}
-
-  export = ErrorBoundary;
-}