react-error-boundary 3.0.2 → 3.1.3

package/README.md

@@ -12,7 +12,6 @@
 [![version][version-badge]][package]
 [![downloads][downloads-badge]][npmtrends]
 [![MIT License][license-badge]][license]
-
 [![PRs Welcome][prs-badge]][prs]
 [![Code of Conduct][coc-badge]][coc]
 <!-- prettier-ignore-end -->
@@ -290,7 +289,7 @@ See the recovery examples above.
 This is called when the `resetKeys` are changed (triggering a reset of the
 `ErrorBoundary`). It's called with the `prevResetKeys` and the `resetKeys`.
 
-### `useErrorHandler(error?: Error)`
+### `useErrorHandler(error?: unknown)`
 
 React's error boundaries feature is limited in that the boundaries can only
 handle errors thrown during React's lifecycles. To quote
@@ -336,9 +335,7 @@ function Greeting() {
     <form onSubmit={handleSubmit}>
       <label>Name</label>
       <input id="name" />
-      <button type="submit"}>
-        get a greeting
-      </button>
+      <button type="submit">get a greeting</button>
     </form>
   )
 }
@@ -425,20 +422,20 @@ MIT
 <!-- prettier-ignore-start -->
 [npm]: https://www.npmjs.com
 [node]: https://nodejs.org
-[build-badge]: https://img.shields.io/travis/bvaughn/react-error-boundary.svg?style=flat-square
-[build]: https://travis-ci.org/bvaughn/react-error-boundary
+[build-badge]: https://img.shields.io/github/workflow/status/bvaughn/react-error-boundary/validate?logo=github&style=flat-square
+[build]: https://github.com/bvaughn/react-error-boundary/actions?query=workflow%3Avalidate
 [coverage-badge]: https://img.shields.io/codecov/c/github/bvaughn/react-error-boundary.svg?style=flat-square
 [coverage]: https://codecov.io/github/bvaughn/react-error-boundary
 [version-badge]: https://img.shields.io/npm/v/react-error-boundary.svg?style=flat-square
 [package]: https://www.npmjs.com/package/react-error-boundary
 [downloads-badge]: https://img.shields.io/npm/dm/react-error-boundary.svg?style=flat-square
-[npmtrends]: http://www.npmtrends.com/react-error-boundary
+[npmtrends]: https://www.npmtrends.com/react-error-boundary
 [license-badge]: https://img.shields.io/npm/l/react-error-boundary.svg?style=flat-square
 [license]: https://github.com/bvaughn/react-error-boundary/blob/master/LICENSE
 [prs-badge]: https://img.shields.io/badge/PRs-welcome-brightgreen.svg?style=flat-square
-[prs]: http://makeapullrequest.com
+[prs]: https://makeapullrequest.com
 [coc-badge]: https://img.shields.io/badge/code%20of-conduct-ff69b4.svg?style=flat-square
-[coc]: https://github.com/bvaughn/react-error-boundary/blob/master/other/CODE_OF_CONDUCT.md
+[coc]: https://github.com/bvaughn/react-error-boundary/blob/master/CODE_OF_CONDUCT.md
 [bugs]: https://github.com/bvaughn/react-error-boundary/issues?utf8=%E2%9C%93&q=is%3Aissue+is%3Aopen+sort%3Acreated-desc+label%3Abug
 [requests]: https://github.com/bvaughn/react-error-boundary/issues?utf8=%E2%9C%93&q=is%3Aissue+is%3Aopen+sort%3Areactions-%2B1-desc+label%3Aenhancement
 [good-first-issue]: https://github.com/bvaughn/react-error-boundary/issues?utf8=%E2%9C%93&q=is%3Aissue+is%3Aopen+sort%3Areactions-%2B1-desc+label%3Aenhancement+label%3A%22good+first+issue%22

package/dist/index.d.ts

@@ -0,0 +1,60 @@
+import * as React from 'react';
+interface FallbackProps {
+    error: Error;
+    resetErrorBoundary: (...args: Array<unknown>) => void;
+}
+interface ErrorBoundaryPropsWithComponent {
+    onResetKeysChange?: (prevResetKeys: Array<unknown> | undefined, resetKeys: Array<unknown> | undefined) => void;
+    onReset?: (...args: Array<unknown>) => void;
+    onError?: (error: Error, info: {
+        componentStack: string;
+    }) => void;
+    resetKeys?: Array<unknown>;
+    fallback?: never;
+    FallbackComponent: React.ComponentType<FallbackProps>;
+    fallbackRender?: never;
+}
+declare function FallbackRender(props: FallbackProps): React.ReactElement<unknown, string | React.FunctionComponent | typeof React.Component> | null;
+interface ErrorBoundaryPropsWithRender {
+    onResetKeysChange?: (prevResetKeys: Array<unknown> | undefined, resetKeys: Array<unknown> | undefined) => void;
+    onReset?: (...args: Array<unknown>) => void;
+    onError?: (error: Error, info: {
+        componentStack: string;
+    }) => void;
+    resetKeys?: Array<unknown>;
+    fallback?: never;
+    FallbackComponent?: never;
+    fallbackRender: typeof FallbackRender;
+}
+interface ErrorBoundaryPropsWithFallback {
+    onResetKeysChange?: (prevResetKeys: Array<unknown> | undefined, resetKeys: Array<unknown> | undefined) => void;
+    onReset?: (...args: Array<unknown>) => void;
+    onError?: (error: Error, info: {
+        componentStack: string;
+    }) => void;
+    resetKeys?: Array<unknown>;
+    fallback: React.ReactElement<unknown, string | React.FunctionComponent | typeof React.Component> | null;
+    FallbackComponent?: never;
+    fallbackRender?: never;
+}
+declare type ErrorBoundaryProps = ErrorBoundaryPropsWithFallback | ErrorBoundaryPropsWithComponent | ErrorBoundaryPropsWithRender;
+declare type ErrorBoundaryState = {
+    error: Error | null;
+};
+declare class ErrorBoundary extends React.Component<React.PropsWithRef<React.PropsWithChildren<ErrorBoundaryProps>>, ErrorBoundaryState> {
+    static getDerivedStateFromError(error: Error): {
+        error: Error;
+    };
+    state: ErrorBoundaryState;
+    updatedWithError: boolean;
+    resetErrorBoundary: (...args: Array<unknown>) => void;
+    reset(): void;
+    componentDidCatch(error: Error, info: React.ErrorInfo): void;
+    componentDidMount(): void;
+    componentDidUpdate(prevProps: ErrorBoundaryProps): void;
+    render(): React.ReactNode;
+}
+declare function withErrorBoundary<P>(Component: React.ComponentType<P>, errorBoundaryProps: ErrorBoundaryProps): React.ComponentType<P>;
+declare function useErrorHandler(givenError?: unknown): (error: unknown) => void;
+export { ErrorBoundary, withErrorBoundary, useErrorHandler };
+export type { FallbackProps, ErrorBoundaryPropsWithComponent, ErrorBoundaryPropsWithRender, ErrorBoundaryPropsWithFallback, ErrorBoundaryProps, };

package/dist/react-error-boundary.cjs.d.ts

@@ -0,0 +1 @@
+export * from "../dist/index";

package/dist/react-error-boundary.cjs.js

