react-error-boundary 2.2.2 → 2.3.2

package/README.md

@@ -28,6 +28,12 @@ This component provides a simple and reusable wrapper that you can use to wrap
 around your components. Any rendering errors in your components hierarchy can
 then be gracefully handled.
 
+Reading this blog post will help you understand what react-error-boundary does
+for you:
+[Use react-error-boundary to handle errors in React](https://kentcdodds.com/blog/use-react-error-boundary-to-handle-errors-in-react)
+– How to simplify your React apps by handling React errors effectively with
+react-error-boundary
+
 ## Table of Contents
 
 <!-- START doctoc generated TOC please keep comment here to allow auto update -->
@@ -38,14 +44,7 @@ then be gracefully handled.
   - [Error Recovery](#error-recovery)
 - [API](#api)
   - [`ErrorBoundary` props](#errorboundary-props)
-  - [`children`](#children)
-  - [`FallbackComponent`](#fallbackcomponent)
-  - [`fallbackRender`](#fallbackrender)
-  - [`fallback`](#fallback)
-  - [`onError`](#onerror)
-  - [`onReset`](#onreset)
-  - [`resetKeys`](#resetkeys)
-  - [`onResetKeysChange`](#onresetkeyschange)
+  - [`useErrorHandler(error?: Error)`](#useerrorhandlererror-error)
 - [Issues](#issues)
   - [🐛 Bugs](#-bugs)
   - [💡 Feature Requests](#-feature-requests)
@@ -190,13 +189,13 @@ specific scenario.
 
 ### `ErrorBoundary` props
 
-### `children`
+#### `children`
 
 This is what you want rendered when everything's working fine. If there's an
 error that React can handle within the children of the `ErrorBoundary`, the
 `ErrorBoundary` will catch that and allow you to handle it gracefully.
 
-### `FallbackComponent`
+#### `FallbackComponent`
 
 This is a component you want rendered in the event of an error. As props it will
 be passed the `error`, `componentStack`, and `resetErrorBoundary` (which will
@@ -205,7 +204,7 @@ when used in combination with the `onReset` prop).
 
 This is required if no `fallback` or `fallbackRender` prop is provided.
 
-### `fallbackRender`
+#### `fallbackRender`
 
 This is a render-prop based API that allows you to inline your error fallback UI
 into the component that's using the `ErrorBoundary`. This is useful if you need
@@ -247,7 +246,7 @@ problem.
 
 This is required if no `FallbackComponent` or `fallback` prop is provided.
 
-### `fallback`
+#### `fallback`
 
 In the spirit of consistency with the `React.Suspense` component, we also
 support a simple `fallback` prop which you can use for a generic fallback. This
@@ -262,12 +261,12 @@ const ui = (
 )
 ```
 
-### `onError`
+#### `onError`
 
 This will be called when there's been an error that the `ErrorBoundary` has
 handled. It will be called with two arguments: `error`, `componentStack`.
 
-### `onReset`
+#### `onReset`
 
 This will be called immediately before the `ErrorBoundary` resets it's internal
 state (which will result in rendering the `children` again). You should use this
@@ -279,7 +278,7 @@ error happening again.
 **Important**: `onReset` will _not_ be called when reset happens from a change
 in `resetKeys`. Use `onResetKeysChange` for that.
 
-### `resetKeys`
+#### `resetKeys`
 
 Sometimes an error happens as a result of local state to the component that's
 rendering the error. If this is the case, then you can pass `resetKeys` which is
@@ -289,11 +288,121 @@ then it will reset automatically (triggering a re-render of the `children`).
 
 See the recovery examples above.
 
-### `onResetKeysChange`
+#### `onResetKeysChange`
 
 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)`
+
+React's error boundaries feature is limited in that the boundaries can only
+handle errors thrown during React's lifecycles. To quote
+[the React docs on Error Boundaries](https://reactjs.org/docs/error-boundaries.html):
+
+> Error boundaries do not catch errors for:
+>
+> - Event handlers
+>   ([learn more](https://reactjs.org/docs/error-boundaries.html#how-about-event-handlers))
+> - Asynchronous code (e.g. setTimeout or requestAnimationFrame callbacks)
+> - Server side rendering
+> - Errors thrown in the error boundary itself (rather than its children)
+
+This means you have to handle those errors yourself, but you probably would like
+to reuse the error boundaries you worked hard on creating for those kinds of
+errors as well. This is what `useErrorHandler` is for.
+
+There are two ways to use `useErrorHandler`:
+
+1. `const handleError = useErrorHandler()`: call `handleError(theError)`
+2. `useErrorHandler(error)`: useful if you are managing the error state yourself
+   or get it from another hook.
+
+Here's an example:
+
+```javascript
+function Greeting() {
+  const [greeting, setGreeting] = React.useState(null)
+  const handleError = useErrorHandler()
+
+  function handleSubmit(event) {
+    event.preventDefault()
+    const name = event.target.elements.name.value
+    fetchGreeting(name).then(
+      newGreeting => setGreeting(newGreeting),
+      handleError,
+    )
+  }
+
+  return greeting ? (
+    <div>{greeting}</div>
+  ) : (
+    <form onSubmit={handleSubmit}>
+      <label>Name</label>
+      <input id="name" />
+      <button type="submit"}>
+        get a greeting
+      </button>
+    </form>
+  )
+}
+```
+
+> Note, in case it's not clear what's happening here, you could also write
+> `handleSubmit` like this:
+
+```javascript
+function handleSubmit(event) {
+  event.preventDefault()
+  const name = event.target.elements.name.value
+  fetchGreeting(name).then(
+    newGreeting => setGreeting(newGreeting),
+    error => handleError(error),
+  )
+}
+```
+
+Alternatively, let's say you're using a hook that gives you the error:
+
+```javascript
+function Greeting() {
+  const [name, setName] = React.useState('')
+  const {greeting, error} = useGreeting(name)
+  useErrorHandler(error)
+
+  function handleSubmit(event) {
+    event.preventDefault()
+    const name = event.target.elements.name.value
+    setName(name)
+  }
+
+  return greeting ? (
+    <div>{greeting}</div>
+  ) : (
+    <form onSubmit={handleSubmit}>
+      <label>Name</label>
+      <input id="name" />
+      <button type="submit">get a greeting</button>
+    </form>
+  )
+}
+```
+
+In this case, if the `error` is ever set to a truthy value, then it will be
+propagated to the nearest error boundary.
+
+In either case, you could handle those errors like this:
+
+```javascript
+const ui = (
+  <ErrorBoundary FallbackComponent={ErrorFallback}>
+    <Greeting />
+  </ErrorBoundary>
+)
+```
+
+And now that'll handle your runtime errors as well as the async errors in the
+`fetchGreeting` or `useGreeting` code.
+
 ## Issues
 
 _Looking to contribute? Look for the [Good First Issue][good-first-issue]

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

@@ -2,10 +2,13 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
+var _inheritsLoose = require('@babel/runtime/helpers/inheritsLoose');
+var React = require('react');
 
-var _inheritsLoose = _interopDefault(require('@babel/runtime/helpers/inheritsLoose'));
-var React = _interopDefault(require('react'));
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var _inheritsLoose__default = /*#__PURE__*/_interopDefaultLegacy(_inheritsLoose);
+var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
 
 var changedArray = function (a, b) {
   if (a === void 0) {
@@ -27,7 +30,7 @@ var initialState = {
 };
 
 var ErrorBoundary = /*#__PURE__*/function (_React$Component) {
-  _inheritsLoose(ErrorBoundary, _React$Component);
+  _inheritsLoose__default['default'](ErrorBoundary, _React$Component);
 
   function ErrorBoundary() {
     var _this;
@@ -54,6 +57,12 @@ var ErrorBoundary = /*#__PURE__*/function (_React$Component) {
     return _this;
   }
 
+  ErrorBoundary.getDerivedStateFromError = function getDerivedStateFromError(error) {
+    return {
+      error: error
+    };
+  };
+
   var _proto = ErrorBoundary.prototype;
 
   _proto.componentDidCatch = function componentDidCatch(error, info) {
@@ -61,16 +70,17 @@ 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 == null ? void 0 : info.componentStack);
     this.setState({
-      error: error,
       info: info
     });
   };
 
   _proto.componentDidUpdate = function componentDidUpdate(prevProps) {
-    var error = this.state.error;
+    var _this$state = this.state,
+        error = _this$state.error,
+        info = _this$state.info;
     var resetKeys = this.props.resetKeys;
 
-    if (error !== null && changedArray(prevProps.resetKeys, resetKeys)) {
+    if (error !== null && info !== null && changedArray(prevProps.resetKeys, resetKeys)) {
       var _this$props$onResetKe, _this$props3;
 
       (_this$props$onResetKe = (_this$props3 = this.props).onResetKeysChange) == null ? void 0 : _this$props$onResetKe.call(_this$props3, prevProps.resetKeys, resetKeys);
@@ -79,27 +89,35 @@ var ErrorBoundary = /*#__PURE__*/function (_React$Component) {
   };
 
   _proto.render = function render() {
-    var _this$state = this.state,
-        error = _this$state.error,
-        info = _this$state.info;
+    var _this$state2 = this.state,
+        error = _this$state2.error,
+        info = _this$state2.info;
     var _this$props4 = this.props,
         fallbackRender = _this$props4.fallbackRender,
         FallbackComponent = _this$props4.FallbackComponent,
         fallback = _this$props4.fallback;
 
     if (error !== null) {
+      // we'll get a re-render with the error state in getDerivedStateFromError
+      // but we don't have the info yet, so just render null
+      // note that this won't be committed to the DOM thanks to our componentDidCatch
+      // so the user won't see a flash of nothing, so this works fine.
+      // the benefit of doing things this way rather than just putting both the
+      // error and info setState within componentDidCatch is we avoid re-rendering
+      // busted stuff: https://github.com/bvaughn/react-error-boundary/issues/66
+      if (!info) return null;
       var props = {
         componentStack: info == null ? void 0 : info.componentStack,
         error: error,
         resetErrorBoundary: this.resetErrorBoundary
       };
 
-      if ( /*#__PURE__*/React.isValidElement(fallback)) {
+      if ( /*#__PURE__*/React__default['default'].isValidElement(fallback)) {
         return fallback;
       } else if (typeof fallbackRender === 'function') {
         return fallbackRender(props);
-      } else if (typeof FallbackComponent === 'function') {
-        return /*#__PURE__*/React.createElement(FallbackComponent, props);
+      } else if (FallbackComponent) {
+        return /*#__PURE__*/React__default['default'].createElement(FallbackComponent, props);
       } else {
         throw new Error('react-error-boundary requires either a fallback, fallbackRender, or FallbackComponent prop');
       }
@@ -109,11 +127,11 @@ var ErrorBoundary = /*#__PURE__*/function (_React$Component) {
   };
 
   return ErrorBoundary;
-}(React.Component);
+}(React__default['default'].Component);
 
 function withErrorBoundary(Component, errorBoundaryProps) {
   function Wrapped(props) {
-    return /*#__PURE__*/React.createElement(ErrorBoundary, errorBoundaryProps, /*#__PURE__*/React.createElement(Component, props));
+    return /*#__PURE__*/React__default['default'].createElement(ErrorBoundary, errorBoundaryProps, /*#__PURE__*/React__default['default'].createElement(Component, props));
   } // Format for display in DevTools
 
 
@@ -122,5 +140,16 @@ function withErrorBoundary(Component, errorBoundaryProps) {
   return Wrapped;
 }
 
+function useErrorHandler(givenError) {
+  var _React$useState = React__default['default'].useState(null),
+      error = _React$useState[0],
+      setError = _React$useState[1];
+
+  if (givenError) throw givenError;
+  if (error) throw error;
+  return setError;
+}
+
 exports.ErrorBoundary = ErrorBoundary;
+exports.useErrorHandler = useErrorHandler;
 exports.withErrorBoundary = withErrorBoundary;

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

@@ -48,6 +48,12 @@ var ErrorBoundary = /*#__PURE__*/function (_React$Component) {
     return _this;
   }
 
+  ErrorBoundary.getDerivedStateFromError = function getDerivedStateFromError(error) {
+    return {
+      error: error
+    };
+  };
+
   var _proto = ErrorBoundary.prototype;
 
   _proto.componentDidCatch = function componentDidCatch(error, info) {
@@ -55,16 +61,17 @@ 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 == null ? void 0 : info.componentStack);
     this.setState({
-      error: error,
       info: info
     });
   };
 
   _proto.componentDidUpdate = function componentDidUpdate(prevProps) {
-    var error = this.state.error;
+    var _this$state = this.state,
+        error = _this$state.error,
+        info = _this$state.info;
     var resetKeys = this.props.resetKeys;
 
-    if (error !== null && changedArray(prevProps.resetKeys, resetKeys)) {
+    if (error !== null && info !== null && changedArray(prevProps.resetKeys, resetKeys)) {
       var _this$props$onResetKe, _this$props3;
 
       (_this$props$onResetKe = (_this$props3 = this.props).onResetKeysChange) == null ? void 0 : _this$props$onResetKe.call(_this$props3, prevProps.resetKeys, resetKeys);
@@ -73,15 +80,23 @@ var ErrorBoundary = /*#__PURE__*/function (_React$Component) {
   };
 
   _proto.render = function render() {
-    var _this$state = this.state,
-        error = _this$state.error,
-        info = _this$state.info;
+    var _this$state2 = this.state,
+        error = _this$state2.error,
+        info = _this$state2.info;
     var _this$props4 = this.props,
         fallbackRender = _this$props4.fallbackRender,
         FallbackComponent = _this$props4.FallbackComponent,
         fallback = _this$props4.fallback;
 
     if (error !== null) {
+      // we'll get a re-render with the error state in getDerivedStateFromError
+      // but we don't have the info yet, so just render null
+      // note that this won't be committed to the DOM thanks to our componentDidCatch
+      // so the user won't see a flash of nothing, so this works fine.
+      // the benefit of doing things this way rather than just putting both the
+      // error and info setState within componentDidCatch is we avoid re-rendering
+      // busted stuff: https://github.com/bvaughn/react-error-boundary/issues/66
+      if (!info) return null;
       var props = {
         componentStack: info == null ? void 0 : info.componentStack,
         error: error,
@@ -92,7 +107,7 @@ var ErrorBoundary = /*#__PURE__*/function (_React$Component) {
         return fallback;
       } else if (typeof fallbackRender === 'function') {
         return fallbackRender(props);
-      } else if (typeof FallbackComponent === 'function') {
+      } else if (FallbackComponent) {
         return /*#__PURE__*/React.createElement(FallbackComponent, props);
       } else {
         throw new Error('react-error-boundary requires either a fallback, fallbackRender, or FallbackComponent prop');
@@ -116,4 +131,14 @@ function withErrorBoundary(Component, errorBoundaryProps) {
   return Wrapped;
 }
 
-export { ErrorBoundary, withErrorBoundary };
+function useErrorHandler(givenError) {
+  var _React$useState = React.useState(null),
+      error = _React$useState[0],
+      setError = _React$useState[1];
+
+  if (givenError) throw givenError;
+  if (error) throw error;
+  return setError;
+}
+
+export { ErrorBoundary, useErrorHandler, withErrorBoundary };

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

@@ -1,10 +1,12 @@
 (function (global, factory) {
   typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('react')) :
   typeof define === 'function' && define.amd ? define(['exports', 'react'], factory) :
-  (global = global || self, factory(global.ReactErrorBoundary = {}, global.React));
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.ReactErrorBoundary = {}, global.React));
 }(this, (function (exports, React) { 'use strict';
 
-  React = React && Object.prototype.hasOwnProperty.call(React, 'default') ? React['default'] : React;
+  function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+  var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
 
   function _inheritsLoose(subClass, superClass) {
     subClass.prototype = Object.create(superClass.prototype);
@@ -59,6 +61,12 @@
       return _this;
     }
 
+    ErrorBoundary.getDerivedStateFromError = function getDerivedStateFromError(error) {
+      return {
+        error: error
+      };
+    };
+
     var _proto = ErrorBoundary.prototype;
 
     _proto.componentDidCatch = function componentDidCatch(error, info) {
@@ -66,16 +74,17 @@
 
       (_this$props$onError = (_this$props2 = this.props).onError) == null ? void 0 : _this$props$onError.call(_this$props2, error, info == null ? void 0 : info.componentStack);
       this.setState({
-        error: error,
         info: info
       });
     };
 
     _proto.componentDidUpdate = function componentDidUpdate(prevProps) {
-      var error = this.state.error;
+      var _this$state = this.state,
+          error = _this$state.error,
+          info = _this$state.info;
       var resetKeys = this.props.resetKeys;
 
-      if (error !== null && changedArray(prevProps.resetKeys, resetKeys)) {
+      if (error !== null && info !== null && changedArray(prevProps.resetKeys, resetKeys)) {
         var _this$props$onResetKe, _this$props3;
 
         (_this$props$onResetKe = (_this$props3 = this.props).onResetKeysChange) == null ? void 0 : _this$props$onResetKe.call(_this$props3, prevProps.resetKeys, resetKeys);
@@ -84,27 +93,35 @@
     };
 
     _proto.render = function render() {
-      var _this$state = this.state,
-          error = _this$state.error,
-          info = _this$state.info;
+      var _this$state2 = this.state,
+          error = _this$state2.error,
+          info = _this$state2.info;
       var _this$props4 = this.props,
           fallbackRender = _this$props4.fallbackRender,
           FallbackComponent = _this$props4.FallbackComponent,
           fallback = _this$props4.fallback;
 
       if (error !== null) {
+        // we'll get a re-render with the error state in getDerivedStateFromError
+        // but we don't have the info yet, so just render null
+        // note that this won't be committed to the DOM thanks to our componentDidCatch
+        // so the user won't see a flash of nothing, so this works fine.
+        // the benefit of doing things this way rather than just putting both the
+        // error and info setState within componentDidCatch is we avoid re-rendering
+        // busted stuff: https://github.com/bvaughn/react-error-boundary/issues/66
+        if (!info) return null;
         var props = {
           componentStack: info == null ? void 0 : info.componentStack,
           error: error,
           resetErrorBoundary: this.resetErrorBoundary
         };
 
-        if ( /*#__PURE__*/React.isValidElement(fallback)) {
+        if ( /*#__PURE__*/React__default['default'].isValidElement(fallback)) {
           return fallback;
         } else if (typeof fallbackRender === 'function') {
           return fallbackRender(props);
-        } else if (typeof FallbackComponent === 'function') {
-          return /*#__PURE__*/React.createElement(FallbackComponent, props);
+        } else if (FallbackComponent) {
+          return /*#__PURE__*/React__default['default'].createElement(FallbackComponent, props);
         } else {
           throw new Error('react-error-boundary requires either a fallback, fallbackRender, or FallbackComponent prop');
         }
@@ -114,11 +131,11 @@
     };
 
     return ErrorBoundary;
-  }(React.Component);
+  }(React__default['default'].Component);
 
   function withErrorBoundary(Component, errorBoundaryProps) {
     function Wrapped(props) {
-      return /*#__PURE__*/React.createElement(ErrorBoundary, errorBoundaryProps, /*#__PURE__*/React.createElement(Component, props));
+      return /*#__PURE__*/React__default['default'].createElement(ErrorBoundary, errorBoundaryProps, /*#__PURE__*/React__default['default'].createElement(Component, props));
     } // Format for display in DevTools
 
 
@@ -127,7 +144,18 @@
     return Wrapped;
   }
 
+  function useErrorHandler(givenError) {
+    var _React$useState = React__default['default'].useState(null),
+        error = _React$useState[0],
+        setError = _React$useState[1];
+
+    if (givenError) throw givenError;
+    if (error) throw error;
+    return setError;
+  }
+
   exports.ErrorBoundary = ErrorBoundary;
+  exports.useErrorHandler = useErrorHandler;
   exports.withErrorBoundary = withErrorBoundary;
 
   Object.defineProperty(exports, '__esModule', { value: true });

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, info: null}\nclass ErrorBoundary extends React.Component {\n  state = initialState\n  resetErrorBoundary = (...args) => {\n    this.props.onReset?.(...args)\n    this.setState(initialState)\n  }\n\n  componentDidCatch(error, info) {\n    this.props.onError?.(error, info?.componentStack)\n    this.setState({error, info})\n  }\n\n  componentDidUpdate(prevProps) {\n    const {error} = this.state\n    const {resetKeys} = this.props\n    if (error !== null && changedArray(prevProps.resetKeys, resetKeys)) {\n      this.props.onResetKeysChange?.(prevProps.resetKeys, resetKeys)\n      this.setState(initialState)\n    }\n  }\n\n  render() {\n    const {error, info} = this.state\n    const {fallbackRender, FallbackComponent, fallback} = this.props\n\n    if (error !== null) {\n      const props = {\n        componentStack: info?.componentStack,\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 (typeof FallbackComponent === 'function') {\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\nexport {ErrorBoundary, withErrorBoundary}\n"],"names":["_inheritsLoose","subClass","superClass","prototype","Object","create","constructor","__proto__","changedArray","a","b","length","some","item","index","is","initialState","error","info","ErrorBoundary","state","resetErrorBoundary","args","props","onReset","setState","componentDidCatch","onError","componentStack","componentDidUpdate","prevProps","resetKeys","onResetKeysChange","render","fallbackRender","FallbackComponent","fallback","React","isValidElement","Error","children","Component","withErrorBoundary","errorBoundaryProps","Wrapped","name","displayName"],"mappings":"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"}
+{"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, info: null}\nclass ErrorBoundary extends React.Component {\n  static getDerivedStateFromError(error) {\n    return {error}\n  }\n\n  state = initialState\n  resetErrorBoundary = (...args) => {\n    this.props.onReset?.(...args)\n    this.setState(initialState)\n  }\n\n  componentDidCatch(error, info) {\n    this.props.onError?.(error, info?.componentStack)\n    this.setState({info})\n  }\n\n  componentDidUpdate(prevProps) {\n    const {error, info} = this.state\n    const {resetKeys} = this.props\n    if (\n      error !== null &&\n      info !== null &&\n      changedArray(prevProps.resetKeys, resetKeys)\n    ) {\n      this.props.onResetKeysChange?.(prevProps.resetKeys, resetKeys)\n      this.setState(initialState)\n    }\n  }\n\n  render() {\n    const {error, info} = this.state\n    const {fallbackRender, FallbackComponent, fallback} = this.props\n\n    if (error !== null) {\n      // we'll get a re-render with the error state in getDerivedStateFromError\n      // but we don't have the info yet, so just render null\n      // note that this won't be committed to the DOM thanks to our componentDidCatch\n      // so the user won't see a flash of nothing, so this works fine.\n      // the benefit of doing things this way rather than just putting both the\n      // error and info setState within componentDidCatch is we avoid re-rendering\n      // busted stuff: https://github.com/bvaughn/react-error-boundary/issues/66\n      if (!info) return null\n\n      const props = {\n        componentStack: info?.componentStack,\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","info","ErrorBoundary","state","resetErrorBoundary","args","props","onReset","setState","getDerivedStateFromError","componentDidCatch","onError","componentStack","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.js

@@ -1,2 +1,2 @@
-!function(e,r){"object"==typeof exports&&"undefined"!=typeof module?r(exports,require("react")):"function"==typeof define&&define.amd?define(["exports","react"],r):r((e=e||self).ReactErrorBoundary={},e.React)}(this,(function(e,r){"use strict";r=r&&Object.prototype.hasOwnProperty.call(r,"default")?r.default:r;var t={error:null,info:null},n=function(e){var n,o;function a(){for(var r,n=arguments.length,o=new Array(n),a=0;a<n;a++)o[a]=arguments[a];return(r=e.call.apply(e,[this].concat(o))||this).state=t,r.resetErrorBoundary=function(){for(var e,n=arguments.length,o=new Array(n),a=0;a<n;a++)o[a]=arguments[a];null==r.props.onReset||(e=r.props).onReset.apply(e,o),r.setState(t)},r}o=e,(n=a).prototype=Object.create(o.prototype),n.prototype.constructor=n,n.__proto__=o;var l=a.prototype;return l.componentDidCatch=function(e,r){var t,n;null==(t=(n=this.props).onError)||t.call(n,e,null==r?void 0:r.componentStack),this.setState({error:e,info:r})},l.componentDidUpdate=function(e){var r,n,o,a,l=this.state.error,i=this.props.resetKeys;null!==l&&(void 0===(o=e.resetKeys)&&(o=[]),void 0===(a=i)&&(a=[]),o.length!==a.length||o.some((function(e,r){return!Object.is(e,a[r])})))&&(null==(r=(n=this.props).onResetKeysChange)||r.call(n,e.resetKeys,i),this.setState(t))},l.render=function(){var e=this.state,t=e.error,n=e.info,o=this.props,a=o.fallbackRender,l=o.FallbackComponent,i=o.fallback;if(null!==t){var s={componentStack:null==n?void 0:n.componentStack,error:t,resetErrorBoundary:this.resetErrorBoundary};if(r.isValidElement(i))return i;if("function"==typeof a)return a(s);if("function"==typeof l)return r.createElement(l,s);throw new Error("react-error-boundary requires either a fallback, fallbackRender, or FallbackComponent prop")}return this.props.children},a}(r.Component);e.ErrorBoundary=n,e.withErrorBoundary=function(e,t){function o(o){return r.createElement(n,t,r.createElement(e,o))}var a=e.displayName||e.name||"Unknown";return o.displayName="withErrorBoundary("+a+")",o},Object.defineProperty(e,"__esModule",{value:!0})}));
+!function(e,r){"object"==typeof exports&&"undefined"!=typeof module?r(exports,require("react")):"function"==typeof define&&define.amd?define(["exports","react"],r):r((e="undefined"!=typeof globalThis?globalThis:e||self).ReactErrorBoundary={},e.React)}(this,(function(e,r){"use strict";function t(e){return e&&"object"==typeof e&&"default"in e?e:{default:e}}var n=t(r);var o={error:null,info:null},a=function(e){var r,t;function a(){for(var r,t=arguments.length,n=new Array(t),a=0;a<t;a++)n[a]=arguments[a];return(r=e.call.apply(e,[this].concat(n))||this).state=o,r.resetErrorBoundary=function(){for(var e,t=arguments.length,n=new Array(t),a=0;a<t;a++)n[a]=arguments[a];null==r.props.onReset||(e=r.props).onReset.apply(e,n),r.setState(o)},r}t=e,(r=a).prototype=Object.create(t.prototype),r.prototype.constructor=r,r.__proto__=t,a.getDerivedStateFromError=function(e){return{error:e}};var l=a.prototype;return l.componentDidCatch=function(e,r){var t,n;null==(t=(n=this.props).onError)||t.call(n,e,null==r?void 0:r.componentStack),this.setState({info:r})},l.componentDidUpdate=function(e){var r,t,n,a,l=this.state,i=l.error,u=l.info,s=this.props.resetKeys;null!==i&&null!==u&&(void 0===(n=e.resetKeys)&&(n=[]),void 0===(a=s)&&(a=[]),n.length!==a.length||n.some((function(e,r){return!Object.is(e,a[r])})))&&(null==(r=(t=this.props).onResetKeysChange)||r.call(t,e.resetKeys,s),this.setState(o))},l.render=function(){var e=this.state,r=e.error,t=e.info,o=this.props,a=o.fallbackRender,l=o.FallbackComponent,i=o.fallback;if(null!==r){if(!t)return null;var u={componentStack:null==t?void 0:t.componentStack,error:r,resetErrorBoundary:this.resetErrorBoundary};if(n.default.isValidElement(i))return i;if("function"==typeof a)return a(u);if(l)return n.default.createElement(l,u);throw new Error("react-error-boundary requires either a fallback, fallbackRender, or FallbackComponent prop")}return this.props.children},a}(n.default.Component);e.ErrorBoundary=a,e.useErrorHandler=function(e){var r=n.default.useState(null),t=r[0],o=r[1];if(e)throw e;if(t)throw t;return o},e.withErrorBoundary=function(e,r){function t(t){return n.default.createElement(a,r,n.default.createElement(e,t))}var o=e.displayName||e.name||"Unknown";return t.displayName="withErrorBoundary("+o+")",t},Object.defineProperty(e,"__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, info: null}\nclass ErrorBoundary extends React.Component {\n  state = initialState\n  resetErrorBoundary = (...args) => {\n    this.props.onReset?.(...args)\n    this.setState(initialState)\n  }\n\n  componentDidCatch(error, info) {\n    this.props.onError?.(error, info?.componentStack)\n    this.setState({error, info})\n  }\n\n  componentDidUpdate(prevProps) {\n    const {error} = this.state\n    const {resetKeys} = this.props\n    if (error !== null && changedArray(prevProps.resetKeys, resetKeys)) {\n      this.props.onResetKeysChange?.(prevProps.resetKeys, resetKeys)\n      this.setState(initialState)\n    }\n  }\n\n  render() {\n    const {error, info} = this.state\n    const {fallbackRender, FallbackComponent, fallback} = this.props\n\n    if (error !== null) {\n      const props = {\n        componentStack: info?.componentStack,\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 (typeof FallbackComponent === 'function') {\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\nexport {ErrorBoundary, withErrorBoundary}\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","info","ErrorBoundary","subClass","superClass","state","resetErrorBoundary","args","props","onReset","setState","prototype","Object","create","constructor","__proto__","componentDidCatch","onError","componentStack","componentDidUpdate","prevProps","a","b","this","resetKeys","length","some","item","index","is","onResetKeysChange","render","fallbackRender","FallbackComponent","fallback","React","isValidElement","Error","children","Component","errorBoundaryProps","Wrapped","name","displayName"],"mappings":"sTAEA,IAGMA,EAAe,CAACC,MAAO,KAAMC,KAAM,MACnCC,cCNS,IAAwBC,EAAUC,0IDO/CC,MAAQN,IACRO,mBAAqB,wCAAIC,2BAAAA,0BAClBC,MAAMC,cAAND,OAAMC,gBAAaF,KACnBG,SAASX,MCV+BK,KAAVD,KAC5BQ,UAAYC,OAAOC,OAAOT,EAAWO,WAC9CR,EAASQ,UAAUG,YAAcX,EACjCA,EAASY,UAAYX,6BDUrBY,kBAAA,SAAkBhB,EAAOC,4BAClBO,OAAMS,mBAAUjB,QAAOC,SAAAA,EAAMiB,qBAC7BR,SAAS,CAACV,MAAAA,EAAOC,KAAAA,OAGxBkB,mBAAA,SAAmBC,WAhBCC,EAAQC,EAiBnBtB,EAASuB,KAAKlB,MAAdL,MACAwB,EAAaD,KAAKf,MAAlBgB,UACO,OAAVxB,cAnBcqB,EAmBiBD,EAAUI,aAnB3BH,EAAI,cAAIC,EAmB8BE,KAnB9BF,EAAI,IAChCD,EAAEI,SAAWH,EAAEG,QAAUJ,EAAEK,MAAK,SAACC,EAAMC,UAAWhB,OAAOiB,GAAGF,EAAML,EAAEM,2BAmB3DpB,OAAMsB,6BAAoBV,EAAUI,UAAWA,QAC/Cd,SAASX,OAIlBgC,OAAA,iBACwBR,KAAKlB,MAApBL,IAAAA,MAAOC,IAAAA,OACwCsB,KAAKf,MAApDwB,IAAAA,eAAgBC,IAAAA,kBAAmBC,IAAAA,YAE5B,OAAVlC,EAAgB,KACZQ,EAAQ,CACZU,qBAAgBjB,SAAAA,EAAMiB,eACtBlB,MAAAA,EACAM,mBAAoBiB,KAAKjB,uBAEvB6B,EAAMC,eAAeF,UAChBA,EACF,GAA8B,mBAAnBF,SACTA,EAAexB,GACjB,GAAiC,mBAAtByB,SACTE,gBAACF,EAAsBzB,SAExB,IAAI6B,MACR,qGAKCd,KAAKf,MAAM8B,aA5CMH,EAAMI,iDAgDlC,SAA2BA,EAAWC,YAC3BC,EAAQjC,UAEb2B,gBAACjC,EAAkBsC,EACjBL,gBAACI,EAAc/B,QAMfkC,EAAOH,EAAUI,aAAeJ,EAAUG,MAAQ,iBACxDD,EAAQE,iCAAmCD,MAEpCD"}
+{"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, info: null}\nclass ErrorBoundary extends React.Component {\n  static getDerivedStateFromError(error) {\n    return {error}\n  }\n\n  state = initialState\n  resetErrorBoundary = (...args) => {\n    this.props.onReset?.(...args)\n    this.setState(initialState)\n  }\n\n  componentDidCatch(error, info) {\n    this.props.onError?.(error, info?.componentStack)\n    this.setState({info})\n  }\n\n  componentDidUpdate(prevProps) {\n    const {error, info} = this.state\n    const {resetKeys} = this.props\n    if (\n      error !== null &&\n      info !== null &&\n      changedArray(prevProps.resetKeys, resetKeys)\n    ) {\n      this.props.onResetKeysChange?.(prevProps.resetKeys, resetKeys)\n      this.setState(initialState)\n    }\n  }\n\n  render() {\n    const {error, info} = this.state\n    const {fallbackRender, FallbackComponent, fallback} = this.props\n\n    if (error !== null) {\n      // we'll get a re-render with the error state in getDerivedStateFromError\n      // but we don't have the info yet, so just render null\n      // note that this won't be committed to the DOM thanks to our componentDidCatch\n      // so the user won't see a flash of nothing, so this works fine.\n      // the benefit of doing things this way rather than just putting both the\n      // error and info setState within componentDidCatch is we avoid re-rendering\n      // busted stuff: https://github.com/bvaughn/react-error-boundary/issues/66\n      if (!info) return null\n\n      const props = {\n        componentStack: info?.componentStack,\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","info","ErrorBoundary","subClass","superClass","state","resetErrorBoundary","args","props","onReset","setState","prototype","Object","create","constructor","__proto__","getDerivedStateFromError","componentDidCatch","onError","componentStack","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,KAAMC,KAAM,MACnCC,cCNS,IAAwBC,EAAUC,0IDW/CC,MAAQN,IACRO,mBAAqB,wCAAIC,2BAAAA,0BAClBC,MAAMC,cAAND,OAAMC,gBAAaF,KACnBG,SAASX,MCd+BK,KAAVD,KAC5BQ,UAAYC,OAAOC,OAAOT,EAAWO,WAC9CR,EAASQ,UAAUG,YAAcX,EACjCA,EAASY,UAAYX,IDIdY,yBAAP,SAAgChB,SACvB,CAACA,MAAAA,+BASViB,kBAAA,SAAkBjB,EAAOC,4BAClBO,OAAMU,mBAAUlB,QAAOC,SAAAA,EAAMkB,qBAC7BT,SAAS,CAACT,KAAAA,OAGjBmB,mBAAA,SAAmBC,WApBCC,EAAQC,IAqBJC,KAAKnB,MAApBL,IAAAA,MAAOC,IAAAA,KACPwB,EAAaD,KAAKhB,MAAlBiB,UAEK,OAAVzB,GACS,OAATC,cAzBgBqB,EA0BHD,EAAUI,aA1BPH,EAAI,cAAIC,EA0BUE,KA1BVF,EAAI,IAChCD,EAAEI,SAAWH,EAAEG,QAAUJ,EAAEK,MAAK,SAACC,EAAMC,UAAWjB,OAAOkB,GAAGF,EAAML,EAAEM,2BA2B3DrB,OAAMuB,6BAAoBV,EAAUI,UAAWA,QAC/Cf,SAASX,OAIlBiC,OAAA,iBACwBR,KAAKnB,MAApBL,IAAAA,MAAOC,IAAAA,OACwCuB,KAAKhB,MAApDyB,IAAAA,eAAgBC,IAAAA,kBAAmBC,IAAAA,YAE5B,OAAVnC,EAAgB,KAQbC,EAAM,OAAO,SAEZO,EAAQ,CACZW,qBAAgBlB,SAAAA,EAAMkB,eACtBnB,MAAAA,EACAM,mBAAoBkB,KAAKlB,uBAEvB8B,UAAMC,eAAeF,UAChBA,EACF,GAA8B,mBAAnBF,SACTA,EAAezB,GACjB,GAAI0B,SACFE,wBAACF,EAAsB1B,SAExB,IAAI8B,MACR,qGAKCd,KAAKhB,MAAM+B,aA7DMH,UAAMI,+CAiFlC,SAAyBC,SACGL,UAAMM,SAAS,MAAlC1C,OAAO2C,UACVF,EAAY,MAAMA,KAClBzC,EAAO,MAAMA,SACV2C,uBApBT,SAA2BH,EAAWI,YAC3BC,EAAQrC,UAEb4B,wBAAClC,EAAkB0C,EACjBR,wBAACI,EAAchC,QAMfsC,EAAON,EAAUO,aAAeP,EAAUM,MAAQ,iBACxDD,EAAQE,iCAAmCD,MAEpCD"}

package/index.d.ts

@@ -41,3 +41,7 @@ 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>>

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "react-error-boundary",
-  "version": "2.2.2",
+  "version": "2.3.2",
   "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",
   "sideEffects": false,
   "keywords": [
     "react",
@@ -38,25 +39,26 @@
     "validate": "kcd-scripts validate"
   },
   "dependencies": {
-    "@babel/runtime": "^7.9.6"
+    "@babel/runtime": "^7.11.2"
   },
   "devDependencies": {
-    "@testing-library/jest-dom": "^5.5.0",
-    "@testing-library/react": "^10.0.4",
-    "@testing-library/user-event": "^10.1.0",
-    "kcd-scripts": "^5.11.1",
+    "@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": "^3.8.3"
+    "typescript": "^4.0.2"
   },
   "peerDependencies": {
-    "react": ">=16.0.0"
+    "react": ">=16.13.1"
   },
   "eslintConfig": {
     "extends": "./node_modules/kcd-scripts/eslint.js",
     "rules": {
       "react/prop-types": "off",
-      "react/no-did-update-set-state": "off"
+      "react/no-did-update-set-state": "off",
+      "babel/no-unused-expressions": "off"
     }
   }
 }