react-error-boundary 3.1.0 → 3.1.4

package/README.md

@@ -43,7 +43,7 @@ react-error-boundary
   - [Error Recovery](#error-recovery)
 - [API](#api)
   - [`ErrorBoundary` props](#errorboundary-props)
-  - [`useErrorHandler(error?: Error)`](#useerrorhandlererror-error)
+  - [`useErrorHandler(error?: unknown)`](#useerrorhandlererror-unknown)
 - [Issues](#issues)
   - [🐛 Bugs](#-bugs)
   - [💡 Feature Requests](#-feature-requests)
@@ -289,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
@@ -316,6 +316,8 @@ There are two ways to use `useErrorHandler`:
 Here's an example:
 
 ```javascript
+import { useErrorHandler } from 'react-error-boundary'
+
 function Greeting() {
   const [greeting, setGreeting] = React.useState(null)
   const handleError = useErrorHandler()
@@ -358,6 +360,8 @@ function handleSubmit(event) {
 Alternatively, let's say you're using a hook that gives you the error:
 
 ```javascript
+import { useErrorHandler } from 'react-error-boundary'
+
 function Greeting() {
   const [name, setName] = React.useState('')
   const {greeting, error} = useGreeting(name)

package/dist/index.d.ts

@@ -10,7 +10,9 @@ interface ErrorBoundaryPropsWithComponent {
         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 {
@@ -20,6 +22,8 @@ interface ErrorBoundaryPropsWithRender {
         componentStack: string;
     }) => void;
     resetKeys?: Array<unknown>;
+    fallback?: never;
+    FallbackComponent?: never;
     fallbackRender: typeof FallbackRender;
 }
 interface ErrorBoundaryPropsWithFallback {
@@ -30,6 +34,8 @@ interface ErrorBoundaryPropsWithFallback {
     }) => 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 = {
@@ -40,14 +46,13 @@ declare class ErrorBoundary extends React.Component<React.PropsWithRef<React.Pro
         error: Error;
     };
     state: ErrorBoundaryState;
-    updatedWithError: boolean;
     resetErrorBoundary: (...args: Array<unknown>) => void;
     reset(): void;
     componentDidCatch(error: Error, info: React.ErrorInfo): void;
-    componentDidUpdate(prevProps: ErrorBoundaryProps): void;
-    render(): {} | null | undefined;
+    componentDidUpdate(prevProps: ErrorBoundaryProps, prevState: ErrorBoundaryState): void;
+    render(): React.ReactNode;
 }
 declare function withErrorBoundary<P>(Component: React.ComponentType<P>, errorBoundaryProps: ErrorBoundaryProps): React.ComponentType<P>;
-declare function useErrorHandler<P = Error>(givenError?: P | null | undefined): React.Dispatch<React.SetStateAction<P | null>>;
+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

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

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

@@ -7,9 +7,28 @@ 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__namespace = /*#__PURE__*/_interopNamespace(React);
 
-var changedArray = function (a, b) {
+var changedArray = function changedArray(a, b) {
   if (a === void 0) {
     a = [];
   }
@@ -28,7 +47,7 @@ var initialState = {
 };
 
 var ErrorBoundary = /*#__PURE__*/function (_React$Component) {
-  _inheritsLoose__default['default'](ErrorBoundary, _React$Component);
+  _inheritsLoose__default["default"](ErrorBoundary, _React$Component);
 
   function ErrorBoundary() {
     var _this;
@@ -39,7 +58,6 @@ var ErrorBoundary = /*#__PURE__*/function (_React$Component) {
 
     _this = _React$Component.call.apply(_React$Component, [this].concat(_args)) || this;
     _this.state = initialState;
-    _this.updatedWithError = false;
 
     _this.resetErrorBoundary = function () {
       var _this$props;
@@ -65,7 +83,6 @@ var ErrorBoundary = /*#__PURE__*/function (_React$Component) {
   var _proto = ErrorBoundary.prototype;
 
   _proto.reset = function reset() {
-    this.updatedWithError = false;
     this.setState(initialState);
   };
 
@@ -75,7 +92,7 @@ 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.componentDidUpdate = function componentDidUpdate(prevProps) {
+  _proto.componentDidUpdate = function componentDidUpdate(prevProps, prevState) {
     var error = this.state.error;
     var resetKeys = this.props.resetKeys; // There's an edge case where if the thing that triggered the error
     // happens to *also* be in the resetKeys array, we'd end up resetting
@@ -84,12 +101,7 @@ var ErrorBoundary = /*#__PURE__*/function (_React$Component) {
     // So we make sure that we don't check the resetKeys on the first call
     // of cDU after the error is set
 
-    if (error !== null && !this.updatedWithError) {
-      this.updatedWithError = true;
-      return;
-    }
-
-    if (error !== null && changedArray(prevProps.resetKeys, resetKeys)) {
+    if (error !== null && prevState.error !== 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);
@@ -98,8 +110,7 @@ var ErrorBoundary = /*#__PURE__*/function (_React$Component) {
   };
 
   _proto.render = function render() {
-    var error = this.state.error; // @ts-expect-error ts(2339) (at least one of these will be defined though, and we check for their existance)
-
+    var error = this.state.error;
     var _this$props4 = this.props,
         fallbackRender = _this$props4.fallbackRender,
         FallbackComponent = _this$props4.FallbackComponent,
@@ -111,12 +122,12 @@ var ErrorBoundary = /*#__PURE__*/function (_React$Component) {
         resetErrorBoundary: this.resetErrorBoundary
       };
 
-      if ( /*#__PURE__*/React.isValidElement(fallback)) {
+      if ( /*#__PURE__*/React__namespace.isValidElement(fallback)) {
         return fallback;
       } else if (typeof fallbackRender === 'function') {
         return fallbackRender(_props);
       } else if (FallbackComponent) {
-        return /*#__PURE__*/React.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,11 +137,11 @@ var ErrorBoundary = /*#__PURE__*/function (_React$Component) {
   };
 
   return ErrorBoundary;
-}(React.Component);
+}(React__namespace.Component);
 
 function withErrorBoundary(Component, errorBoundaryProps) {
-  var Wrapped = function (props) {
-    return /*#__PURE__*/React.createElement(ErrorBoundary, errorBoundaryProps, /*#__PURE__*/React.createElement(Component, props));
+  var Wrapped = function Wrapped(props) {
+    return /*#__PURE__*/React__namespace.createElement(ErrorBoundary, errorBoundaryProps, /*#__PURE__*/React__namespace.createElement(Component, props));
   }; // Format for display in DevTools
 
 
@@ -140,16 +151,17 @@ function withErrorBoundary(Component, errorBoundaryProps) {
 }
 
 function useErrorHandler(givenError) {
-  var _React$useState = React.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/sort-type-union-intersection-members: "off",
   @typescript-eslint/no-throw-literal: "off",
   @typescript-eslint/prefer-nullish-coalescing: "off"
 */

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

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

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

@@ -1,7 +1,7 @@
 import _inheritsLoose from '@babel/runtime/helpers/esm/inheritsLoose';
-import { isValidElement, createElement, Component, useState } from 'react';
+import * as React from 'react';
 
-var changedArray = function (a, b) {
+var changedArray = function changedArray(a, b) {
   if (a === void 0) {
     a = [];
   }
@@ -31,7 +31,6 @@ var ErrorBoundary = /*#__PURE__*/function (_React$Component) {
 
     _this = _React$Component.call.apply(_React$Component, [this].concat(_args)) || this;
     _this.state = initialState;
-    _this.updatedWithError = false;
 
     _this.resetErrorBoundary = function () {
       var _this$props;
@@ -57,7 +56,6 @@ var ErrorBoundary = /*#__PURE__*/function (_React$Component) {
   var _proto = ErrorBoundary.prototype;
 
   _proto.reset = function reset() {
-    this.updatedWithError = false;
     this.setState(initialState);
   };
 
@@ -67,7 +65,7 @@ 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.componentDidUpdate = function componentDidUpdate(prevProps) {
+  _proto.componentDidUpdate = function componentDidUpdate(prevProps, prevState) {
     var error = this.state.error;
     var resetKeys = this.props.resetKeys; // There's an edge case where if the thing that triggered the error
     // happens to *also* be in the resetKeys array, we'd end up resetting
@@ -76,12 +74,7 @@ var ErrorBoundary = /*#__PURE__*/function (_React$Component) {
     // So we make sure that we don't check the resetKeys on the first call
     // of cDU after the error is set
 
-    if (error !== null && !this.updatedWithError) {
-      this.updatedWithError = true;
-      return;
-    }
-
-    if (error !== null && changedArray(prevProps.resetKeys, resetKeys)) {
+    if (error !== null && prevState.error !== 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);
@@ -90,8 +83,7 @@ var ErrorBoundary = /*#__PURE__*/function (_React$Component) {
   };
 
   _proto.render = function render() {
-    var error = this.state.error; // @ts-expect-error ts(2339) (at least one of these will be defined though, and we check for their existance)
-
+    var error = this.state.error;
     var _this$props4 = this.props,
         fallbackRender = _this$props4.fallbackRender,
         FallbackComponent = _this$props4.FallbackComponent,
@@ -103,12 +95,12 @@ var ErrorBoundary = /*#__PURE__*/function (_React$Component) {
         resetErrorBoundary: this.resetErrorBoundary
       };
 
-      if ( /*#__PURE__*/isValidElement(fallback)) {
+      if ( /*#__PURE__*/React.isValidElement(fallback)) {
         return fallback;
       } else if (typeof fallbackRender === 'function') {
         return fallbackRender(_props);
       } else if (FallbackComponent) {
-        return /*#__PURE__*/createElement(FallbackComponent, _props);
+        return /*#__PURE__*/React.createElement(FallbackComponent, _props);
       } else {
         throw new Error('react-error-boundary requires either a fallback, fallbackRender, or FallbackComponent prop');
       }
@@ -118,11 +110,11 @@ var ErrorBoundary = /*#__PURE__*/function (_React$Component) {
   };
 
   return ErrorBoundary;
-}(Component);
+}(React.Component);
 
 function withErrorBoundary(Component, errorBoundaryProps) {
-  var Wrapped = function (props) {
-    return /*#__PURE__*/createElement(ErrorBoundary, errorBoundaryProps, /*#__PURE__*/createElement(Component, props));
+  var Wrapped = function Wrapped(props) {
+    return /*#__PURE__*/React.createElement(ErrorBoundary, errorBoundaryProps, /*#__PURE__*/React.createElement(Component, props));
   }; // Format for display in DevTools
 
 
@@ -132,16 +124,17 @@ function withErrorBoundary(Component, errorBoundaryProps) {
 }
 
 function useErrorHandler(givenError) {
-  var _React$useState = useState(null),
+  var _React$useState = React.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/sort-type-union-intersection-members: "off",
   @typescript-eslint/no-throw-literal: "off",
   @typescript-eslint/prefer-nullish-coalescing: "off"
 */

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

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

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

@@ -2,15 +2,44 @@
   typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('react')) :
   typeof define === 'function' && define.amd ? define(['exports', 'react'], factory) :
   (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.ReactErrorBoundary = {}, global.React));
-}(this, (function (exports, React) { 'use strict';
+})(this, (function (exports, React) { 'use strict';
+
+  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);
+
+  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 = [];
     }
@@ -40,7 +69,6 @@
 
       _this = _React$Component.call.apply(_React$Component, [this].concat(_args)) || this;
       _this.state = initialState;
-      _this.updatedWithError = false;
 
       _this.resetErrorBoundary = function () {
         var _this$props;
@@ -66,7 +94,6 @@
     var _proto = ErrorBoundary.prototype;
 
     _proto.reset = function reset() {
-      this.updatedWithError = false;
       this.setState(initialState);
     };
 
@@ -76,7 +103,7 @@
       (_this$props$onError = (_this$props2 = this.props).onError) == null ? void 0 : _this$props$onError.call(_this$props2, error, info);
     };
 
-    _proto.componentDidUpdate = function componentDidUpdate(prevProps) {
+    _proto.componentDidUpdate = function componentDidUpdate(prevProps, prevState) {
       var error = this.state.error;
       var resetKeys = this.props.resetKeys; // There's an edge case where if the thing that triggered the error
       // happens to *also* be in the resetKeys array, we'd end up resetting
@@ -85,12 +112,7 @@
       // So we make sure that we don't check the resetKeys on the first call
       // of cDU after the error is set
 
-      if (error !== null && !this.updatedWithError) {
-        this.updatedWithError = true;
-        return;
-      }
-
-      if (error !== null && changedArray(prevProps.resetKeys, resetKeys)) {
+      if (error !== null && prevState.error !== 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);
@@ -99,8 +121,7 @@
     };
 
     _proto.render = function render() {
-      var error = this.state.error; // @ts-expect-error ts(2339) (at least one of these will be defined though, and we check for their existance)
-
+      var error = this.state.error;
       var _this$props4 = this.props,
           fallbackRender = _this$props4.fallbackRender,
           FallbackComponent = _this$props4.FallbackComponent,
@@ -112,12 +133,12 @@
           resetErrorBoundary: this.resetErrorBoundary
         };
 
-        if ( /*#__PURE__*/React.isValidElement(fallback)) {
+        if ( /*#__PURE__*/React__namespace.isValidElement(fallback)) {
           return fallback;
         } else if (typeof fallbackRender === 'function') {
           return fallbackRender(_props);
         } else if (FallbackComponent) {
-          return /*#__PURE__*/React.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');
         }
@@ -127,11 +148,11 @@
     };
 
     return ErrorBoundary;
-  }(React.Component);
+  }(React__namespace.Component);
 
   function withErrorBoundary(Component, errorBoundaryProps) {
-    var Wrapped = function (props) {
-      return /*#__PURE__*/React.createElement(ErrorBoundary, errorBoundaryProps, /*#__PURE__*/React.createElement(Component, props));
+    var Wrapped = function Wrapped(props) {
+      return /*#__PURE__*/React__namespace.createElement(ErrorBoundary, errorBoundaryProps, /*#__PURE__*/React__namespace.createElement(Component, props));
     }; // Format for display in DevTools
 
 
@@ -141,16 +162,17 @@
   }
 
   function useErrorHandler(givenError) {
-    var _React$useState = React.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/sort-type-union-intersection-members: "off",
     @typescript-eslint/no-throw-literal: "off",
     @typescript-eslint/prefer-nullish-coalescing: "off"
   */
@@ -161,5 +183,5 @@
 
   Object.defineProperty(exports, '__esModule', { value: true });
 
-})));
+}));
 //# sourceMappingURL=react-error-boundary.umd.js.map

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.tsx"],"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 * 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  FallbackComponent: React.ComponentType<FallbackProps>\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  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}\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  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    // @ts-expect-error ts(2339) (at least one of these will be defined though, and we check for their existance)\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 as typeof 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<P = Error>(\n  givenError?: P | null | undefined,\n): React.Dispatch<React.SetStateAction<P | null>> {\n  const [error, setError] = React.useState<P | null>(null)\n  if (givenError) throw givenError\n  if (error) 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":["_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","React.createElement","Error","children","withErrorBoundary","Component","errorBoundaryProps","Wrapped","name","displayName","useErrorHandler","givenError","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  resetErrorBoundary = (...args: Array<unknown>) => {\n    this.props.onReset?.(...args)\n    this.reset()\n  }\n\n  reset() {\n    this.setState(initialState)\n  }\n\n  componentDidCatch(error: Error, info: React.ErrorInfo) {\n    this.props.onError?.(error, info)\n  }\n\n  componentDidUpdate(\n    prevProps: ErrorBoundaryProps,\n    prevState: ErrorBoundaryState,\n  ) {\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\n    if (\n      error !== null &&\n      prevState.error !== null &&\n      changedArray(prevProps.resetKeys, resetKeys)\n    ) {\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/sort-type-union-intersection-members: \"off\",\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","resetErrorBoundary","args","props","onReset","reset","getDerivedStateFromError","setState","componentDidCatch","info","onError","componentDidUpdate","prevProps","prevState","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

@@ -1 +1 @@
-export * from ".";
+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";var t={error:null},o=function(r){var o,n;function a(){for(var e,o=arguments.length,n=new Array(o),a=0;a<o;a++)n[a]=arguments[a];return(e=r.call.apply(r,[this].concat(n))||this).state=t,e.updatedWithError=!1,e.resetErrorBoundary=function(){for(var r,t=arguments.length,o=new Array(t),n=0;n<t;n++)o[n]=arguments[n];null==e.props.onReset||(r=e.props).onReset.apply(r,o),e.reset()},e}n=r,(o=a).prototype=Object.create(n.prototype),o.prototype.constructor=o,o.__proto__=n,a.getDerivedStateFromError=function(r){return{error:r}};var i=a.prototype;return i.reset=function(){this.updatedWithError=!1,this.setState(t)},i.componentDidCatch=function(r,e){var t,o;null==(t=(o=this.props).onError)||t.call(o,r,e)},i.componentDidUpdate=function(r){var e,t,o,n,a=this.state.error,i=this.props.resetKeys;null===a||this.updatedWithError?null!==a&&(void 0===(o=r.resetKeys)&&(o=[]),void 0===(n=i)&&(n=[]),o.length!==n.length||o.some((function(r,e){return!Object.is(r,n[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,t=this.props,o=t.fallbackRender,n=t.FallbackComponent,a=t.fallback;if(null!==r){var i={error:r,resetErrorBoundary:this.resetErrorBoundary};if(e.isValidElement(a))return a;if("function"==typeof o)return o(i);if(n)return e.createElement(n,i);throw new Error("react-error-boundary requires either a fallback, fallbackRender, or FallbackComponent prop")}return this.props.children},a}(e.Component);r.ErrorBoundary=o,r.useErrorHandler=function(r){var t=e.useState(null),o=t[0],n=t[1];if(r)throw r;if(o)throw o;return n},r.withErrorBoundary=function(r,t){var n=function(n){return e.createElement(o,t,e.createElement(r,n))},a=r.displayName||r.name||"Unknown";return n.displayName="withErrorBoundary("+a+")",n},Object.defineProperty(r,"__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){if(e&&e.__esModule)return e;var r=Object.create(null);return e&&Object.keys(e).forEach((function(t){if("default"!==t){var n=Object.getOwnPropertyDescriptor(e,t);Object.defineProperty(r,t,n.get?n:{enumerable:!0,get:function(){return e[t]}})}})),r.default=e,Object.freeze(r)}var n=t(r);function o(e,r){return o=Object.setPrototypeOf||function(e,r){return e.__proto__=r,e},o(e,r)}var a={error:null},u=function(e){var r,t;function u(){for(var r,t=arguments.length,n=new Array(t),o=0;o<t;o++)n[o]=arguments[o];return(r=e.call.apply(e,[this].concat(n))||this).state=a,r.resetErrorBoundary=function(){for(var e,t=arguments.length,n=new Array(t),o=0;o<t;o++)n[o]=arguments[o];null==r.props.onReset||(e=r.props).onReset.apply(e,n),r.reset()},r}t=e,(r=u).prototype=Object.create(t.prototype),r.prototype.constructor=r,o(r,t),u.getDerivedStateFromError=function(e){return{error:e}};var i=u.prototype;return i.reset=function(){this.setState(a)},i.componentDidCatch=function(e,r){var t,n;null==(t=(n=this.props).onError)||t.call(n,e,r)},i.componentDidUpdate=function(e,r){var t,n,o,a,u=this.state.error,i=this.props.resetKeys;null!==u&&null!==r.error&&(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==(t=(n=this.props).onResetKeysChange)||t.call(n,e.resetKeys,i),this.reset())},i.render=function(){var e=this.state.error,r=this.props,t=r.fallbackRender,o=r.FallbackComponent,a=r.fallback;if(null!==e){var u={error:e,resetErrorBoundary:this.resetErrorBoundary};if(n.isValidElement(a))return a;if("function"==typeof t)return t(u);if(o)return n.createElement(o,u);throw new Error("react-error-boundary requires either a fallback, fallbackRender, or FallbackComponent prop")}return this.props.children},u}(n.Component);e.ErrorBoundary=u,e.useErrorHandler=function(e){var r=n.useState(null),t=r[0],o=r[1];if(null!=e)throw e;if(null!=t)throw t;return o},e.withErrorBoundary=function(e,r){var t=function(t){return n.createElement(u,r,n.createElement(e,t))},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.tsx","../node_modules/@babel/runtime/helpers/esm/inheritsLoose.js"],"sourcesContent":["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  FallbackComponent: React.ComponentType<FallbackProps>\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  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}\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  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    // @ts-expect-error ts(2339) (at least one of these will be defined though, and we check for their existance)\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 as typeof 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<P = Error>(\n  givenError?: P | null | undefined,\n): React.Dispatch<React.SetStateAction<P | null>> {\n  const [error, setError] = React.useState<P | null>(null)\n  if (givenError) throw givenError\n  if (error) 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","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","React.createElement","Error","children","givenError","setError","Component","errorBoundaryProps","Wrapped","name","displayName"],"mappings":"6RAEA,IA0DMA,EAAmC,CAACC,MAAO,MAE3CC,cC9DS,IAAwBC,EAAUC,0IDsE/CC,MAAQL,IACRM,kBAAmB,IACnBC,mBAAqB,wCAAIC,2BAAAA,0BAClBC,MAAMC,cAAND,OAAMC,gBAAaF,KACnBG,WC1EwCP,KAAVD,KAC5BS,UAAYC,OAAOC,OAAOV,EAAWQ,WAC9CT,EAASS,UAAUG,YAAcZ,EACjCA,EAASa,UAAYZ,ID+Dda,yBAAP,SAAgChB,SACvB,CAACA,MAAAA,+BAUVU,MAAA,gBACOL,kBAAmB,OACnBY,SAASlB,MAGhBmB,kBAAA,SAAkBlB,EAAcmB,4BACzBX,OAAMY,mBAAUpB,EAAOmB,MAG9BE,mBAAA,SAAmBC,WApFCC,EAAwBC,EAqFnCxB,EAASyB,KAAKrB,MAAdJ,MACA0B,EAAaD,KAAKjB,MAAlBkB,UAQO,OAAV1B,GAAmByB,KAAKpB,iBAKd,OAAVL,cAnGcuB,EAmGiBD,EAAUI,aAnG3BH,EAAoB,cAAIC,EAmGcE,KAnGdF,EAAoB,IAChED,EAAEI,SAAWH,EAAEG,QAAUJ,EAAEK,MAAK,SAACC,EAAMC,UAAWlB,OAAOmB,GAAGF,EAAML,EAAEM,2BAmG3DtB,OAAMwB,6BAAoBV,EAAUI,UAAWA,QAC/ChB,cANAL,kBAAmB,KAU5B4B,OAAA,eACSjC,EAASyB,KAAKrB,MAAdJ,QAE+CyB,KAAKjB,MAApD0B,IAAAA,eAAgBC,IAAAA,kBAAmBC,IAAAA,YAE5B,OAAVpC,EAAgB,KACZQ,EAAQ,CACZR,MAAAA,EACAM,mBAAoBmB,KAAKnB,uBAEvB+B,iBAAqBD,UAChBA,EACF,GAA8B,mBAAnBF,SACRA,EAAyC1B,GAC5C,GAAI2B,SACFG,gBAACH,EAAsB3B,SAExB,IAAI+B,MACR,qGAKCd,KAAKjB,MAAMgC,aApEMH,iDA2F5B,SACEI,SAE0BJ,WAAyB,MAA5CrC,OAAO0C,UACVD,EAAY,MAAMA,KAClBzC,EAAO,MAAMA,SACV0C,uBAzBT,SACEC,EACAC,OAEMC,EAAkC,SAAArC,UAEpC8B,gBAACrC,EAAkB2C,EACjBN,gBAACK,EAAcnC,KAMfsC,EAAOH,EAAUI,aAAeJ,EAAUG,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  resetErrorBoundary = (...args: Array<unknown>) => {\n    this.props.onReset?.(...args)\n    this.reset()\n  }\n\n  reset() {\n    this.setState(initialState)\n  }\n\n  componentDidCatch(error: Error, info: React.ErrorInfo) {\n    this.props.onError?.(error, info)\n  }\n\n  componentDidUpdate(\n    prevProps: ErrorBoundaryProps,\n    prevState: ErrorBoundaryState,\n  ) {\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\n    if (\n      error !== null &&\n      prevState.error !== null &&\n      changedArray(prevProps.resetKeys, resetKeys)\n    ) {\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/sort-type-union-intersection-members: \"off\",\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","resetErrorBoundary","args","props","onReset","reset","prototype","create","constructor","getDerivedStateFromError","setState","componentDidCatch","info","onError","componentDidUpdate","prevProps","prevState","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":"ukBAAe,SAASA,EAAgBC,EAAGC,UACzCF,EAAkBG,OAAOC,gBAAkB,SAAyBH,EAAGC,UACrED,EAAEI,UAAYH,EACPD,GAGFD,EAAgBC,EAAGC,GCJ5B,IAgEMI,EAAmC,CAACC,MAAO,MAE3CC,cCnES,IAAwBC,EAAUC,0ID2E/CC,MAAQL,IACRM,mBAAqB,wCAAIC,2BAAAA,0BAClBC,MAAMC,cAAND,OAAMC,gBAAaF,KACnBG,WC9EwCN,KAAVD,KAC5BQ,UAAYd,OAAOe,OAAOR,EAAWO,WAC9CR,EAASQ,UAAUE,YAAcV,EACjCL,EAAeK,EAAUC,KDoElBU,yBAAP,SAAgCb,SACvB,CAACA,MAAAA,+BASVS,MAAA,gBACOK,SAASf,MAGhBgB,kBAAA,SAAkBf,EAAcgB,4BACzBT,OAAMU,mBAAUjB,EAAOgB,MAG9BE,mBAAA,SACEC,EACAC,WA1FkBC,EAAwBC,EA4FnCtB,EAASuB,KAAKnB,MAAdJ,MACAwB,EAAaD,KAAKhB,MAAlBiB,UAUK,OAAVxB,GACoB,OAApBoB,EAAUpB,kBAxGMqB,EAyGHF,EAAUK,aAzGPH,EAAoB,cAAIC,EAyGNE,KAzGMF,EAAoB,IAChED,EAAEI,SAAWH,EAAEG,QAAUJ,EAAEK,MAAK,SAACC,EAAMC,UAAWhC,OAAOiC,GAAGF,EAAML,EAAEM,2BA0G3DrB,OAAMuB,6BAAoBX,EAAUK,UAAWA,QAC/Cf,YAITsB,OAAA,eACS/B,EAASuB,KAAKnB,MAAdJ,QAE+CuB,KAAKhB,MAApDyB,IAAAA,eAAgBC,IAAAA,kBAAmBC,IAAAA,YAE5B,OAAVlC,EAAgB,KACZO,EAAQ,CACZP,MAAAA,EACAK,mBAAoBkB,KAAKlB,uBAEvB8B,EAAMC,eAAeF,UAChBA,EACF,GAA8B,mBAAnBF,SACTA,EAAezB,GACjB,GAAI0B,SACFE,gBAACF,EAAsB1B,SAExB,IAAI8B,MACR,qGAKCd,KAAKhB,MAAM+B,aArEMH,EAAMI,+CA4FlC,SAAyBC,SACGL,EAAMM,SAAkB,MAA3CzC,OAAO0C,UACI,MAAdF,EAAoB,MAAMA,KACjB,MAATxC,EAAe,MAAMA,SAClB0C,uBAvBT,SACEH,EACAI,OAEMC,EAAkC,SAAArC,UAEpC4B,gBAAClC,EAAkB0C,EACjBR,gBAACI,EAAchC,KAMfsC,EAAON,EAAUO,aAAeP,EAAUM,MAAQ,iBACxDD,EAAQE,iCAAmCD,MAEpCD"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-error-boundary",
-  "version": "3.1.0",
+  "version": "3.1.4",
   "description": "Simple reusable React error boundary component",
   "main": "dist/react-error-boundary.cjs.js",
   "module": "dist/react-error-boundary.esm.js",