@@ -7,10 +7,30 @@ var React = require('react');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () {
+            return e[k];
+          }
+        });
+      }
+    });
+  }
+  n['default'] = e;
+  return Object.freeze(n);
+}
+
 var _inheritsLoose__default = /*#__PURE__*/_interopDefaultLegacy(_inheritsLoose);
-var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
+var React__namespace = /*#__PURE__*/_interopNamespace(React);
 
-var changedArray = function (a, b) {
+var changedArray = function changedArray(a, b) {
   if (a === void 0) {
     a = [];
   }
@@ -76,6 +96,14 @@ var ErrorBoundary = /*#__PURE__*/function (_React$Component) {
     (_this$props$onError = (_this$props2 = this.props).onError) == null ? void 0 : _this$props$onError.call(_this$props2, error, info);
   };
 
+  _proto.componentDidMount = function componentDidMount() {
+    var error = this.state.error;
+
+    if (error !== null) {
+      this.updatedWithError = true;
+    }
+  };
+
   _proto.componentDidUpdate = function componentDidUpdate(prevProps) {
     var error = this.state.error;
     var resetKeys = this.props.resetKeys; // There's an edge case where if the thing that triggered the error
@@ -106,17 +134,17 @@ var ErrorBoundary = /*#__PURE__*/function (_React$Component) {
         fallback = _this$props4.fallback;
 
     if (error !== null) {
-      var props = {
+      var _props = {
         error: error,
         resetErrorBoundary: this.resetErrorBoundary
       };
 
-      if ( /*#__PURE__*/React__default['default'].isValidElement(fallback)) {
+      if ( /*#__PURE__*/React__namespace.isValidElement(fallback)) {
         return fallback;
       } else if (typeof fallbackRender === 'function') {
-        return fallbackRender(props);
+        return fallbackRender(_props);
       } else if (FallbackComponent) {
-        return /*#__PURE__*/React__default['default'].createElement(FallbackComponent, props);
+        return /*#__PURE__*/React__namespace.createElement(FallbackComponent, _props);
       } else {
         throw new Error('react-error-boundary requires either a fallback, fallbackRender, or FallbackComponent prop');
       }
@@ -126,12 +154,12 @@ var ErrorBoundary = /*#__PURE__*/function (_React$Component) {
   };
 
   return ErrorBoundary;
-}(React__default['default'].Component);
+}(React__namespace.Component);
 
 function withErrorBoundary(Component, errorBoundaryProps) {
-  function Wrapped(props) {
-    return /*#__PURE__*/React__default['default'].createElement(ErrorBoundary, errorBoundaryProps, /*#__PURE__*/React__default['default'].createElement(Component, props));
-  } // Format for display in DevTools
+  var Wrapped = function Wrapped(props) {
+    return /*#__PURE__*/React__namespace.createElement(ErrorBoundary, errorBoundaryProps, /*#__PURE__*/React__namespace.createElement(Component, props));
+  }; // Format for display in DevTools
 
 
   var name = Component.displayName || Component.name || 'Unknown';
@@ -140,14 +168,19 @@ function withErrorBoundary(Component, errorBoundaryProps) {
 }
 
 function useErrorHandler(givenError) {
-  var _React$useState = React__default['default'].useState(null),
+  var _React$useState = React__namespace.useState(null),
       error = _React$useState[0],
       setError = _React$useState[1];
 
-  if (givenError) throw givenError;
-  if (error) throw error;
+  if (givenError != null) throw givenError;
+  if (error != null) throw error;
   return setError;
 }
+/*
+eslint
+  @typescript-eslint/no-throw-literal: "off",
+  @typescript-eslint/prefer-nullish-coalescing: "off"
+*/
 
 exports.ErrorBoundary = ErrorBoundary;
 exports.useErrorHandler = useErrorHandler;

package/dist/react-error-boundary.esm.d.ts

@@ -0,0 +1 @@
+export * from "../dist/index";

package/dist/react-error-boundary.esm.js

@@ -1,7 +1,7 @@
 import _inheritsLoose from '@babel/runtime/helpers/esm/inheritsLoose';
-import React from 'react';
+import * as React from 'react';
 
-var changedArray = function (a, b) {
+var changedArray = function changedArray(a, b) {
   if (a === void 0) {
     a = [];
   }
@@ -67,6 +67,14 @@ var ErrorBoundary = /*#__PURE__*/function (_React$Component) {
     (_this$props$onError = (_this$props2 = this.props).onError) == null ? void 0 : _this$props$onError.call(_this$props2, error, info);
   };
 
+  _proto.componentDidMount = function componentDidMount() {
+    var error = this.state.error;
+
+    if (error !== null) {
+      this.updatedWithError = true;
+    }
+  };
+
   _proto.componentDidUpdate = function componentDidUpdate(prevProps) {
     var error = this.state.error;
     var resetKeys = this.props.resetKeys; // There's an edge case where if the thing that triggered the error
@@ -97,7 +105,7 @@ var ErrorBoundary = /*#__PURE__*/function (_React$Component) {
         fallback = _this$props4.fallback;
 
     if (error !== null) {
-      var props = {
+      var _props = {
         error: error,
         resetErrorBoundary: this.resetErrorBoundary
       };
@@ -105,9 +113,9 @@ var ErrorBoundary = /*#__PURE__*/function (_React$Component) {
       if ( /*#__PURE__*/React.isValidElement(fallback)) {
         return fallback;
       } else if (typeof fallbackRender === 'function') {
-        return fallbackRender(props);
+        return fallbackRender(_props);
       } else if (FallbackComponent) {
-        return /*#__PURE__*/React.createElement(FallbackComponent, props);
+        return /*#__PURE__*/React.createElement(FallbackComponent, _props);
       } else {
         throw new Error('react-error-boundary requires either a fallback, fallbackRender, or FallbackComponent prop');
       }
@@ -120,9 +128,9 @@ var ErrorBoundary = /*#__PURE__*/function (_React$Component) {
 }(React.Component);
 
 function withErrorBoundary(Component, errorBoundaryProps) {
-  function Wrapped(props) {
+  var Wrapped = function Wrapped(props) {
     return /*#__PURE__*/React.createElement(ErrorBoundary, errorBoundaryProps, /*#__PURE__*/React.createElement(Component, props));
-  } // Format for display in DevTools
+  }; // Format for display in DevTools
 
 
   var name = Component.displayName || Component.name || 'Unknown';
@@ -135,9 +143,14 @@ function useErrorHandler(givenError) {
       error = _React$useState[0],
       setError = _React$useState[1];
 
-  if (givenError) throw givenError;
-  if (error) throw error;
+  if (givenError != null) throw givenError;
+  if (error != null) throw error;
   return setError;
 }
+/*
+eslint
+  @typescript-eslint/no-throw-literal: "off",
+  @typescript-eslint/prefer-nullish-coalescing: "off"
+*/
 
 export { ErrorBoundary, useErrorHandler, withErrorBoundary };

package/dist/react-error-boundary.umd.d.ts

@@ -0,0 +1 @@
+export * from "../dist/index";

package/dist/react-error-boundary.umd.js

@@ -4,17 +4,44 @@
   (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.ReactErrorBoundary = {}, global.React));
 }(this, (function (exports, React) { 'use strict';
 
-  function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+  function _interopNamespace(e) {
+    if (e && e.__esModule) return e;
+    var n = Object.create(null);
+    if (e) {
+      Object.keys(e).forEach(function (k) {
+        if (k !== 'default') {
+          var d = Object.getOwnPropertyDescriptor(e, k);
+          Object.defineProperty(n, k, d.get ? d : {
+            enumerable: true,
+            get: function () {
+              return e[k];
+            }
+          });
+        }
+      });
+    }
+    n['default'] = e;
+    return Object.freeze(n);
+  }
+
+  var React__namespace = /*#__PURE__*/_interopNamespace(React);
 
-  var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
+  function _setPrototypeOf(o, p) {
+    _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
+      o.__proto__ = p;
+      return o;
+    };
+
+    return _setPrototypeOf(o, p);
+  }
 
   function _inheritsLoose(subClass, superClass) {
     subClass.prototype = Object.create(superClass.prototype);
     subClass.prototype.constructor = subClass;
-    subClass.__proto__ = superClass;
+    _setPrototypeOf(subClass, superClass);
   }
 
-  var changedArray = function (a, b) {
+  var changedArray = function changedArray(a, b) {
     if (a === void 0) {
       a = [];
     }
@@ -80,6 +107,14 @@
       (_this$props$onError = (_this$props2 = this.props).onError) == null ? void 0 : _this$props$onError.call(_this$props2, error, info);
     };
 
+    _proto.componentDidMount = function componentDidMount() {
+      var error = this.state.error;
+
+      if (error !== null) {
+        this.updatedWithError = true;
+      }
+    };
+
     _proto.componentDidUpdate = function componentDidUpdate(prevProps) {
       var error = this.state.error;
       var resetKeys = this.props.resetKeys; // There's an edge case where if the thing that triggered the error
@@ -110,17 +145,17 @@
           fallback = _this$props4.fallback;
 
       if (error !== null) {
-        var props = {
+        var _props = {
           error: error,
           resetErrorBoundary: this.resetErrorBoundary
         };
 
-        if ( /*#__PURE__*/React__default['default'].isValidElement(fallback)) {
+        if ( /*#__PURE__*/React__namespace.isValidElement(fallback)) {
           return fallback;
         } else if (typeof fallbackRender === 'function') {
-          return fallbackRender(props);
+          return fallbackRender(_props);
         } else if (FallbackComponent) {
-          return /*#__PURE__*/React__default['default'].createElement(FallbackComponent, props);
+          return /*#__PURE__*/React__namespace.createElement(FallbackComponent, _props);
         } else {
           throw new Error('react-error-boundary requires either a fallback, fallbackRender, or FallbackComponent prop');
         }
@@ -130,12 +165,12 @@
     };
 
     return ErrorBoundary;
-  }(React__default['default'].Component);
+  }(React__namespace.Component);
 
   function withErrorBoundary(Component, errorBoundaryProps) {
-    function Wrapped(props) {
-      return /*#__PURE__*/React__default['default'].createElement(ErrorBoundary, errorBoundaryProps, /*#__PURE__*/React__default['default'].createElement(Component, props));
-    } // Format for display in DevTools
+    var Wrapped = function Wrapped(props) {
+      return /*#__PURE__*/React__namespace.createElement(ErrorBoundary, errorBoundaryProps, /*#__PURE__*/React__namespace.createElement(Component, props));
+    }; // Format for display in DevTools
 
 
     var name = Component.displayName || Component.name || 'Unknown';
@@ -144,14 +179,19 @@
   }
 
   function useErrorHandler(givenError) {
-    var _React$useState = React__default['default'].useState(null),
+    var _React$useState = React__namespace.useState(null),
         error = _React$useState[0],
         setError = _React$useState[1];
 
-    if (givenError) throw givenError;
-    if (error) throw error;
+    if (givenError != null) throw givenError;
+    if (error != null) throw error;
     return setError;
   }
+  /*
+  eslint
+    @typescript-eslint/no-throw-literal: "off",
+    @typescript-eslint/prefer-nullish-coalescing: "off"
+  */
 
   exports.ErrorBoundary = ErrorBoundary;
   exports.useErrorHandler = useErrorHandler;

package/dist/react-error-boundary.umd.js.map

@@ -1 +1 @@
-{"version":3,"file":"react-error-boundary.umd.js","sources":["../node_modules/@babel/runtime/helpers/esm/inheritsLoose.js","../src/index.js"],"sourcesContent":["export default function _inheritsLoose(subClass, superClass) {\n  subClass.prototype = Object.create(superClass.prototype);\n  subClass.prototype.constructor = subClass;\n  subClass.__proto__ = superClass;\n}","import React from 'react'\n\nconst changedArray = (a = [], b = []) =>\n  a.length !== b.length || a.some((item, index) => !Object.is(item, b[index]))\n\nconst initialState = {error: null}\nclass ErrorBoundary extends React.Component {\n  static getDerivedStateFromError(error) {\n    return {error}\n  }\n\n  state = initialState\n  updatedWithError = false\n  resetErrorBoundary = (...args) => {\n    this.props.onReset?.(...args)\n    this.reset()\n  }\n\n  reset() {\n    this.updatedWithError = false\n    this.setState(initialState)\n  }\n\n  componentDidCatch(error, info) {\n    this.props.onError?.(error, info)\n  }\n\n  componentDidUpdate(prevProps) {\n    const {error} = this.state\n    const {resetKeys} = this.props\n\n    // There's an edge case where if the thing that triggered the error\n    // happens to *also* be in the resetKeys array, we'd end up resetting\n    // the error boundary immediately. This would likely trigger a second\n    // error to be thrown.\n    // So we make sure that we don't check the resetKeys on the first call\n    // of cDU after the error is set\n    if (error !== null && !this.updatedWithError) {\n      this.updatedWithError = true\n      return\n    }\n\n    if (error !== null && changedArray(prevProps.resetKeys, resetKeys)) {\n      this.props.onResetKeysChange?.(prevProps.resetKeys, resetKeys)\n      this.reset()\n    }\n  }\n\n  render() {\n    const {error} = this.state\n    const {fallbackRender, FallbackComponent, fallback} = this.props\n\n    if (error !== null) {\n      const props = {\n        error,\n        resetErrorBoundary: this.resetErrorBoundary,\n      }\n      if (React.isValidElement(fallback)) {\n        return fallback\n      } else if (typeof fallbackRender === 'function') {\n        return fallbackRender(props)\n      } else if (FallbackComponent) {\n        return <FallbackComponent {...props} />\n      } else {\n        throw new Error(\n          'react-error-boundary requires either a fallback, fallbackRender, or FallbackComponent prop',\n        )\n      }\n    }\n\n    return this.props.children\n  }\n}\n\nfunction withErrorBoundary(Component, errorBoundaryProps) {\n  function Wrapped(props) {\n    return (\n      <ErrorBoundary {...errorBoundaryProps}>\n        <Component {...props} />\n      </ErrorBoundary>\n    )\n  }\n\n  // Format for display in DevTools\n  const name = Component.displayName || Component.name || 'Unknown'\n  Wrapped.displayName = `withErrorBoundary(${name})`\n\n  return Wrapped\n}\n\nfunction useErrorHandler(givenError) {\n  const [error, setError] = React.useState(null)\n  if (givenError) throw givenError\n  if (error) throw error\n  return setError\n}\n\nexport {ErrorBoundary, withErrorBoundary, useErrorHandler}\n"],"names":["_inheritsLoose","subClass","superClass","prototype","Object","create","constructor","__proto__","changedArray","a","b","length","some","item","index","is","initialState","error","ErrorBoundary","state","updatedWithError","resetErrorBoundary","args","props","onReset","reset","getDerivedStateFromError","setState","componentDidCatch","info","onError","componentDidUpdate","prevProps","resetKeys","onResetKeysChange","render","fallbackRender","FallbackComponent","fallback","React","isValidElement","Error","children","Component","withErrorBoundary","errorBoundaryProps","Wrapped","name","displayName","useErrorHandler","givenError","useState","setError"],"mappings":"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"}
+{"version":3,"file":"react-error-boundary.umd.js","sources":["../node_modules/@babel/runtime/helpers/esm/setPrototypeOf.js","../node_modules/@babel/runtime/helpers/esm/inheritsLoose.js","../src/index.tsx"],"sourcesContent":["export default function _setPrototypeOf(o, p) {\n  _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {\n    o.__proto__ = p;\n    return o;\n  };\n\n  return _setPrototypeOf(o, p);\n}","import setPrototypeOf from \"./setPrototypeOf.js\";\nexport default function _inheritsLoose(subClass, superClass) {\n  subClass.prototype = Object.create(superClass.prototype);\n  subClass.prototype.constructor = subClass;\n  setPrototypeOf(subClass, superClass);\n}","import * as React from 'react'\n\nconst changedArray = (a: Array<unknown> = [], b: Array<unknown> = []) =>\n  a.length !== b.length || a.some((item, index) => !Object.is(item, b[index]))\n\ninterface FallbackProps {\n  error: Error\n  resetErrorBoundary: (...args: Array<unknown>) => void\n}\n\ninterface ErrorBoundaryPropsWithComponent {\n  onResetKeysChange?: (\n    prevResetKeys: Array<unknown> | undefined,\n    resetKeys: Array<unknown> | undefined,\n  ) => void\n  onReset?: (...args: Array<unknown>) => void\n  onError?: (error: Error, info: {componentStack: string}) => void\n  resetKeys?: Array<unknown>\n  fallback?: never\n  FallbackComponent: React.ComponentType<FallbackProps>\n  fallbackRender?: never\n}\n\ndeclare function FallbackRender(\n  props: FallbackProps,\n): React.ReactElement<\n  unknown,\n  string | React.FunctionComponent | typeof React.Component\n> | null\n\ninterface ErrorBoundaryPropsWithRender {\n  onResetKeysChange?: (\n    prevResetKeys: Array<unknown> | undefined,\n    resetKeys: Array<unknown> | undefined,\n  ) => void\n  onReset?: (...args: Array<unknown>) => void\n  onError?: (error: Error, info: {componentStack: string}) => void\n  resetKeys?: Array<unknown>\n  fallback?: never\n  FallbackComponent?: never\n  fallbackRender: typeof FallbackRender\n}\n\ninterface ErrorBoundaryPropsWithFallback {\n  onResetKeysChange?: (\n    prevResetKeys: Array<unknown> | undefined,\n    resetKeys: Array<unknown> | undefined,\n  ) => void\n  onReset?: (...args: Array<unknown>) => void\n  onError?: (error: Error, info: {componentStack: string}) => void\n  resetKeys?: Array<unknown>\n  fallback: React.ReactElement<\n    unknown,\n    string | React.FunctionComponent | typeof React.Component\n  > | null\n  FallbackComponent?: never\n  fallbackRender?: never\n}\n\ntype ErrorBoundaryProps =\n  | ErrorBoundaryPropsWithFallback\n  | ErrorBoundaryPropsWithComponent\n  | ErrorBoundaryPropsWithRender\n\ntype ErrorBoundaryState = {error: Error | null}\n\nconst initialState: ErrorBoundaryState = {error: null}\n\nclass ErrorBoundary extends React.Component<\n  React.PropsWithRef<React.PropsWithChildren<ErrorBoundaryProps>>,\n  ErrorBoundaryState\n> {\n  static getDerivedStateFromError(error: Error) {\n    return {error}\n  }\n\n  state = initialState\n  updatedWithError = false\n  resetErrorBoundary = (...args: Array<unknown>) => {\n    this.props.onReset?.(...args)\n    this.reset()\n  }\n\n  reset() {\n    this.updatedWithError = false\n    this.setState(initialState)\n  }\n\n  componentDidCatch(error: Error, info: React.ErrorInfo) {\n    this.props.onError?.(error, info)\n  }\n\n  componentDidMount() {\n    const {error} = this.state\n\n    if (error !== null) {\n      this.updatedWithError = true\n    }\n  }\n\n  componentDidUpdate(prevProps: ErrorBoundaryProps) {\n    const {error} = this.state\n    const {resetKeys} = this.props\n\n    // There's an edge case where if the thing that triggered the error\n    // happens to *also* be in the resetKeys array, we'd end up resetting\n    // the error boundary immediately. This would likely trigger a second\n    // error to be thrown.\n    // So we make sure that we don't check the resetKeys on the first call\n    // of cDU after the error is set\n    if (error !== null && !this.updatedWithError) {\n      this.updatedWithError = true\n      return\n    }\n\n    if (error !== null && changedArray(prevProps.resetKeys, resetKeys)) {\n      this.props.onResetKeysChange?.(prevProps.resetKeys, resetKeys)\n      this.reset()\n    }\n  }\n\n  render() {\n    const {error} = this.state\n\n    const {fallbackRender, FallbackComponent, fallback} = this.props\n\n    if (error !== null) {\n      const props = {\n        error,\n        resetErrorBoundary: this.resetErrorBoundary,\n      }\n      if (React.isValidElement(fallback)) {\n        return fallback\n      } else if (typeof fallbackRender === 'function') {\n        return fallbackRender(props)\n      } else if (FallbackComponent) {\n        return <FallbackComponent {...props} />\n      } else {\n        throw new Error(\n          'react-error-boundary requires either a fallback, fallbackRender, or FallbackComponent prop',\n        )\n      }\n    }\n\n    return this.props.children\n  }\n}\n\nfunction withErrorBoundary<P>(\n  Component: React.ComponentType<P>,\n  errorBoundaryProps: ErrorBoundaryProps,\n): React.ComponentType<P> {\n  const Wrapped: React.ComponentType<P> = props => {\n    return (\n      <ErrorBoundary {...errorBoundaryProps}>\n        <Component {...props} />\n      </ErrorBoundary>\n    )\n  }\n\n  // Format for display in DevTools\n  const name = Component.displayName || Component.name || 'Unknown'\n  Wrapped.displayName = `withErrorBoundary(${name})`\n\n  return Wrapped\n}\n\nfunction useErrorHandler(givenError?: unknown): (error: unknown) => void {\n  const [error, setError] = React.useState<unknown>(null)\n  if (givenError != null) throw givenError\n  if (error != null) throw error\n  return setError\n}\n\nexport {ErrorBoundary, withErrorBoundary, useErrorHandler}\nexport type {\n  FallbackProps,\n  ErrorBoundaryPropsWithComponent,\n  ErrorBoundaryPropsWithRender,\n  ErrorBoundaryPropsWithFallback,\n  ErrorBoundaryProps,\n}\n\n/*\neslint\n  @typescript-eslint/no-throw-literal: \"off\",\n  @typescript-eslint/prefer-nullish-coalescing: \"off\"\n*/\n"],"names":["_setPrototypeOf","o","p","Object","setPrototypeOf","__proto__","_inheritsLoose","subClass","superClass","prototype","create","constructor","changedArray","a","b","length","some","item","index","is","initialState","error","ErrorBoundary","state","updatedWithError","resetErrorBoundary","args","props","onReset","reset","getDerivedStateFromError","setState","componentDidCatch","info","onError","componentDidMount","componentDidUpdate","prevProps","resetKeys","onResetKeysChange","render","fallbackRender","FallbackComponent","fallback","React","isValidElement","Error","children","Component","withErrorBoundary","errorBoundaryProps","Wrapped","name","displayName","useErrorHandler","givenError","useState","setError"],"mappings":"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"}

package/dist/react-error-boundary.umd.min.d.ts

@@ -0,0 +1 @@
+export * from "../dist/index";

package/dist/react-error-boundary.umd.min.js

@@ -1,2 +1,2 @@
-!function(r,e){"object"==typeof exports&&"undefined"!=typeof module?e(exports,require("react")):"function"==typeof define&&define.amd?define(["exports","react"],e):e((r="undefined"!=typeof globalThis?globalThis:r||self).ReactErrorBoundary={},r.React)}(this,(function(r,e){"use strict";function t(r){return r&&"object"==typeof r&&"default"in r?r:{default:r}}var n=t(e);var o={error:null},a=function(r){var e,t;function a(){for(var e,t=arguments.length,n=new Array(t),a=0;a<t;a++)n[a]=arguments[a];return(e=r.call.apply(r,[this].concat(n))||this).state=o,e.updatedWithError=!1,e.resetErrorBoundary=function(){for(var r,t=arguments.length,n=new Array(t),o=0;o<t;o++)n[o]=arguments[o];null==e.props.onReset||(r=e.props).onReset.apply(r,n),e.reset()},e}t=r,(e=a).prototype=Object.create(t.prototype),e.prototype.constructor=e,e.__proto__=t,a.getDerivedStateFromError=function(r){return{error:r}};var i=a.prototype;return i.reset=function(){this.updatedWithError=!1,this.setState(o)},i.componentDidCatch=function(r,e){var t,n;null==(t=(n=this.props).onError)||t.call(n,r,e)},i.componentDidUpdate=function(r){var e,t,n,o,a=this.state.error,i=this.props.resetKeys;null===a||this.updatedWithError?null!==a&&(void 0===(n=r.resetKeys)&&(n=[]),void 0===(o=i)&&(o=[]),n.length!==o.length||n.some((function(r,e){return!Object.is(r,o[e])})))&&(null==(e=(t=this.props).onResetKeysChange)||e.call(t,r.resetKeys,i),this.reset()):this.updatedWithError=!0},i.render=function(){var r=this.state.error,e=this.props,t=e.fallbackRender,o=e.FallbackComponent,a=e.fallback;if(null!==r){var i={error:r,resetErrorBoundary:this.resetErrorBoundary};if(n.default.isValidElement(a))return a;if("function"==typeof t)return t(i);if(o)return n.default.createElement(o,i);throw new Error("react-error-boundary requires either a fallback, fallbackRender, or FallbackComponent prop")}return this.props.children},a}(n.default.Component);r.ErrorBoundary=a,r.useErrorHandler=function(r){var e=n.default.useState(null),t=e[0],o=e[1];if(r)throw r;if(t)throw t;return o},r.withErrorBoundary=function(r,e){function t(t){return n.default.createElement(a,e,n.default.createElement(r,t))}var o=r.displayName||r.name||"Unknown";return t.displayName="withErrorBoundary("+o+")",t},Object.defineProperty(r,"__esModule",{value:!0})}));
+!function(r,e){"object"==typeof exports&&"undefined"!=typeof module?e(exports,require("react")):"function"==typeof define&&define.amd?define(["exports","react"],e):e((r="undefined"!=typeof globalThis?globalThis:r||self).ReactErrorBoundary={},r.React)}(this,(function(r,e){"use strict";function t(r){if(r&&r.__esModule)return r;var e=Object.create(null);return r&&Object.keys(r).forEach((function(t){if("default"!==t){var n=Object.getOwnPropertyDescriptor(r,t);Object.defineProperty(e,t,n.get?n:{enumerable:!0,get:function(){return r[t]}})}})),e.default=r,Object.freeze(e)}var n=t(e);function o(r,e){return(o=Object.setPrototypeOf||function(r,e){return r.__proto__=e,r})(r,e)}var a={error:null},i=function(r){var e,t;function i(){for(var e,t=arguments.length,n=new Array(t),o=0;o<t;o++)n[o]=arguments[o];return(e=r.call.apply(r,[this].concat(n))||this).state=a,e.updatedWithError=!1,e.resetErrorBoundary=function(){for(var r,t=arguments.length,n=new Array(t),o=0;o<t;o++)n[o]=arguments[o];null==e.props.onReset||(r=e.props).onReset.apply(r,n),e.reset()},e}t=r,(e=i).prototype=Object.create(t.prototype),e.prototype.constructor=e,o(e,t),i.getDerivedStateFromError=function(r){return{error:r}};var u=i.prototype;return u.reset=function(){this.updatedWithError=!1,this.setState(a)},u.componentDidCatch=function(r,e){var t,n;null==(t=(n=this.props).onError)||t.call(n,r,e)},u.componentDidMount=function(){null!==this.state.error&&(this.updatedWithError=!0)},u.componentDidUpdate=function(r){var e,t,n,o,a=this.state.error,i=this.props.resetKeys;null===a||this.updatedWithError?null!==a&&(void 0===(n=r.resetKeys)&&(n=[]),void 0===(o=i)&&(o=[]),n.length!==o.length||n.some((function(r,e){return!Object.is(r,o[e])})))&&(null==(e=(t=this.props).onResetKeysChange)||e.call(t,r.resetKeys,i),this.reset()):this.updatedWithError=!0},u.render=function(){var r=this.state.error,e=this.props,t=e.fallbackRender,o=e.FallbackComponent,a=e.fallback;if(null!==r){var i={error:r,resetErrorBoundary:this.resetErrorBoundary};if(n.isValidElement(a))return a;if("function"==typeof t)return t(i);if(o)return n.createElement(o,i);throw new Error("react-error-boundary requires either a fallback, fallbackRender, or FallbackComponent prop")}return this.props.children},i}(n.Component);r.ErrorBoundary=i,r.useErrorHandler=function(r){var e=n.useState(null),t=e[0],o=e[1];if(null!=r)throw r;if(null!=t)throw t;return o},r.withErrorBoundary=function(r,e){var t=function(t){return n.createElement(i,e,n.createElement(r,t))},o=r.displayName||r.name||"Unknown";return t.displayName="withErrorBoundary("+o+")",t},Object.defineProperty(r,"__esModule",{value:!0})}));
 //# sourceMappingURL=react-error-boundary.umd.min.js.map

package/dist/react-error-boundary.umd.min.js.map

@@ -1 +1 @@
-{"version":3,"file":"react-error-boundary.umd.min.js","sources":["../src/index.js","../node_modules/@babel/runtime/helpers/esm/inheritsLoose.js"],"sourcesContent":["import React from 'react'\n\nconst changedArray = (a = [], b = []) =>\n  a.length !== b.length || a.some((item, index) => !Object.is(item, b[index]))\n\nconst initialState = {error: null}\nclass ErrorBoundary extends React.Component {\n  static getDerivedStateFromError(error) {\n    return {error}\n  }\n\n  state = initialState\n  updatedWithError = false\n  resetErrorBoundary = (...args) => {\n    this.props.onReset?.(...args)\n    this.reset()\n  }\n\n  reset() {\n    this.updatedWithError = false\n    this.setState(initialState)\n  }\n\n  componentDidCatch(error, info) {\n    this.props.onError?.(error, info)\n  }\n\n  componentDidUpdate(prevProps) {\n    const {error} = this.state\n    const {resetKeys} = this.props\n\n    // There's an edge case where if the thing that triggered the error\n    // happens to *also* be in the resetKeys array, we'd end up resetting\n    // the error boundary immediately. This would likely trigger a second\n    // error to be thrown.\n    // So we make sure that we don't check the resetKeys on the first call\n    // of cDU after the error is set\n    if (error !== null && !this.updatedWithError) {\n      this.updatedWithError = true\n      return\n    }\n\n    if (error !== null && changedArray(prevProps.resetKeys, resetKeys)) {\n      this.props.onResetKeysChange?.(prevProps.resetKeys, resetKeys)\n      this.reset()\n    }\n  }\n\n  render() {\n    const {error} = this.state\n    const {fallbackRender, FallbackComponent, fallback} = this.props\n\n    if (error !== null) {\n      const props = {\n        error,\n        resetErrorBoundary: this.resetErrorBoundary,\n      }\n      if (React.isValidElement(fallback)) {\n        return fallback\n      } else if (typeof fallbackRender === 'function') {\n        return fallbackRender(props)\n      } else if (FallbackComponent) {\n        return <FallbackComponent {...props} />\n      } else {\n        throw new Error(\n          'react-error-boundary requires either a fallback, fallbackRender, or FallbackComponent prop',\n        )\n      }\n    }\n\n    return this.props.children\n  }\n}\n\nfunction withErrorBoundary(Component, errorBoundaryProps) {\n  function Wrapped(props) {\n    return (\n      <ErrorBoundary {...errorBoundaryProps}>\n        <Component {...props} />\n      </ErrorBoundary>\n    )\n  }\n\n  // Format for display in DevTools\n  const name = Component.displayName || Component.name || 'Unknown'\n  Wrapped.displayName = `withErrorBoundary(${name})`\n\n  return Wrapped\n}\n\nfunction useErrorHandler(givenError) {\n  const [error, setError] = React.useState(null)\n  if (givenError) throw givenError\n  if (error) throw error\n  return setError\n}\n\nexport {ErrorBoundary, withErrorBoundary, useErrorHandler}\n","export default function _inheritsLoose(subClass, superClass) {\n  subClass.prototype = Object.create(superClass.prototype);\n  subClass.prototype.constructor = subClass;\n  subClass.__proto__ = superClass;\n}"],"names":["initialState","error","ErrorBoundary","subClass","superClass","state","updatedWithError","resetErrorBoundary","args","props","onReset","reset","prototype","Object","create","constructor","__proto__","getDerivedStateFromError","setState","componentDidCatch","info","onError","componentDidUpdate","prevProps","a","b","this","resetKeys","length","some","item","index","is","onResetKeysChange","render","fallbackRender","FallbackComponent","fallback","React","isValidElement","Error","children","Component","givenError","useState","setError","errorBoundaryProps","Wrapped","name","displayName"],"mappings":"gXAEA,IAGMA,EAAe,CAACC,MAAO,MACvBC,cCNS,IAAwBC,EAAUC,0IDW/CC,MAAQL,IACRM,kBAAmB,IACnBC,mBAAqB,wCAAIC,2BAAAA,0BAClBC,MAAMC,cAAND,OAAMC,gBAAaF,KACnBG,WCfwCP,KAAVD,KAC5BS,UAAYC,OAAOC,OAAOV,EAAWQ,WAC9CT,EAASS,UAAUG,YAAcZ,EACjCA,EAASa,UAAYZ,IDIda,yBAAP,SAAgChB,SACvB,CAACA,MAAAA,+BAUVU,MAAA,gBACOL,kBAAmB,OACnBY,SAASlB,MAGhBmB,kBAAA,SAAkBlB,EAAOmB,4BAClBX,OAAMY,mBAAUpB,EAAOmB,MAG9BE,mBAAA,SAAmBC,WAzBCC,EAAQC,EA0BnBxB,EAASyB,KAAKrB,MAAdJ,MACA0B,EAAaD,KAAKjB,MAAlBkB,UAQO,OAAV1B,GAAmByB,KAAKpB,iBAKd,OAAVL,cAxCcuB,EAwCiBD,EAAUI,aAxC3BH,EAAI,cAAIC,EAwC8BE,KAxC9BF,EAAI,IAChCD,EAAEI,SAAWH,EAAEG,QAAUJ,EAAEK,MAAK,SAACC,EAAMC,UAAWlB,OAAOmB,GAAGF,EAAML,EAAEM,2BAwC3DtB,OAAMwB,6BAAoBV,EAAUI,UAAWA,QAC/ChB,cANAL,kBAAmB,KAU5B4B,OAAA,eACSjC,EAASyB,KAAKrB,MAAdJ,QAC+CyB,KAAKjB,MAApD0B,IAAAA,eAAgBC,IAAAA,kBAAmBC,IAAAA,YAE5B,OAAVpC,EAAgB,KACZQ,EAAQ,CACZR,MAAAA,EACAM,mBAAoBmB,KAAKnB,uBAEvB+B,UAAMC,eAAeF,UAChBA,EACF,GAA8B,mBAAnBF,SACTA,EAAe1B,GACjB,GAAI2B,SACFE,wBAACF,EAAsB3B,SAExB,IAAI+B,MACR,qGAKCd,KAAKjB,MAAMgC,aAhEMH,UAAMI,+CAoFlC,SAAyBC,SACGL,UAAMM,SAAS,MAAlC3C,OAAO4C,UACVF,EAAY,MAAMA,KAClB1C,EAAO,MAAMA,SACV4C,uBApBT,SAA2BH,EAAWI,YAC3BC,EAAQtC,UAEb6B,wBAACpC,EAAkB4C,EACjBR,wBAACI,EAAcjC,QAMfuC,EAAON,EAAUO,aAAeP,EAAUM,MAAQ,iBACxDD,EAAQE,iCAAmCD,MAEpCD"}
+{"version":3,"file":"react-error-boundary.umd.min.js","sources":["../node_modules/@babel/runtime/helpers/esm/setPrototypeOf.js","../src/index.tsx","../node_modules/@babel/runtime/helpers/esm/inheritsLoose.js"],"sourcesContent":["export default function _setPrototypeOf(o, p) {\n  _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {\n    o.__proto__ = p;\n    return o;\n  };\n\n  return _setPrototypeOf(o, p);\n}","import * as React from 'react'\n\nconst changedArray = (a: Array<unknown> = [], b: Array<unknown> = []) =>\n  a.length !== b.length || a.some((item, index) => !Object.is(item, b[index]))\n\ninterface FallbackProps {\n  error: Error\n  resetErrorBoundary: (...args: Array<unknown>) => void\n}\n\ninterface ErrorBoundaryPropsWithComponent {\n  onResetKeysChange?: (\n    prevResetKeys: Array<unknown> | undefined,\n    resetKeys: Array<unknown> | undefined,\n  ) => void\n  onReset?: (...args: Array<unknown>) => void\n  onError?: (error: Error, info: {componentStack: string}) => void\n  resetKeys?: Array<unknown>\n  fallback?: never\n  FallbackComponent: React.ComponentType<FallbackProps>\n  fallbackRender?: never\n}\n\ndeclare function FallbackRender(\n  props: FallbackProps,\n): React.ReactElement<\n  unknown,\n  string | React.FunctionComponent | typeof React.Component\n> | null\n\ninterface ErrorBoundaryPropsWithRender {\n  onResetKeysChange?: (\n    prevResetKeys: Array<unknown> | undefined,\n    resetKeys: Array<unknown> | undefined,\n  ) => void\n  onReset?: (...args: Array<unknown>) => void\n  onError?: (error: Error, info: {componentStack: string}) => void\n  resetKeys?: Array<unknown>\n  fallback?: never\n  FallbackComponent?: never\n  fallbackRender: typeof FallbackRender\n}\n\ninterface ErrorBoundaryPropsWithFallback {\n  onResetKeysChange?: (\n    prevResetKeys: Array<unknown> | undefined,\n    resetKeys: Array<unknown> | undefined,\n  ) => void\n  onReset?: (...args: Array<unknown>) => void\n  onError?: (error: Error, info: {componentStack: string}) => void\n  resetKeys?: Array<unknown>\n  fallback: React.ReactElement<\n    unknown,\n    string | React.FunctionComponent | typeof React.Component\n  > | null\n  FallbackComponent?: never\n  fallbackRender?: never\n}\n\ntype ErrorBoundaryProps =\n  | ErrorBoundaryPropsWithFallback\n  | ErrorBoundaryPropsWithComponent\n  | ErrorBoundaryPropsWithRender\n\ntype ErrorBoundaryState = {error: Error | null}\n\nconst initialState: ErrorBoundaryState = {error: null}\n\nclass ErrorBoundary extends React.Component<\n  React.PropsWithRef<React.PropsWithChildren<ErrorBoundaryProps>>,\n  ErrorBoundaryState\n> {\n  static getDerivedStateFromError(error: Error) {\n    return {error}\n  }\n\n  state = initialState\n  updatedWithError = false\n  resetErrorBoundary = (...args: Array<unknown>) => {\n    this.props.onReset?.(...args)\n    this.reset()\n  }\n\n  reset() {\n    this.updatedWithError = false\n    this.setState(initialState)\n  }\n\n  componentDidCatch(error: Error, info: React.ErrorInfo) {\n    this.props.onError?.(error, info)\n  }\n\n  componentDidMount() {\n    const {error} = this.state\n\n    if (error !== null) {\n      this.updatedWithError = true\n    }\n  }\n\n  componentDidUpdate(prevProps: ErrorBoundaryProps) {\n    const {error} = this.state\n    const {resetKeys} = this.props\n\n    // There's an edge case where if the thing that triggered the error\n    // happens to *also* be in the resetKeys array, we'd end up resetting\n    // the error boundary immediately. This would likely trigger a second\n    // error to be thrown.\n    // So we make sure that we don't check the resetKeys on the first call\n    // of cDU after the error is set\n    if (error !== null && !this.updatedWithError) {\n      this.updatedWithError = true\n      return\n    }\n\n    if (error !== null && changedArray(prevProps.resetKeys, resetKeys)) {\n      this.props.onResetKeysChange?.(prevProps.resetKeys, resetKeys)\n      this.reset()\n    }\n  }\n\n  render() {\n    const {error} = this.state\n\n    const {fallbackRender, FallbackComponent, fallback} = this.props\n\n    if (error !== null) {\n      const props = {\n        error,\n        resetErrorBoundary: this.resetErrorBoundary,\n      }\n      if (React.isValidElement(fallback)) {\n        return fallback\n      } else if (typeof fallbackRender === 'function') {\n        return fallbackRender(props)\n      } else if (FallbackComponent) {\n        return <FallbackComponent {...props} />\n      } else {\n        throw new Error(\n          'react-error-boundary requires either a fallback, fallbackRender, or FallbackComponent prop',\n        )\n      }\n    }\n\n    return this.props.children\n  }\n}\n\nfunction withErrorBoundary<P>(\n  Component: React.ComponentType<P>,\n  errorBoundaryProps: ErrorBoundaryProps,\n): React.ComponentType<P> {\n  const Wrapped: React.ComponentType<P> = props => {\n    return (\n      <ErrorBoundary {...errorBoundaryProps}>\n        <Component {...props} />\n      </ErrorBoundary>\n    )\n  }\n\n  // Format for display in DevTools\n  const name = Component.displayName || Component.name || 'Unknown'\n  Wrapped.displayName = `withErrorBoundary(${name})`\n\n  return Wrapped\n}\n\nfunction useErrorHandler(givenError?: unknown): (error: unknown) => void {\n  const [error, setError] = React.useState<unknown>(null)\n  if (givenError != null) throw givenError\n  if (error != null) throw error\n  return setError\n}\n\nexport {ErrorBoundary, withErrorBoundary, useErrorHandler}\nexport type {\n  FallbackProps,\n  ErrorBoundaryPropsWithComponent,\n  ErrorBoundaryPropsWithRender,\n  ErrorBoundaryPropsWithFallback,\n  ErrorBoundaryProps,\n}\n\n/*\neslint\n  @typescript-eslint/no-throw-literal: \"off\",\n  @typescript-eslint/prefer-nullish-coalescing: \"off\"\n*/\n","import setPrototypeOf from \"./setPrototypeOf.js\";\nexport default function _inheritsLoose(subClass, superClass) {\n  subClass.prototype = Object.create(superClass.prototype);\n  subClass.prototype.constructor = subClass;\n  setPrototypeOf(subClass, superClass);\n}"],"names":["_setPrototypeOf","o","p","Object","setPrototypeOf","__proto__","initialState","error","ErrorBoundary","subClass","superClass","state","updatedWithError","resetErrorBoundary","args","props","onReset","reset","prototype","create","constructor","getDerivedStateFromError","setState","componentDidCatch","info","onError","componentDidMount","this","componentDidUpdate","prevProps","a","b","resetKeys","length","some","item","index","is","onResetKeysChange","render","fallbackRender","FallbackComponent","fallback","React","isValidElement","Error","children","Component","givenError","useState","setError","errorBoundaryProps","Wrapped","name","displayName"],"mappings":"ukBAAe,SAASA,EAAgBC,EAAGC,UACzCF,EAAkBG,OAAOC,gBAAkB,SAAyBH,EAAGC,UACrED,EAAEI,UAAYH,EACPD,IAGcA,EAAGC,GCJ5B,IAgEMI,EAAmC,CAACC,MAAO,MAE3CC,cCnES,IAAwBC,EAAUC,0ID2E/CC,MAAQL,IACRM,kBAAmB,IACnBC,mBAAqB,wCAAIC,2BAAAA,0BAClBC,MAAMC,cAAND,OAAMC,gBAAaF,KACnBG,WC/EwCP,KAAVD,KAC5BS,UAAYf,OAAOgB,OAAOT,EAAWQ,WAC9CT,EAASS,UAAUE,YAAcX,EACjCL,EAAeK,EAAUC,KDoElBW,yBAAP,SAAgCd,SACvB,CAACA,MAAAA,+BAUVU,MAAA,gBACOL,kBAAmB,OACnBU,SAAShB,MAGhBiB,kBAAA,SAAkBhB,EAAciB,4BACzBT,OAAMU,mBAAUlB,EAAOiB,MAG9BE,kBAAA,WAGgB,OAFEC,KAAKhB,MAAdJ,aAGAK,kBAAmB,MAI5BgB,mBAAA,SAAmBC,WAlGCC,EAAwBC,EAmGnCxB,EAASoB,KAAKhB,MAAdJ,MACAyB,EAAaL,KAAKZ,MAAlBiB,UAQO,OAAVzB,GAAmBoB,KAAKf,iBAKd,OAAVL,cAjHcuB,EAiHiBD,EAAUG,aAjH3BF,EAAoB,cAAIC,EAiHcC,KAjHdD,EAAoB,IAChED,EAAEG,SAAWF,EAAEE,QAAUH,EAAEI,MAAK,SAACC,EAAMC,UAAWjC,OAAOkC,GAAGF,EAAMJ,EAAEK,2BAiH3DrB,OAAMuB,6BAAoBT,EAAUG,UAAWA,QAC/Cf,cANAL,kBAAmB,KAU5B2B,OAAA,eACShC,EAASoB,KAAKhB,MAAdJ,QAE+CoB,KAAKZ,MAApDyB,IAAAA,eAAgBC,IAAAA,kBAAmBC,IAAAA,YAE5B,OAAVnC,EAAgB,KACZQ,EAAQ,CACZR,MAAAA,EACAM,mBAAoBc,KAAKd,uBAEvB8B,EAAMC,eAAeF,UAChBA,EACF,GAA8B,mBAAnBF,SACTA,EAAezB,GACjB,GAAI0B,SACFE,gBAACF,EAAsB1B,SAExB,IAAI8B,MACR,qGAKClB,KAAKZ,MAAM+B,aA5EMH,EAAMI,+CAmGlC,SAAyBC,SACGL,EAAMM,SAAkB,MAA3C1C,OAAO2C,UACI,MAAdF,EAAoB,MAAMA,KACjB,MAATzC,EAAe,MAAMA,SAClB2C,uBAvBT,SACEH,EACAI,OAEMC,EAAkC,SAAArC,UAEpC4B,gBAACnC,EAAkB2C,EACjBR,gBAACI,EAAchC,KAMfsC,EAAON,EAAUO,aAAeP,EAAUM,MAAQ,iBACxDD,EAAQE,iCAAmCD,MAEpCD"}

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "react-error-boundary",
-  "version": "3.0.2",
+  "version": "3.1.3",
   "description": "Simple reusable React error boundary component",
   "main": "dist/react-error-boundary.cjs.js",
   "module": "dist/react-error-boundary.esm.js",
   "browser": "dist/react-error-boundary.umd.js",
-  "types": "index.d.ts",
+  "types": "dist/index.d.ts",
   "sideEffects": false,
   "keywords": [
     "react",
@@ -27,8 +27,7 @@
   },
   "homepage": "https://github.com/bvaughn/react-error-boundary#readme",
   "files": [
-    "dist",
-    "index.d.ts"
+    "dist"
   ],
   "scripts": {
     "build": "kcd-scripts build --bundle",
@@ -36,19 +35,22 @@
     "setup": "npm install && npm run validate -s",
     "test": "kcd-scripts test",
     "test:update": "npm test -- --updateSnapshot --coverage",
+    "typecheck": "kcd-scripts typecheck",
     "validate": "kcd-scripts validate"
   },
   "dependencies": {
-    "@babel/runtime": "^7.11.2"
+    "@babel/runtime": "^7.12.5"
   },
   "devDependencies": {
-    "@testing-library/jest-dom": "^5.11.4",
-    "@testing-library/react": "^11.0.2",
-    "@testing-library/user-event": "^12.1.4",
-    "kcd-scripts": "^6.3.0",
-    "react": "^16.13.1",
-    "react-dom": "^16.13.1",
-    "typescript": "^4.0.2"
+    "@testing-library/jest-dom": "^5.11.6",
+    "@testing-library/react": "^11.2.2",
+    "@testing-library/user-event": "^12.2.2",
+    "@types/jest": "^26.0.15",
+    "@types/react": "^17.0.0",
+    "kcd-scripts": "^7.3.0",
+    "react": "^17.0.1",
+    "react-dom": "^17.0.1",
+    "typescript": "^4.1.2"
   },
   "peerDependencies": {
     "react": ">=16.13.1"

package/index.d.ts

@@ -1,46 +0,0 @@
-import * as React from 'react'
-
-export interface FallbackProps {
-  error?: Error
-  resetErrorBoundary: () => void
-}
-
-export interface ErrorBoundaryPropsWithComponent {
-  onResetKeysChange?: (prevResetKeys: Array<any>, resetKeys: Array<any>) => void
-  onReset?: () => void
-  onError?: (error: Error, info: { componentStack: string }) => void
-  resetKeys?: Array<any>
-  FallbackComponent: React.ComponentType<FallbackProps>
-}
-
-export interface ErrorBoundaryPropsWithRender {
-  onResetKeysChange?: (prevResetKeys: Array<any>, resetKeys: Array<any>) => void
-  onReset?: () => void
-  onError?: (error: Error, info: { componentStack: string }) => void
-  resetKeys?: Array<any>
-  fallbackRender: (props: FallbackProps) => React.ReactElement<any, any> | null
-}
-
-export interface ErrorBoundaryPropsWithFallback {
-  onResetKeysChange?: (prevResetKeys: Array<any>, resetKeys: Array<any>) => void
-  onReset?: () => void
-  onError?: (error: Error, info: { componentStack: string }) => void
-  resetKeys?: Array<any>
-  fallback: React.ReactElement<any, any> | null
-}
-
-export type ErrorBoundaryProps =
-  | ErrorBoundaryPropsWithFallback
-  | ErrorBoundaryPropsWithComponent
-  | ErrorBoundaryPropsWithRender
-
-export class ErrorBoundary extends React.Component<ErrorBoundaryProps> {}
-
-export function withErrorBoundary<P>(
-  ComponentToDecorate: React.ComponentType<P>,
-  errorBoundaryProps: ErrorBoundaryProps,
-): React.ComponentType<P>
-
-export function useErrorHandler<P = Error>(
-  error?: P,
-): React.Dispatch<React.SetStateAction<P>>